From 40de3cc5eff7f217c514f614ca6759f359d4f21a Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Thu, 19 Sep 2019 14:54:43 +0200 Subject: [PATCH] Propagating TargetRate struct to BitrateAllocator. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bug: webrtc:9883 Change-Id: I443ac7f1ef0f933e2165fdb2f912d314acc7f2f8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/153345 Commit-Queue: Sebastian Jansson Reviewed-by: Oskar Sundbom Reviewed-by: Björn Terelius Cr-Commit-Position: refs/heads/master@{#29241} --- audio/audio_send_stream_unittest.cc | 2 +- call/BUILD.gn | 1 + call/bitrate_allocator.cc | 45 ++- call/bitrate_allocator.h | 10 +- call/bitrate_allocator_unittest.cc | 273 +++++++++++------- call/call.cc | 20 +- .../pcc/pcc_network_controller.cc | 1 + .../rtp/control_handler.cc | 1 + 8 files changed, 200 insertions(+), 153 deletions(-) diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc index a61ce22554..948fcfed72 100644 --- a/audio/audio_send_stream_unittest.cc +++ b/audio/audio_send_stream_unittest.cc @@ -141,7 +141,7 @@ struct ConfigHelper { task_queue_factory_(CreateDefaultTaskQueueFactory()), stream_config_(/*send_transport=*/nullptr, MediaTransportConfig()), audio_processing_(new rtc::RefCountedObject()), - bitrate_allocator_(&clock_, &limit_observer_), + bitrate_allocator_(&limit_observer_), worker_queue_(task_queue_factory_->CreateTaskQueue( "ConfigHelper_worker_queue", TaskQueueFactory::Priority::NORMAL)), diff --git a/call/BUILD.gn b/call/BUILD.gn index cf70067236..92dedbdc5e 100644 --- a/call/BUILD.gn +++ b/call/BUILD.gn @@ -202,6 +202,7 @@ rtc_source_set("bitrate_allocator") { "../api/units:time_delta", "../rtc_base:checks", "../rtc_base:rtc_base_approved", + "../rtc_base:safe_minmax", "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "../system_wrappers:field_trial", diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc index c13848fb97..5362ceec5f 100644 --- a/call/bitrate_allocator.cc +++ b/call/bitrate_allocator.cc @@ -21,6 +21,7 @@ #include "api/units/time_delta.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" +#include "rtc_base/numerics/safe_minmax.h" #include "system_wrappers/include/clock.h" #include "system_wrappers/include/field_trial.h" #include "system_wrappers/include/metrics.h" @@ -51,7 +52,7 @@ double MediaRatio(uint32_t allocated_bitrate, uint32_t protection_bitrate) { } // namespace -BitrateAllocator::BitrateAllocator(Clock* clock, LimitObserver* limit_observer) +BitrateAllocator::BitrateAllocator(LimitObserver* limit_observer) : limit_observer_(limit_observer), last_target_bps_(0), last_stable_target_bps_(0), @@ -61,7 +62,6 @@ BitrateAllocator::BitrateAllocator(Clock* clock, LimitObserver* limit_observer) last_rtt_(0), last_bwe_period_ms_(1000), num_pause_events_(0), - clock_(clock), last_bwe_log_time_(0), transmission_max_bitrate_multiplier_( GetTransmissionMaxBitrateMultiplier()) { @@ -92,33 +92,32 @@ uint8_t BitrateAllocator::GetTransmissionMaxBitrateMultiplier() { return kTransmissionMaxBitrateMultiplier; } -void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, - uint32_t stable_target_bitrate_bps, - uint32_t bandwidth_bps, - uint8_t fraction_loss, - int64_t rtt, - int64_t bwe_period_ms) { +void BitrateAllocator::OnNetworkEstimateChanged(TargetTransferRate msg) { RTC_DCHECK_RUN_ON(&sequenced_checker_); - last_target_bps_ = target_bitrate_bps; - last_bandwidth_bps_ = bandwidth_bps; - last_stable_target_bps_ = stable_target_bitrate_bps; + last_target_bps_ = msg.target_rate.bps(); + last_bandwidth_bps_ = msg.network_estimate.bandwidth.bps(); + last_stable_target_bps_ = msg.stable_target_rate.bps(); last_non_zero_bitrate_bps_ = - target_bitrate_bps > 0 ? target_bitrate_bps : last_non_zero_bitrate_bps_; - last_fraction_loss_ = fraction_loss; - last_rtt_ = rtt; - last_bwe_period_ms_ = bwe_period_ms; + last_target_bps_ > 0 ? last_target_bps_ : last_non_zero_bitrate_bps_; + + int loss_ratio_255 = msg.network_estimate.loss_rate_ratio * 255; + last_fraction_loss_ = + rtc::dchecked_cast(rtc::SafeClamp(loss_ratio_255, 0, 255)); + last_rtt_ = msg.network_estimate.round_trip_time.ms(); + last_bwe_period_ms_ = msg.network_estimate.bwe_period.ms(); // Periodically log the incoming BWE. - int64_t now = clock_->TimeInMilliseconds(); + int64_t now = msg.at_time.ms(); if (now > last_bwe_log_time_ + kBweLogIntervalMs) { - RTC_LOG(LS_INFO) << "Current BWE " << target_bitrate_bps; + RTC_LOG(LS_INFO) << "Current BWE " << last_target_bps_; last_bwe_log_time_ = now; } - ObserverAllocation allocation = AllocateBitrates(target_bitrate_bps); - ObserverAllocation bandwidth_allocation = AllocateBitrates(bandwidth_bps); + ObserverAllocation allocation = AllocateBitrates(last_target_bps_); + ObserverAllocation bandwidth_allocation = + AllocateBitrates(last_bandwidth_bps_); ObserverAllocation stable_bitrate_allocation = - AllocateBitrates(stable_target_bitrate_bps); + AllocateBitrates(last_stable_target_bps_); for (auto& config : allocatable_tracks_) { uint32_t allocated_bitrate = allocation[config.observer]; @@ -135,7 +134,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, uint32_t protection_bitrate = config.observer->OnBitrateUpdated(update); if (allocated_bitrate == 0 && config.allocated_bitrate_bps > 0) { - if (target_bitrate_bps > 0) + if (last_target_bps_ > 0) ++num_pause_events_; // The protection bitrate is an estimate based on the ratio between media // and protection used before this observer was muted. @@ -144,11 +143,11 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, RTC_LOG(LS_INFO) << "Pausing observer " << config.observer << " with configured min bitrate " << config.config.min_bitrate_bps - << " and current estimate of " << target_bitrate_bps + << " and current estimate of " << last_target_bps_ << " and protection bitrate " << predicted_protection_bps; } else if (allocated_bitrate > 0 && config.allocated_bitrate_bps == 0) { - if (target_bitrate_bps > 0) + if (last_target_bps_ > 0) ++num_pause_events_; RTC_LOG(LS_INFO) << "Resuming observer " << config.observer << ", configured min bitrate " diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h index a4ef032cfd..bad601624f 100644 --- a/call/bitrate_allocator.h +++ b/call/bitrate_allocator.h @@ -89,18 +89,13 @@ class BitrateAllocator : public BitrateAllocatorInterface { virtual ~LimitObserver() = default; }; - BitrateAllocator(Clock* clock, LimitObserver* limit_observer); + explicit BitrateAllocator(LimitObserver* limit_observer); ~BitrateAllocator() override; void UpdateStartRate(uint32_t start_rate_bps); // Allocate target_bitrate across the registered BitrateAllocatorObservers. - void OnNetworkChanged(uint32_t target_bitrate_bps, - uint32_t stable_target_bitrate_bps, - uint32_t bandwidth_bps, - uint8_t fraction_loss, - int64_t rtt, - int64_t bwe_period_ms); + void OnNetworkEstimateChanged(TargetTransferRate msg); // Set the configuration used by the bandwidth management. // |observer| updates bitrates if already in use. @@ -211,7 +206,6 @@ class BitrateAllocator : public BitrateAllocatorInterface { int64_t last_bwe_period_ms_ RTC_GUARDED_BY(&sequenced_checker_); // Number of mute events based on too low BWE, not network up/down. int num_pause_events_ RTC_GUARDED_BY(&sequenced_checker_); - Clock* const clock_ RTC_GUARDED_BY(&sequenced_checker_); int64_t last_bwe_log_time_ RTC_GUARDED_BY(&sequenced_checker_); BitrateAllocationLimits current_limits_ RTC_GUARDED_BY(&sequenced_checker_); const uint8_t transmission_max_bitrate_multiplier_; diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc index 5cdbc38b9f..edb3f7e30e 100644 --- a/call/bitrate_allocator_unittest.cc +++ b/call/bitrate_allocator_unittest.cc @@ -25,6 +25,7 @@ using ::testing::NiceMock; namespace webrtc { +namespace { auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps, uint32_t max_padding_rate_bps, uint32_t max_allocatable_rate_bps) { @@ -77,30 +78,32 @@ class TestBitrateObserver : public BitrateAllocatorObserver { double protection_ratio_; }; -class BitrateAllocatorForTest : public BitrateAllocator { - public: - using BitrateAllocator::BitrateAllocator; - void OnNetworkChanged(uint32_t target_bitrate_bps, - uint8_t fraction_loss, - int64_t rtt, - int64_t bwe_period_ms) { - BitrateAllocator::OnNetworkChanged(target_bitrate_bps, target_bitrate_bps, - target_bitrate_bps, fraction_loss, rtt, - bwe_period_ms); - } -}; - -namespace { constexpr int64_t kDefaultProbingIntervalMs = 3000; const double kDefaultBitratePriority = 1.0; + +TargetTransferRate CreateTargetRateMessage(uint32_t target_bitrate_bps, + uint8_t fraction_loss, + int64_t rtt_ms, + int64_t bwe_period_ms) { + TargetTransferRate msg; + // The timestamp is just for log output, keeping it fixed just means fewer log + // messages in the test. + msg.at_time = Timestamp::seconds(10000); + msg.target_rate = DataRate::bps(target_bitrate_bps); + msg.stable_target_rate = msg.target_rate; + msg.network_estimate.bandwidth = msg.target_rate; + msg.network_estimate.loss_rate_ratio = fraction_loss / 255.0; + msg.network_estimate.round_trip_time = TimeDelta::ms(rtt_ms); + msg.network_estimate.bwe_period = TimeDelta::ms(bwe_period_ms); + return msg; +} } // namespace class BitrateAllocatorTest : public ::testing::Test { protected: - BitrateAllocatorTest() - : allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(), - &limit_observer_)) { - allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); + BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) { + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs)); } ~BitrateAllocatorTest() {} void AddObserver(BitrateAllocatorObserver* observer, @@ -126,7 +129,7 @@ class BitrateAllocatorTest : public ::testing::Test { } NiceMock limit_observer_; - std::unique_ptr allocator_; + std::unique_ptr allocator_; }; TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) { @@ -143,23 +146,28 @@ TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) { config_b.priority_bitrate_bps = 300000; allocator_->AddObserver(&stream_b, config_b); - allocator_->OnNetworkChanged(100000, 0, 0, 0); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(100000, 0, 0, 0)); EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u); EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u); - allocator_->OnNetworkChanged(200000, 0, 0, 0); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000, 0, 0, 0)); EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u); EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u); - allocator_->OnNetworkChanged(300000, 0, 0, 0); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 0, 0)); EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u); EXPECT_EQ(stream_b.last_bitrate_bps_, 200000u); - allocator_->OnNetworkChanged(400000, 0, 0, 0); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(400000, 0, 0, 0)); EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u); EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u); - allocator_->OnNetworkChanged(800000, 0, 0, 0); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(800000, 0, 0, 0)); EXPECT_EQ(stream_a.last_bitrate_bps_, 500000u); EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u); } @@ -176,12 +184,14 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, kPadUpToBitrateBps, true, kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); - allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max // bitrate for FEC/retransmissions (see todo in BitrateAllocator). - allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(4000000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. @@ -197,7 +207,8 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { kDefaultBitratePriority); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); } @@ -228,8 +239,8 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { // Test too low start bitrate, hence lower than sum of min. Min bitrates // will // be allocated to all observers. - allocator_->OnNetworkChanged(kObs2StartBitrateBps, 0, 50, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kObs2StartBitrateBps, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); @@ -238,7 +249,8 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); // Test a bitrate which should be distributed equally. - allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(500000, 0, 50, kDefaultProbingIntervalMs)); const uint32_t kBitrateToShare = 500000 - kObs2StartBitrateBps - kObs1StartBitrateBps; EXPECT_EQ(100000u + kBitrateToShare / 2, @@ -248,14 +260,16 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { // Limited by 2x max bitrates since we leave room for FEC and // retransmissions. - allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_); // Verify that if the bandwidth estimate is set to zero, the allocated // rate is // zero. - allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(0, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); } @@ -279,9 +293,9 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) { class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { protected: BitrateAllocatorTestNoEnforceMin() - : allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(), - &limit_observer_)) { - allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); + : allocator_(new BitrateAllocator(&limit_observer_)) { + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs)); } ~BitrateAllocatorTestNoEnforceMin() {} void AddObserver(BitrateAllocatorObserver* observer, @@ -296,7 +310,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { enforce_min_bitrate, bitrate_priority}); } NiceMock limit_observer_; - std::unique_ptr allocator_; + std::unique_ptr allocator_; }; // The following three tests verify enforcing a minimum bitrate works as @@ -314,11 +328,13 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); // High BWE. - allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); // Low BWE. - allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_CALL(limit_observer_, @@ -348,7 +364,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { // High BWE. Make sure the controllers get a fair share of the surplus (i.e., // what is left after each controller gets its min rate). - allocator_->OnNetworkChanged(690000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(690000, 0, 0, kDefaultProbingIntervalMs)); // Verify that each observer gets its min rate (sum of min rates is 600000), // and that the remaining 90000 is divided equally among the three. uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; @@ -360,27 +377,31 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { bitrate_observer_3.last_bitrate_bps_); // BWE below the sum of observer's min bitrate. - allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate. EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate. EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. // Increased BWE, but still below the sum of configured min bitrates for all // observers and too little for observer 3. 1 and 2 will share the rest. - allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(500000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split. EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split. EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. // Below min for all. - allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Verify that zero estimated bandwidth, means that that all gets zero, // regardless of set min bitrate. - allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); @@ -407,15 +428,16 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); // High BWE. - allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_); // Add loss and use a part of the bitrate for protection. const double kProtectionRatio = 0.4; const uint8_t fraction_loss = kProtectionRatio * 256; bitrate_observer.SetBitrateProtectionRatio(kProtectionRatio); - allocator_->OnNetworkChanged(200000, 0, fraction_loss, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + 200000, 0, fraction_loss, kDefaultProbingIntervalMs)); EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); // Above the min threshold, but not enough given the protection used. @@ -427,31 +449,34 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(AllocationLimitsEq( 0, kMinStartBitrateWithProtectionBps, kMaxBitrateBps))); - allocator_->OnNetworkChanged(kMinStartBitrateBps + 1000, 0, fraction_loss, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kMinStartBitrateBps + 1000, 0, fraction_loss, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0, - fraction_loss, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0, + fraction_loss, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); // Just enough to enable video again. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged( AllocationLimitsEq(0, 0, kMaxBitrateBps))); - allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps, 0, - fraction_loss, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(kMinStartBitrateWithProtectionBps, 0, + fraction_loss, kDefaultProbingIntervalMs)); EXPECT_EQ(kMinStartBitrateWithProtectionBps, bitrate_observer.last_bitrate_bps_); // Remove all protection and make sure video is not paused as earlier. bitrate_observer.SetBitrateProtectionRatio(0.0); - allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0, 0, + kDefaultProbingIntervalMs)); EXPECT_EQ(kMinStartBitrateWithProtectionBps - 1000, bitrate_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(kMinStartBitrateBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kMinStartBitrateBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(kMinStartBitrateBps, bitrate_observer.last_bitrate_bps_); EXPECT_CALL(limit_observer_, @@ -479,19 +504,22 @@ TEST_F(BitrateAllocatorTest, bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2); // Total allocation limits are unaffected by the protection rate change. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0); - allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs)); // Observer uses 0% of it's allocated bitrate for protection. bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.0); // Total allocation limits are unaffected by the protection rate change. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0); - allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs)); // Observer again uses 20% of it's allocated bitrate for protection. bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2); // Total allocation limits are unaffected by the protection rate change. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0); - allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs)); } TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { @@ -508,37 +536,45 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { // Enough bitrate for both. bitrate_observer_2.SetBitrateProtectionRatio(0.5); - allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Above min for observer 2, but too little given the protection used. - allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(330000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); - allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(100000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); - allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(99999, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); - allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(119000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); - allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(120000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); // Verify the protection is accounted for before resuming observer 2. - allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(429000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); - allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(430000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_); @@ -568,7 +604,8 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { // Low BWE. Verify that all observers still get their respective min // bitrate. - allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(1000, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap. EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap. EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap. @@ -588,7 +625,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); // Set network down, ie, no available bitrate. - allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); @@ -606,7 +644,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); // Set network back up. - allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); } @@ -623,31 +662,38 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer)); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(35000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(5000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(55000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); @@ -660,22 +706,28 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); - allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(30000u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(20000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(49000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(50000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(50000u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(30000u, observer.last_bitrate_bps_); allocator_->RemoveObserver(&observer); @@ -686,22 +738,28 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); - allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(300000u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(200000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(329000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(0u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(330000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(330000u, observer.last_bitrate_bps_); - allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs)); EXPECT_EQ(300000u, observer.last_bitrate_bps_); allocator_->RemoveObserver(&observer); @@ -712,7 +770,8 @@ TEST_F(BitrateAllocatorTest, PassProbingInterval) { AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); - allocator_->OnNetworkChanged(300000, 0, 50, 5000); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(300000, 0, 50, 5000)); EXPECT_EQ(5000, observer.last_probing_interval_ms_); allocator_->RemoveObserver(&observer); @@ -725,8 +784,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) { const uint32_t kNetworkBandwidthBps = 30; AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0); - allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(kNetworkBandwidthBps, observer.last_bitrate_bps_); @@ -745,8 +804,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) { 2.0); AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false, 2.0); - allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_); EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_); @@ -767,8 +826,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) { 2.0); AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0); - allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_); EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_); @@ -789,8 +848,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) { 2.0); AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 4.0); - allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(kMaxSendBitrateBps, observer_low.last_bitrate_bps_); EXPECT_EQ(kMaxSendBitrateBps, observer_mid.last_bitrate_bps_); @@ -807,7 +866,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) { TestBitrateObserver observer_mid; AddObserver(&observer_low, 10, 50, 0, false, 2.0); AddObserver(&observer_mid, 10, 50, 0, false, 4.0); - allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(90, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(40u, observer_low.last_bitrate_bps_); EXPECT_EQ(50u, observer_mid.last_bitrate_bps_); @@ -834,8 +894,8 @@ TEST_F(BitrateAllocatorTest, AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority); AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority); AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority); - allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs)); const double kLowFractionAllocated = kLowBitratePriority / kTotalBitratePriority; @@ -880,8 +940,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) { kMidBitratePriority); AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, kHighBitratePriority); - allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs)); const double kLowFractionAllocated = kLowBitratePriority / (kLowBitratePriority + kMidBitratePriority); @@ -924,8 +984,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) { kMidBitratePriority); AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, kHighBitratePriority); - allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0, - kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage( + kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs)); const double kMidFractionAllocated = kMidBitratePriority / (kMidBitratePriority + kHighBitratePriority); @@ -958,7 +1018,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) { // Scaled (target allocation) = (max - min) / bitrate priority AddObserver(&observer_mid, 10, 30, 0, false, 4.0); AddObserver(&observer_high, 10, 50, 0, false, 8.0); - allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs); + allocator_->OnNetworkEstimateChanged( + CreateTargetRateMessage(110, 0, 0, kDefaultProbingIntervalMs)); EXPECT_EQ(30u, observer_low.last_bitrate_bps_); EXPECT_EQ(30u, observer_mid.last_bitrate_bps_); diff --git a/call/call.cc b/call/call.cc index 90208fcf0e..f816cb5ea5 100644 --- a/call/call.cc +++ b/call/call.cc @@ -48,7 +48,6 @@ #include "rtc_base/constructor_magic.h" #include "rtc_base/location.h" #include "rtc_base/logging.h" -#include "rtc_base/numerics/safe_minmax.h" #include "rtc_base/strings/string_builder.h" #include "rtc_base/synchronization/rw_lock_wrapper.h" #include "rtc_base/synchronization/sequence_checker.h" @@ -442,7 +441,7 @@ Call::Call(Clock* clock, num_cpu_cores_(CpuInfo::DetectNumberOfCores()), module_process_thread_(std::move(module_process_thread)), call_stats_(new CallStats(clock_, module_process_thread_.get())), - bitrate_allocator_(new BitrateAllocator(clock_, this)), + bitrate_allocator_(new BitrateAllocator(this)), config_(config), audio_network_state_(kNetworkDown), video_network_state_(kNetworkDown), @@ -1064,24 +1063,15 @@ void Call::OnStartRateUpdate(DataRate start_rate) { void Call::OnTargetTransferRate(TargetTransferRate msg) { RTC_DCHECK(network_queue()->IsCurrent()); RTC_DCHECK_RUN_ON(&worker_sequence_checker_); - - uint32_t target_bitrate_bps = msg.target_rate.bps(); - int loss_ratio_255 = msg.network_estimate.loss_rate_ratio * 255; - uint8_t fraction_loss = - rtc::dchecked_cast(rtc::SafeClamp(loss_ratio_255, 0, 255)); - int64_t rtt_ms = msg.network_estimate.round_trip_time.ms(); - int64_t probing_interval_ms = msg.network_estimate.bwe_period.ms(); - uint32_t bandwidth_bps = msg.network_estimate.bandwidth.bps(); - uint32_t stable_target_rate_bps = msg.stable_target_rate.bps(); { rtc::CritScope cs(&last_bandwidth_bps_crit_); - last_bandwidth_bps_ = bandwidth_bps; + last_bandwidth_bps_ = msg.network_estimate.bandwidth.bps(); } + + uint32_t target_bitrate_bps = msg.target_rate.bps(); // For controlling the rate of feedback messages. receive_side_cc_.OnBitrateChanged(target_bitrate_bps); - bitrate_allocator_->OnNetworkChanged( - target_bitrate_bps, stable_target_rate_bps, bandwidth_bps, fraction_loss, - rtt_ms, probing_interval_ms); + bitrate_allocator_->OnNetworkEstimateChanged(msg); // Ignore updates if bitrate is zero (the aggregate network state is down). if (target_bitrate_bps == 0) { diff --git a/modules/congestion_controller/pcc/pcc_network_controller.cc b/modules/congestion_controller/pcc/pcc_network_controller.cc index 034328e4fc..169b1476b2 100644 --- a/modules/congestion_controller/pcc/pcc_network_controller.cc +++ b/modules/congestion_controller/pcc/pcc_network_controller.cc @@ -101,6 +101,7 @@ NetworkControlUpdate PccNetworkController::CreateRateUpdate( // Set up target rate to encoder. TargetTransferRate target_rate_msg; + target_rate_msg.at_time = at_time; target_rate_msg.network_estimate.at_time = at_time; target_rate_msg.network_estimate.round_trip_time = rtt_tracker_.GetRtt(); target_rate_msg.network_estimate.bandwidth = bandwidth_estimate_; diff --git a/modules/congestion_controller/rtp/control_handler.cc b/modules/congestion_controller/rtp/control_handler.cc index 9272d99328..ba77aacab7 100644 --- a/modules/congestion_controller/rtp/control_handler.cc +++ b/modules/congestion_controller/rtp/control_handler.cc @@ -38,6 +38,7 @@ CongestionControlHandler::~CongestionControlHandler() {} void CongestionControlHandler::SetTargetRate( TargetTransferRate new_target_rate) { RTC_DCHECK_RUN_ON(&sequenced_checker_); + RTC_CHECK(new_target_rate.at_time.IsFinite()); last_incoming_ = new_target_rate; }