diff --git a/webrtc/call/bitrate_allocator.cc b/webrtc/call/bitrate_allocator.cc index 5bd1a2c93e..c3568df34c 100644 --- a/webrtc/call/bitrate_allocator.cc +++ b/webrtc/call/bitrate_allocator.cc @@ -54,7 +54,9 @@ BitrateAllocator::BitrateAllocator(LimitObserver* limit_observer) last_rtt_(0), num_pause_events_(0), clock_(Clock::GetRealTimeClock()), - last_bwe_log_time_(0) { + last_bwe_log_time_(0), + total_requested_padding_bitrate_(0), + total_requested_min_bitrate_(0) { sequenced_checker_.Detach(); } @@ -115,6 +117,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, config.media_ratio = MediaRatio(allocated_bitrate, protection_bitrate); config.allocated_bitrate_bps = allocated_bitrate; } + UpdateAllocationLimits(); } void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer, @@ -167,12 +170,24 @@ void BitrateAllocator::UpdateAllocationLimits() { uint32_t total_requested_min_bitrate = 0; for (const auto& config : bitrate_observer_configs_) { + uint32_t stream_padding = config.pad_up_bitrate_bps; if (config.enforce_min_bitrate) { total_requested_min_bitrate += config.min_bitrate_bps; + } else if (config.allocated_bitrate_bps == 0) { + stream_padding = + std::max(MinBitrateWithHysteresis(config), stream_padding); } - total_requested_padding_bitrate += config.pad_up_bitrate_bps; + total_requested_padding_bitrate += stream_padding; } + if (total_requested_padding_bitrate == total_requested_padding_bitrate_ && + total_requested_min_bitrate == total_requested_min_bitrate_) { + return; + } + + total_requested_min_bitrate_ = total_requested_min_bitrate; + total_requested_padding_bitrate_ = total_requested_padding_bitrate; + LOG(LS_INFO) << "UpdateAllocationLimits : total_requested_min_bitrate: " << total_requested_min_bitrate << "bps, total_requested_padding_bitrate: " @@ -416,8 +431,9 @@ bool BitrateAllocator::EnoughBitrateForAllObservers(uint32_t bitrate, static_cast(bitrate_observer_configs_.size()); for (const auto& observer_config : bitrate_observer_configs_) { if (observer_config.min_bitrate_bps + extra_bitrate_per_observer < - MinBitrateWithHysteresis(observer_config)) + MinBitrateWithHysteresis(observer_config)) { return false; + } } return true; } diff --git a/webrtc/call/bitrate_allocator.h b/webrtc/call/bitrate_allocator.h index cd3b2e163b..f133fa1723 100644 --- a/webrtc/call/bitrate_allocator.h +++ b/webrtc/call/bitrate_allocator.h @@ -165,6 +165,8 @@ class BitrateAllocator { int num_pause_events_ GUARDED_BY(&sequenced_checker_); Clock* const clock_ GUARDED_BY(&sequenced_checker_); int64_t last_bwe_log_time_ GUARDED_BY(&sequenced_checker_); + uint32_t total_requested_padding_bitrate_ GUARDED_BY(&sequenced_checker_); + uint32_t total_requested_min_bitrate_ GUARDED_BY(&sequenced_checker_); }; } // namespace webrtc #endif // WEBRTC_CALL_BITRATE_ALLOCATOR_H_ diff --git a/webrtc/call/bitrate_allocator_unittest.cc b/webrtc/call/bitrate_allocator_unittest.cc index 751ec93657..ead4cbdf94 100644 --- a/webrtc/call/bitrate_allocator_unittest.cc +++ b/webrtc/call/bitrate_allocator_unittest.cc @@ -98,8 +98,6 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { true); EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); - EXPECT_CALL(limit_observer_, - OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, true); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); @@ -183,7 +181,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { TestBitrateObserver bitrate_observer_1; // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // AddObserver is called with |enforce_min_bitrate| = false. - EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); + EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000)); allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); @@ -264,7 +262,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { TestBitrateObserver bitrate_observer; // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // AddObserver is called with |enforce_min_bitrate| = false. - EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); + EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000)); allocator_->AddObserver( &bitrate_observer, 100000, 400000, 0, false); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); @@ -292,6 +290,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); // Just enough to enable video again. + EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); allocator_->OnNetworkChanged(168000, 0, fraction_loss, kDefaultProbingIntervalMs); EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_); @@ -304,7 +303,6 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { allocator_->OnNetworkChanged(139000, 0, 0, kDefaultProbingIntervalMs); EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_); - EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); allocator_->RemoveObserver(&bitrate_observer); } diff --git a/webrtc/call/rampup_tests.cc b/webrtc/call/rampup_tests.cc index 46e97cd2a5..94153b08ae 100644 --- a/webrtc/call/rampup_tests.cc +++ b/webrtc/call/rampup_tests.cc @@ -11,6 +11,7 @@ #include "webrtc/call/rampup_tests.h" #include "webrtc/base/checks.h" +#include "webrtc/base/logging.h" #include "webrtc/base/platform_thread.h" #include "webrtc/test/encoder_settings.h" #include "webrtc/test/gtest.h" @@ -20,7 +21,7 @@ namespace webrtc { namespace { static const int64_t kPollIntervalMs = 20; -static const int kExpectedHighVideoBitrateBps = 60000; +static const int kExpectedHighVideoBitrateBps = 80000; static const int kExpectedHighAudioBitrateBps = 30000; static const int kLowBandwidthLimitBps = 20000; static const int kExpectedLowBitrateBps = 20000; @@ -35,6 +36,7 @@ std::vector GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) { RampUpTester::RampUpTester(size_t num_video_streams, size_t num_audio_streams, + size_t num_flexfec_streams, unsigned int start_bitrate_bps, int64_t min_run_time_ms, const std::string& extension_type, @@ -46,6 +48,7 @@ RampUpTester::RampUpTester(size_t num_video_streams, clock_(Clock::GetRealTimeClock()), num_video_streams_(num_video_streams), num_audio_streams_(num_audio_streams), + num_flexfec_streams_(num_flexfec_streams), rtx_(rtx), red_(red), sender_call_(nullptr), @@ -63,6 +66,8 @@ RampUpTester::RampUpTester(size_t num_video_streams, poller_thread_(&BitrateStatsPollingThread, this, "BitrateStatsPollingThread") { + if (red_) + EXPECT_EQ(0u, num_flexfec_streams_); EXPECT_LE(num_audio_streams_, 1u); } @@ -100,6 +105,10 @@ size_t RampUpTester::GetNumAudioStreams() const { return num_audio_streams_; } +size_t RampUpTester::GetNumFlexfecStreams() const { + return num_flexfec_streams_; +} + class RampUpTester::VideoStreamFactory : public VideoEncoderConfig::VideoStreamFactoryInterface { public: @@ -209,6 +218,13 @@ void RampUpTester::ModifyVideoConfigs( } ++i; } + + RTC_DCHECK_LE(num_flexfec_streams_, 1); + if (num_flexfec_streams_ == 1) { + send_config->rtp.flexfec.payload_type = test::CallTest::kFlexfecPayloadType; + send_config->rtp.flexfec.ssrc = test::CallTest::kFlexfecSendSsrc; + send_config->rtp.flexfec.protected_media_ssrcs = {video_ssrcs_[0]}; + } } void RampUpTester::ModifyAudioConfigs( @@ -219,6 +235,8 @@ void RampUpTester::ModifyAudioConfigs( EXPECT_NE(RtpExtension::kTimestampOffsetUri, extension_type_) << "Audio BWE not supported with toffset."; + EXPECT_NE(RtpExtension::kAbsSendTimeUri, extension_type_) + << "Audio BWE not supported with abs-send-time."; send_config->rtp.ssrc = audio_ssrcs_[0]; send_config->rtp.extensions.clear(); @@ -227,11 +245,7 @@ void RampUpTester::ModifyAudioConfigs( send_config->max_bitrate_bps = 60000; bool transport_cc = false; - if (extension_type_ == RtpExtension::kAbsSendTimeUri) { - transport_cc = false; - send_config->rtp.extensions.push_back( - RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId)); - } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) { + if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) { transport_cc = true; send_config->rtp.extensions.push_back(RtpExtension( extension_type_.c_str(), kTransportSequenceNumberExtensionId)); @@ -244,6 +258,26 @@ void RampUpTester::ModifyAudioConfigs( } } +void RampUpTester::ModifyFlexfecConfigs( + std::vector* receive_configs) { + if (num_flexfec_streams_ == 0) + return; + RTC_DCHECK_EQ(1, num_flexfec_streams_); + (*receive_configs)[0].payload_type = test::CallTest::kFlexfecPayloadType; + (*receive_configs)[0].remote_ssrc = test::CallTest::kFlexfecSendSsrc; + (*receive_configs)[0].protected_media_ssrcs = {video_ssrcs_[0]}; + (*receive_configs)[0].local_ssrc = video_ssrcs_[0]; + if (extension_type_ == RtpExtension::kAbsSendTimeUri) { + (*receive_configs)[0].transport_cc = false; + (*receive_configs)[0].rtp_header_extensions.push_back( + RtpExtension(extension_type_.c_str(), kAbsSendTimeExtensionId)); + } else if (extension_type_ == RtpExtension::kTransportSequenceNumberUri) { + (*receive_configs)[0].transport_cc = true; + (*receive_configs)[0].rtp_header_extensions.push_back(RtpExtension( + extension_type_.c_str(), kTransportSequenceNumberExtensionId)); + } +} + void RampUpTester::OnCallsCreated(Call* sender_call, Call* receiver_call) { sender_call_ = sender_call; } @@ -351,23 +385,32 @@ void RampUpTester::PerformTest() { RampUpDownUpTester::RampUpDownUpTester(size_t num_video_streams, size_t num_audio_streams, + size_t num_flexfec_streams, unsigned int start_bitrate_bps, const std::string& extension_type, bool rtx, - bool red) + bool red, + const std::vector& loss_rates) : RampUpTester(num_video_streams, num_audio_streams, + num_flexfec_streams, start_bitrate_bps, 0, extension_type, rtx, red, true), + link_rates_({GetHighLinkCapacity(), kLowBandwidthLimitBps / 1000, + GetHighLinkCapacity(), 0}), test_state_(kFirstRampup), + next_state_(kTransitionToNextState), state_start_ms_(clock_->TimeInMilliseconds()), interval_start_ms_(clock_->TimeInMilliseconds()), - sent_bytes_(0) { - forward_transport_config_.link_capacity_kbps = GetHighLinkCapacity(); + sent_bytes_(0), + loss_rates_(loss_rates) { + forward_transport_config_.link_capacity_kbps = link_rates_[test_state_]; + forward_transport_config_.queue_delay_ms = 100; + forward_transport_config_.loss_percent = loss_rates_[test_state_]; } RampUpDownUpTester::~RampUpDownUpTester() {} @@ -432,57 +475,79 @@ int RampUpDownUpTester::GetHighLinkCapacity() const { return 4 * GetExpectedHighBitrate() / (3 * 1000); } +size_t RampUpDownUpTester::GetFecBytes() const { + size_t flex_fec_bytes = 0; + if (num_flexfec_streams_ > 0) { + webrtc::VideoSendStream::Stats stats = send_stream_->GetStats(); + for (const auto& kv : stats.substreams) + flex_fec_bytes += kv.second.rtp_stats.fec.TotalBytes(); + } + return flex_fec_bytes; +} + +bool RampUpDownUpTester::ExpectingFec() const { + return num_flexfec_streams_ > 0 && forward_transport_config_.loss_percent > 0; +} + void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) { int64_t now = clock_->TimeInMilliseconds(); switch (test_state_) { - case kFirstRampup: { + case kFirstRampup: EXPECT_FALSE(suspended); if (bitrate_bps >= GetExpectedHighBitrate()) { - // The first ramp-up has reached the target bitrate. Change the - // channel limit, and move to the next test state. - forward_transport_config_.link_capacity_kbps = - kLowBandwidthLimitBps / 1000; - send_transport_->SetConfig(forward_transport_config_); - test_state_ = kLowRate; webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(), "first_rampup", now - state_start_ms_, "ms", false); - state_start_ms_ = now; - interval_start_ms_ = now; - sent_bytes_ = 0; + // Apply loss during the transition between states if FEC is enabled. + forward_transport_config_.loss_percent = loss_rates_[test_state_]; + test_state_ = kTransitionToNextState; + next_state_ = kLowRate; } break; - } case kLowRate: { // Audio streams are never suspended. bool check_suspend_state = num_video_streams_ > 0; if (bitrate_bps < kExpectedLowBitrateBps && suspended == check_suspend_state) { - // The ramp-down was successful. Change the channel limit back to a - // high value, and move to the next test state. - forward_transport_config_.link_capacity_kbps = GetHighLinkCapacity(); - send_transport_->SetConfig(forward_transport_config_); - test_state_ = kSecondRampup; webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(), "rampdown", now - state_start_ms_, "ms", false); - state_start_ms_ = now; - interval_start_ms_ = now; - sent_bytes_ = 0; + // Apply loss during the transition between states if FEC is enabled. + forward_transport_config_.loss_percent = loss_rates_[test_state_]; + test_state_ = kTransitionToNextState; + next_state_ = kSecondRampup; } break; } - case kSecondRampup: { + case kSecondRampup: if (bitrate_bps >= GetExpectedHighBitrate() && !suspended) { webrtc::test::PrintResult("ramp_up_down_up", GetModifierString(), "second_rampup", now - state_start_ms_, "ms", false); ReportResult("ramp-up-down-up-average-network-latency", send_transport_->GetAverageDelayMs(), "milliseconds"); - observation_complete_.Set(); + // Apply loss during the transition between states if FEC is enabled. + forward_transport_config_.loss_percent = loss_rates_[test_state_]; + test_state_ = kTransitionToNextState; + next_state_ = kTestEnd; + } + break; + case kTestEnd: + observation_complete_.Set(); + break; + case kTransitionToNextState: + if (!ExpectingFec() || GetFecBytes() > 0) { + test_state_ = next_state_; + forward_transport_config_.link_capacity_kbps = link_rates_[test_state_]; + // No loss while ramping up and down as it may affect the BWE + // negatively, making the test flaky. + forward_transport_config_.loss_percent = 0; + state_start_ms_ = now; + interval_start_ms_ = now; + sent_bytes_ = 0; + send_transport_->SetConfig(forward_transport_config_); } break; - } } } @@ -499,70 +564,83 @@ class RampUpTest : public test::CallTest { static const uint32_t kStartBitrateBps = 60000; TEST_F(RampUpTest, UpDownUpAbsSendTimeSimulcastRedRtx) { - RampUpDownUpTester test(3, 0, kStartBitrateBps, RtpExtension::kAbsSendTimeUri, - true, true); + std::vector loss_rates = {0, 0, 0, 0}; + RampUpDownUpTester test(3, 0, 0, kStartBitrateBps, + RtpExtension::kAbsSendTimeUri, true, true, + loss_rates); RunBaseTest(&test); } TEST_F(RampUpTest, UpDownUpTransportSequenceNumberRtx) { - RampUpDownUpTester test(3, 0, kStartBitrateBps, + std::vector loss_rates = {0, 0, 0, 0}; + RampUpDownUpTester test(3, 0, 0, kStartBitrateBps, RtpExtension::kTransportSequenceNumberUri, true, - false); + false, loss_rates); + RunBaseTest(&test); +} + +TEST_F(RampUpTest, UpDownUpTransportSequenceNumberPacketLoss) { + std::vector loss_rates = {20, 0, 0, 0}; + RampUpDownUpTester test(1, 0, 1, kStartBitrateBps, + RtpExtension::kTransportSequenceNumberUri, true, + false, loss_rates); RunBaseTest(&test); } TEST_F(RampUpTest, UpDownUpAudioVideoTransportSequenceNumberRtx) { - RampUpDownUpTester test(3, 1, kStartBitrateBps, + std::vector loss_rates = {0, 0, 0, 0}; + RampUpDownUpTester test(3, 1, 0, kStartBitrateBps, RtpExtension::kTransportSequenceNumberUri, true, - false); + false, loss_rates); RunBaseTest(&test); } TEST_F(RampUpTest, UpDownUpAudioTransportSequenceNumberRtx) { - RampUpDownUpTester test(0, 1, kStartBitrateBps, + std::vector loss_rates = {0, 0, 0, 0}; + RampUpDownUpTester test(0, 1, 0, kStartBitrateBps, RtpExtension::kTransportSequenceNumberUri, true, - false); + false, loss_rates); RunBaseTest(&test); } TEST_F(RampUpTest, TOffsetSimulcastRedRtx) { - RampUpTester test(3, 0, 0, 0, RtpExtension::kTimestampOffsetUri, true, true, - true); + RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTimestampOffsetUri, true, + true, true); RunBaseTest(&test); } TEST_F(RampUpTest, AbsSendTime) { - RampUpTester test(1, 0, 0, 0, RtpExtension::kAbsSendTimeUri, false, false, + RampUpTester test(1, 0, 0, 0, 0, RtpExtension::kAbsSendTimeUri, false, false, true); RunBaseTest(&test); } TEST_F(RampUpTest, AbsSendTimeSimulcastRedRtx) { - RampUpTester test(3, 0, 0, 0, RtpExtension::kAbsSendTimeUri, true, true, + RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kAbsSendTimeUri, true, true, true); RunBaseTest(&test); } TEST_F(RampUpTest, TransportSequenceNumber) { - RampUpTester test(1, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, + RampUpTester test(1, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, false, false, true); RunBaseTest(&test); } TEST_F(RampUpTest, TransportSequenceNumberSimulcast) { - RampUpTester test(3, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, + RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, false, false, true); RunBaseTest(&test); } TEST_F(RampUpTest, TransportSequenceNumberSimulcastRedRtx) { - RampUpTester test(3, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, + RampUpTester test(3, 0, 0, 0, 0, RtpExtension::kTransportSequenceNumberUri, true, true, true); RunBaseTest(&test); } TEST_F(RampUpTest, AudioTransportSequenceNumber) { - RampUpTester test(0, 1, 300000, 10000, + RampUpTester test(0, 1, 0, 300000, 10000, RtpExtension::kTransportSequenceNumberUri, false, false, false); RunBaseTest(&test); diff --git a/webrtc/call/rampup_tests.h b/webrtc/call/rampup_tests.h index 5cf4c4fab5..65276ea265 100644 --- a/webrtc/call/rampup_tests.h +++ b/webrtc/call/rampup_tests.h @@ -33,6 +33,7 @@ class RampUpTester : public test::EndToEndTest { public: RampUpTester(size_t num_video_streams, size_t num_audio_streams, + size_t num_flexfec_streams, unsigned int start_bitrate_bps, int64_t min_run_time_ms, const std::string& extension_type, @@ -43,6 +44,7 @@ class RampUpTester : public test::EndToEndTest { size_t GetNumVideoStreams() const override; size_t GetNumAudioStreams() const override; + size_t GetNumFlexfecStreams() const override; void PerformTest() override; @@ -66,6 +68,7 @@ class RampUpTester : public test::EndToEndTest { FakeNetworkPipe::Config forward_transport_config_; const size_t num_video_streams_; const size_t num_audio_streams_; + const size_t num_flexfec_streams_; const bool rtx_; const bool red_; Call* sender_call_; @@ -88,6 +91,8 @@ class RampUpTester : public test::EndToEndTest { void ModifyAudioConfigs( AudioSendStream::Config* send_config, std::vector* receive_configs) override; + void ModifyFlexfecConfigs( + std::vector* receive_configs) override; void OnCallsCreated(Call* sender_call, Call* receiver_call) override; static bool BitrateStatsPollingThread(void* obj); @@ -111,29 +116,42 @@ class RampUpDownUpTester : public RampUpTester { public: RampUpDownUpTester(size_t num_video_streams, size_t num_audio_streams, + size_t num_flexfec_streams, unsigned int start_bitrate_bps, const std::string& extension_type, bool rtx, - bool red); + bool red, + const std::vector& loss_rates); ~RampUpDownUpTester() override; protected: bool PollStats() override; private: - enum TestStates { kFirstRampup, kLowRate, kSecondRampup }; + enum TestStates { + kFirstRampup = 0, + kLowRate, + kSecondRampup, + kTestEnd, + kTransitionToNextState, + }; Call::Config GetReceiverCallConfig() override; std::string GetModifierString() const; int GetExpectedHighBitrate() const; int GetHighLinkCapacity() const; + size_t GetFecBytes() const; + bool ExpectingFec() const; void EvolveTestState(int bitrate_bps, bool suspended); + const std::vector link_rates_; TestStates test_state_; + TestStates next_state_; int64_t state_start_ms_; int64_t interval_start_ms_; int sent_bytes_; + std::vector loss_rates_; }; } // namespace webrtc #endif // WEBRTC_CALL_RAMPUP_TESTS_H_ diff --git a/webrtc/test/call_test.cc b/webrtc/test/call_test.cc index 833e53c465..68d6857e29 100644 --- a/webrtc/test/call_test.cc +++ b/webrtc/test/call_test.cc @@ -215,7 +215,7 @@ void CallTest::CreateSendConfig(size_t num_video_streams, audio_send_config_.voe_channel_id = voe_send_.channel_id; audio_send_config_.rtp.ssrc = kAudioSendSsrc; audio_send_config_.send_codec_spec.codec_inst = - CodecInst{kAudioSendPayloadType, "ISAC", 16000, 480, 1, 32000}; + CodecInst{kAudioSendPayloadType, "OPUS", 48000, 960, 2, 64000}; } // TODO(brandtr): Update this when we support multistream protection. diff --git a/webrtc/test/encoder_settings.cc b/webrtc/test/encoder_settings.cc index 061fafcb07..570fff5ed5 100644 --- a/webrtc/test/encoder_settings.cc +++ b/webrtc/test/encoder_settings.cc @@ -24,7 +24,7 @@ const size_t DefaultVideoStreamFactory::kMaxNumberOfStreams; const int DefaultVideoStreamFactory::kMaxBitratePerStream[] = {150000, 450000, 1500000}; const int DefaultVideoStreamFactory::kDefaultMinBitratePerStream[] = { - 50000, 200000, 700000}; + 30000, 200000, 700000}; // static std::vector CreateVideoStreams( diff --git a/webrtc/test/fake_network_pipe.cc b/webrtc/test/fake_network_pipe.cc index 0b3aa6ac71..d594ab8104 100644 --- a/webrtc/test/fake_network_pipe.cc +++ b/webrtc/test/fake_network_pipe.cc @@ -33,31 +33,14 @@ FakeNetworkPipe::FakeNetworkPipe(Clock* clock, : clock_(clock), packet_receiver_(NULL), random_(seed), - config_(config), + config_(), dropped_packets_(0), sent_packets_(0), total_packet_delay_(0), bursting_(false), next_process_time_(clock_->TimeInMilliseconds()), last_log_time_(clock_->TimeInMilliseconds()) { - double prob_loss = config.loss_percent / 100.0; - if (config_.avg_burst_loss_length == -1) { - // Uniform loss - prob_loss_bursting_ = prob_loss; - prob_start_bursting_ = prob_loss; - } else { - // Lose packets according to a gilbert-elliot model. - int avg_burst_loss_length = config.avg_burst_loss_length; - int min_avg_burst_loss_length = std::ceil(prob_loss / (1 - prob_loss)); - - RTC_CHECK_GT(avg_burst_loss_length, min_avg_burst_loss_length) - << "For a total packet loss of " << config.loss_percent << "%% then" - << " avg_burst_loss_length must be " << min_avg_burst_loss_length + 1 - << " or higher."; - - prob_loss_bursting_ = (1.0 - 1.0 / avg_burst_loss_length); - prob_start_bursting_ = prob_loss / (1 - prob_loss) / avg_burst_loss_length; - } + SetConfig(config); } FakeNetworkPipe::~FakeNetworkPipe() { @@ -78,6 +61,24 @@ void FakeNetworkPipe::SetReceiver(PacketReceiver* receiver) { void FakeNetworkPipe::SetConfig(const FakeNetworkPipe::Config& config) { rtc::CritScope crit(&lock_); config_ = config; // Shallow copy of the struct. + double prob_loss = config.loss_percent / 100.0; + if (config_.avg_burst_loss_length == -1) { + // Uniform loss + prob_loss_bursting_ = prob_loss; + prob_start_bursting_ = prob_loss; + } else { + // Lose packets according to a gilbert-elliot model. + int avg_burst_loss_length = config.avg_burst_loss_length; + int min_avg_burst_loss_length = std::ceil(prob_loss / (1 - prob_loss)); + + RTC_CHECK_GT(avg_burst_loss_length, min_avg_burst_loss_length) + << "For a total packet loss of " << config.loss_percent << "%% then" + << " avg_burst_loss_length must be " << min_avg_burst_loss_length + 1 + << " or higher."; + + prob_loss_bursting_ = (1.0 - 1.0 / avg_burst_loss_length); + prob_start_bursting_ = prob_loss / (1 - prob_loss) / avg_burst_loss_length; + } } void FakeNetworkPipe::SendPacket(const uint8_t* data, size_t data_length) {