admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor bitrate configuration in CallTest

Browse Source 
All implementations of ModifyReceiverCallConfig and
ModifySenderCallConfig configure the bitrate_config member only. So
replace these methods by ModifyReceiverBitrateConfig and
ModifySenderBitrateConfig.

This is a preparation for injecting RtpTransportControllerSend via
CallConfig. Then bitrates should be passed when constructing
RtpTransportControllerSend, and they can be deleted from CallConfig.

Bug: webrtc:7135
Change-Id: I6714158bd463dd485018713d0e26815919e5afcc
Reviewed-on: https://webrtc-review.googlesource.com/c/110780
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25624}
This commit is contained in:
Niels Möller 2018-11-13 15:10:33 +01:00 committed by Commit Bot
parent c7e3af1ad9
commit de8e6e6db3
12 changed files with 46 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
call/call_perf_tests.cc
View File

@ -770,8 +770,9 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
return FakeEncoder::SetRateAllocation(rate_allocation, framerate);
}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = kInitialBitrateKbps * 1000;
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->start_bitrate_bps = kInitialBitrateKbps * 1000;
}
void ModifyVideoConfigs(

12
call/rampup_tests.cc
View File

@ -84,11 +84,12 @@ RampUpTester::RampUpTester(size_t num_video_streams,
RampUpTester::~RampUpTester() {}
void RampUpTester::ModifySenderCallConfig(Call::Config* config) {
void RampUpTester::ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) {
if (start_bitrate_bps_ != 0) {
config->bitrate_config.start_bitrate_bps = start_bitrate_bps_;
bitrate_config->start_bitrate_bps = start_bitrate_bps_;
}
config->bitrate_config.min_bitrate_bps = 10000;
bitrate_config->min_bitrate_bps = 10000;
}
void RampUpTester::OnVideoStreamsCreated(
@ -453,8 +454,9 @@ void RampUpDownUpTester::PollStats() {
} while (!stop_event_.Wait(kPollIntervalMs));
}
void RampUpDownUpTester::ModifyReceiverCallConfig(Call::Config* config) {
config->bitrate_config.min_bitrate_bps = 10000;
void RampUpDownUpTester::ModifyReceiverBitrateConfig(
BitrateConstraints* bitrate_config) {
bitrate_config->min_bitrate_bps = 10000;
}
std::string RampUpDownUpTester::GetModifierString() const {

4
call/rampup_tests.h
View File

@ -83,7 +83,7 @@ class RampUpTester : public test::EndToEndTest {
typedef std::map<uint32_t, uint32_t> SsrcMap;
class VideoStreamFactory;
void ModifySenderCallConfig(Call::Config* config) override;
void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) override;
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
@ -142,7 +142,7 @@ class RampUpDownUpTester : public RampUpTester {
kTransitionToNextState,
};
void ModifyReceiverCallConfig(Call::Config* config) override;
void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) override;
std::string GetModifierString() const;
int GetExpectedHighBitrate() const;

9
test/call_test.cc
View File

@ -78,7 +78,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
num_flexfec_streams_ = test->GetNumFlexfecStreams();
RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
Call::Config send_config(send_event_log_.get());
test->ModifySenderCallConfig(&send_config);
test->ModifySenderBitrateConfig(&send_config.bitrate_config);
if (num_audio_streams_ > 0) {
CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
test->OnFakeAudioDevicesCreated(fake_send_audio_device_.get(),
@ -102,7 +102,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
}
if (test->ShouldCreateReceivers()) {
Call::Config recv_config(recv_event_log_.get());
test->ModifyReceiverCallConfig(&recv_config);
test->ModifyReceiverBitrateConfig(&recv_config.bitrate_config);
if (num_audio_streams_ > 0) {
AudioState::Config audio_state_config;
audio_state_config.audio_mixer = AudioMixerImpl::Create();
@ -733,9 +733,10 @@ void BaseTest::OnFakeAudioDevicesCreated(
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device) {}
void BaseTest::ModifySenderCallConfig(Call::Config* config) {}
void BaseTest::ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) {}
void BaseTest::ModifyReceiverCallConfig(Call::Config* config) {}
void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
}
void BaseTest::OnRtpTransportControllerSendCreated(
RtpTransportControllerSend* controller) {}

4
test/call_test.h
View File

@ -243,8 +243,8 @@ class BaseTest : public RtpRtcpObserver {
TestAudioDeviceModule* send_audio_device,
TestAudioDeviceModule* recv_audio_device);
virtual void ModifySenderCallConfig(Call::Config* config);
virtual void ModifyReceiverCallConfig(Call::Config* config);
virtual void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config);
virtual void ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config);
virtual void OnRtpTransportControllerSendCreated(
RtpTransportControllerSend* controller);

5
video/end_to_end_tests/bandwidth_tests.cc
View File

@ -165,9 +165,10 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
return receive_transport_;
}
void ModifySenderCallConfig(Call::Config* config) override {
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
// Set a high start bitrate to reduce the test completion time.
config->bitrate_config.start_bitrate_bps = remb_bitrate_bps_;
bitrate_config->start_bitrate_bps = remb_bitrate_bps_;
}
void ModifyVideoConfigs(

5
video/end_to_end_tests/fec_tests.cc
View File

@ -433,9 +433,10 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
// TODO(holmer): Investigate why we don't send FEC packets when the bitrate
// is 10 kbps.
void ModifySenderCallConfig(Call::Config* config) override {
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
const int kMinBitrateBps = 30000;
config->bitrate_config.min_bitrate_bps = kMinBitrateBps;
bitrate_config->min_bitrate_bps = kMinBitrateBps;
}
void ModifyVideoConfigs(

4
video/end_to_end_tests/probing_tests.cc
View File

@ -41,8 +41,8 @@ class ProbingTest : public test::EndToEndTest {
state_(0),
sender_call_(nullptr) {}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = start_bitrate_bps_;
void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) override {
bitrate_config->start_bitrate_bps = start_bitrate_bps_;
}
void OnCallsCreated(Call* sender_call, Call* receiver_call) override {

9
video/end_to_end_tests/stats_tests.cc
View File

@ -239,8 +239,9 @@ TEST_F(StatsEndToEndTest, GetStats) {
Clock::GetRealTimeClock(),
absl::make_unique<SimulatedNetwork>(network_config)));
}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = kStartBitrateBps;
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->start_bitrate_bps = kStartBitrateBps;
}
// This test use other VideoStream settings than the the default settings
@ -514,9 +515,9 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
metrics::Reset();
Call::Config send_config(send_event_log_.get());
test.ModifySenderCallConfig(&send_config);
test.ModifySenderBitrateConfig(&send_config.bitrate_config);
Call::Config recv_config(recv_event_log_.get());
test.ModifyReceiverCallConfig(&recv_config);
test.ModifyReceiverBitrateConfig(&recv_config.bitrate_config);
VideoEncoderConfig encoder_config_with_screenshare;

5
video/end_to_end_tests/transport_feedback_tests.cc
View File

@ -414,8 +414,9 @@ TEST_P(TransportFeedbackEndToEndTest,
EXPECT_TRUE(parser.Parse(data, length));
return parser.transport_feedback()->num_packets() > 0;
}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.max_bitrate_bps = 300000;
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->max_bitrate_bps = 300000;
}
void PerformTest() override {

5
video/quality_scaling_tests.cc
View File

@ -103,8 +103,9 @@ void QualityScalingTest::RunTest(VideoEncoderFactory* encoder_factory,
if (wants.max_pixel_count < kWidth * kHeight)
observation_complete_.Set();
}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.start_bitrate_bps = start_bps_;
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->start_bitrate_bps = start_bps_;
}
void ModifyVideoConfigs(

14
video/video_send_stream_tests.cc
View File

@ -1119,9 +1119,10 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
}
encoder_.SetFrameSize(static_cast<size_t>(current_size_frame_));
}
void ModifySenderCallConfig(Call::Config* config) override {
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
const int kMinBitrateBps = 30000;
config->bitrate_config.min_bitrate_bps = kMinBitrateBps;
bitrate_config->min_bitrate_bps = kMinBitrateBps;
}
void ModifyVideoConfigs(
@ -2893,10 +2894,11 @@ TEST_P(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
EXPECT_EQ(expected_bitrate, target_bitrate_);
}
void ModifySenderCallConfig(Call::Config* config) override {
config->bitrate_config.min_bitrate_bps = kMinBitrateKbps * 1000;
config->bitrate_config.start_bitrate_bps = kStartBitrateKbps * 1000;
config->bitrate_config.max_bitrate_bps = kMaxBitrateKbps * 1000;
void ModifySenderBitrateConfig(
BitrateConstraints* bitrate_config) override {
bitrate_config->min_bitrate_bps = kMinBitrateKbps * 1000;
bitrate_config->start_bitrate_bps = kStartBitrateKbps * 1000;
bitrate_config->max_bitrate_bps = kMaxBitrateKbps * 1000;
}
class VideoStreamFactory