From 24ad720885de4c3edfc54c0b78a7f96f885935bd Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Thu, 19 Apr 2018 08:25:12 +0200 Subject: [PATCH] Uses config struct with bitrate allocator. This makes it easier to refactor the interface in upcoming CLs. Bug: None Change-Id: I67d0216e24f087294e95ac96f7278f302bf69832 Reviewed-on: https://webrtc-review.googlesource.com/71041 Reviewed-by: Stefan Holmer Commit-Queue: Sebastian Jansson Cr-Commit-Position: refs/heads/master@{#22933} --- audio/audio_send_stream.cc | 8 +- call/bitrate_allocator.cc | 27 ++-- call/bitrate_allocator.h | 48 ++++---- call/bitrate_allocator_unittest.cc | 190 ++++++++++++++++------------- video/video_send_stream_impl.cc | 27 ++-- 5 files changed, 162 insertions(+), 138 deletions(-) diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc index b8c88e8197..8798d4345c 100644 --- a/audio/audio_send_stream.cc +++ b/audio/audio_send_stream.cc @@ -708,9 +708,11 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps, config_.max_bitrate_bps = max_bitrate_bps; config_.bitrate_priority = bitrate_priority; // This either updates the current observer or adds a new observer. - bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0, - true, config_.track_id, bitrate_priority, - has_packet_feedback); + bitrate_allocator_->AddObserver( + this, MediaStreamAllocationConfig{ + static_cast(min_bitrate_bps), + static_cast(max_bitrate_bps), 0, true, + config_.track_id, bitrate_priority, has_packet_feedback}); thread_sync_event.Set(); }); thread_sync_event.Wait(rtc::Event::kForever); diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc index 753fd7ef0c..7a84f25206 100644 --- a/call/bitrate_allocator.cc +++ b/call/bitrate_allocator.cc @@ -142,29 +142,24 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, } void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer, - uint32_t min_bitrate_bps, - uint32_t max_bitrate_bps, - uint32_t pad_up_bitrate_bps, - bool enforce_min_bitrate, - std::string track_id, - double bitrate_priority, - bool has_packet_feedback) { + MediaStreamAllocationConfig config) { RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); - RTC_DCHECK_GT(bitrate_priority, 0); - RTC_DCHECK(std::isnormal(bitrate_priority)); + RTC_DCHECK_GT(config.bitrate_priority, 0); + RTC_DCHECK(std::isnormal(config.bitrate_priority)); auto it = FindObserverConfig(observer); // Update settings if the observer already exists, create a new one otherwise. if (it != bitrate_observer_configs_.end()) { - it->min_bitrate_bps = min_bitrate_bps; - it->max_bitrate_bps = max_bitrate_bps; - it->pad_up_bitrate_bps = pad_up_bitrate_bps; - it->enforce_min_bitrate = enforce_min_bitrate; - it->bitrate_priority = bitrate_priority; + it->min_bitrate_bps = config.min_bitrate_bps; + it->max_bitrate_bps = config.max_bitrate_bps; + it->pad_up_bitrate_bps = config.pad_up_bitrate_bps; + it->enforce_min_bitrate = config.enforce_min_bitrate; + it->bitrate_priority = config.bitrate_priority; } else { bitrate_observer_configs_.push_back(ObserverConfig( - observer, min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, - enforce_min_bitrate, track_id, bitrate_priority, has_packet_feedback)); + observer, config.min_bitrate_bps, config.max_bitrate_bps, + config.pad_up_bitrate_bps, config.enforce_min_bitrate, config.track_id, + config.bitrate_priority, config.has_packet_feedback)); } ObserverAllocation allocation; diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h index a4fdaf7c36..99f2018190 100644 --- a/call/bitrate_allocator.h +++ b/call/bitrate_allocator.h @@ -43,6 +43,30 @@ class BitrateAllocatorObserver { virtual ~BitrateAllocatorObserver() {} }; +// Struct describing parameters for how a media stream should get bitrate +// allocated to it. |min_bitrate_bps| = 0 equals no min bitrate. +// |max_bitrate_bps| = 0 equals no max bitrate. +// |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for +// this observer, even if the BWE is too low, 'false' will allocate 0 to +// the observer if BWE doesn't allow |min_bitrate_bps|. +// |has_packet_feedback| indicates whether the data produced by the +// corresponding media stream will receive per packet feedback. This is +// tracked here to communicate to limit observers whether packet feedback can +// be expected, which is true if any of the active observers has packet +// feedback enabled. Note that |observer|->OnBitrateUpdated() will be called +// within the scope of this method with the current rtt, fraction_loss and +// available bitrate and that the bitrate in OnBitrateUpdated will be zero if +// the |observer| is currently not allowed to send data. +struct MediaStreamAllocationConfig { + uint32_t min_bitrate_bps; + uint32_t max_bitrate_bps; + uint32_t pad_up_bitrate_bps; + bool enforce_min_bitrate; + std::string track_id; + double bitrate_priority; + bool has_packet_feedback; +}; + // Usage: this class will register multiple RtcpBitrateObserver's one at each // RTCP module. It will aggregate the results and run one bandwidth estimation // and push the result to the encoders via BitrateAllocatorObserver(s). @@ -71,30 +95,10 @@ class BitrateAllocator { int64_t bwe_period_ms); // Set the configuration used by the bandwidth management. - // // |observer| updates bitrates if already in use. - // |min_bitrate_bps| = 0 equals no min bitrate. - // |max_bitrate_bps| = 0 equals no max bitrate. - // |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for - // this observer, even if the BWE is too low, 'false' will allocate 0 to - // the observer if BWE doesn't allow |min_bitrate_bps|. - // |has_packet_feedback| indicates whether the data produced by the - // corresponding media stream will receive per packet feedback. This is - // tracked here to communicate to limit observers whether packet feedback can - // be expected, which is true if any of the active observers has packet - // feedback enabled. Note that |observer|->OnBitrateUpdated() will be called - // within the scope of this method with the current rtt, fraction_loss and - // available bitrate and that the bitrate in OnBitrateUpdated will be zero if - // the |observer| is currently not allowed to send data. + // |config| is the configuration to use for allocation. void AddObserver(BitrateAllocatorObserver* observer, - uint32_t min_bitrate_bps, - uint32_t max_bitrate_bps, - uint32_t pad_up_bitrate_bps, - bool enforce_min_bitrate, - std::string track_id, - double bitrate_priority, - // TODO(srte): Remove default when callers have been fixed. - bool has_packet_feedback = false); + MediaStreamAllocationConfig config); // Removes a previously added observer, but will not trigger a new bitrate // allocation. diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc index 5b07a81e78..b325f518c2 100644 --- a/call/bitrate_allocator_unittest.cc +++ b/call/bitrate_allocator_unittest.cc @@ -86,6 +86,17 @@ class BitrateAllocatorTest : public ::testing::Test { allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); } ~BitrateAllocatorTest() {} + void AddObserver(BitrateAllocatorObserver* observer, + uint32_t min_bitrate_bps, + uint32_t max_bitrate_bps, + uint32_t pad_up_bitrate_bps, + bool enforce_min_bitrate, + std::string track_id, + double bitrate_priority) { + allocator_->AddObserver( + observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, + enforce_min_bitrate, track_id, bitrate_priority, false}); + } NiceMock limit_observer_; std::unique_ptr allocator_; @@ -100,9 +111,8 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)); - allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, - kPadUpToBitrateBps, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, + kPadUpToBitrateBps, true, "", kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); @@ -115,14 +125,14 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _)); - allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, - true, "", kDefaultBitratePriority); + AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true, "", + kDefaultBitratePriority); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _)); EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); - allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, - 0, true, "", kDefaultBitratePriority); + AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true, + "", kDefaultBitratePriority); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs); @@ -140,17 +150,15 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { EXPECT_CALL( limit_observer_, OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps)); - allocator_->AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, - kObs1MaxBitrateBps, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0, + true, "", kDefaultBitratePriority); EXPECT_EQ(static_cast(kObs1MaxBitrateBps), allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged( kObs1StartBitrateBps + kObs2StartBitrateBps, 0, kObs1MaxBitrateBps + kObs2MaxBitrateBps)); - allocator_->AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, - kObs2MaxBitrateBps, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0, + true, "", kDefaultBitratePriority); EXPECT_EQ(static_cast(kObs2StartBitrateBps), allocator_->GetStartBitrate(&bitrate_observer_2)); @@ -198,9 +206,8 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) { EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)); - allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, - kPadUpToBitrateBps, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, + kPadUpToBitrateBps, true, "", kDefaultBitratePriority); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _)); allocator_->RemoveObserver(&bitrate_observer); } @@ -212,7 +219,17 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); } ~BitrateAllocatorTestNoEnforceMin() {} - + void AddObserver(BitrateAllocatorObserver* observer, + uint32_t min_bitrate_bps, + uint32_t max_bitrate_bps, + uint32_t pad_up_bitrate_bps, + bool enforce_min_bitrate, + std::string track_id, + double bitrate_priority) { + allocator_->AddObserver( + observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, + enforce_min_bitrate, track_id, bitrate_priority, false}); + } NiceMock limit_observer_; std::unique_ptr allocator_; }; @@ -225,8 +242,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { // 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, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); // High BWE. @@ -246,17 +263,17 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_3; // Set up the observers with min bitrates at 100000, 200000, and 300000. - allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); - allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); - allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); @@ -311,8 +328,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { // 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, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer, 100000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); // High BWE. @@ -359,11 +376,11 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_2; - allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); - allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); @@ -412,17 +429,17 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_3; - allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); - allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "", + kDefaultBitratePriority); EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); - allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3)); EXPECT_EQ(100000, static_cast(bitrate_observer_1.last_bitrate_bps_)); EXPECT_EQ(200000, static_cast(bitrate_observer_2.last_bitrate_bps_)); @@ -443,8 +460,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { TestBitrateObserver bitrate_observer_1; EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _)); - allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "", + kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); // Set network down, ie, no available bitrate. @@ -455,8 +472,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { TestBitrateObserver bitrate_observer_2; // Adding an observer while the network is down should not affect the limits. EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _)); - allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "", + kDefaultBitratePriority); // Expect the start_bitrate to be set as if the network was still up but that // the new observer have been notified that the network is down. @@ -472,13 +489,13 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { TestBitrateObserver enforced_observer; - allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, "", - kDefaultBitratePriority); + AddObserver(&enforced_observer, 6000, 30000, 0, true, "", + kDefaultBitratePriority); EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer)); TestBitrateObserver not_enforced_observer; - allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, 0, false, "", - kDefaultBitratePriority); + AddObserver(¬_enforced_observer, 30000, 2500000, 0, false, "", + kDefaultBitratePriority); EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer)); EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); @@ -516,8 +533,7 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { TestBitrateObserver observer; - allocator_->AddObserver(&observer, 30000, 300000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&observer, 30000, 300000, 0, false, "", kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); @@ -543,8 +559,7 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { TestBitrateObserver observer; - allocator_->AddObserver(&observer, 300000, 600000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); @@ -570,8 +585,7 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { TEST_F(BitrateAllocatorTest, PassProbingInterval) { TestBitrateObserver observer; - allocator_->AddObserver(&observer, 300000, 600000, 0, false, "", - kDefaultBitratePriority); + AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority); EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); allocator_->OnNetworkChanged(300000, 0, 50, 5000); @@ -586,8 +600,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) { const uint32_t kMaxSendBitrateBps = 60; const uint32_t kNetworkBandwidthBps = 30; - allocator_->AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, - true, "", 2.0); + AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, "", + 2.0); allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs); @@ -604,10 +618,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) { const uint32_t kMinSendBitrateBps = 10; const uint32_t kMaxSendBitrateBps = 60; const uint32_t kNetworkBandwidthBps = 60; - allocator_->AddObserver(&observer_low_1, kMinSendBitrateBps, - kMaxSendBitrateBps, 0, false, "low1", 2.0); - allocator_->AddObserver(&observer_low_2, kMinSendBitrateBps, - kMaxSendBitrateBps, 0, false, "low2", 2.0); + AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false, + "low1", 2.0); + AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false, + "low2", 2.0); allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs); @@ -626,10 +640,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) { const uint32_t kMinSendBitrateBps = 0; const uint32_t kMaxSendBitrateBps = 60; const uint32_t kNetworkBandwidthBps = 60; - allocator_->AddObserver(&observer_low_1, kMinSendBitrateBps, - kMaxSendBitrateBps, 0, true, "low1", 2.0); - allocator_->AddObserver(&observer_low_2, kMinSendBitrateBps, - kMaxSendBitrateBps, 0, true, "low2", 2.0); + AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, + "low1", 2.0); + AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, + "low2", 2.0); allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs); @@ -648,10 +662,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) { const uint32_t kMinSendBitrateBps = 0; const uint32_t kMaxSendBitrateBps = 60; const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2; - allocator_->AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, - 0, true, "low", 2.0); - allocator_->AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, - 0, true, "mid", 4.0); + AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, + "low", 2.0); + AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, + "mid", 4.0); allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs); @@ -668,8 +682,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) { TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) { TestBitrateObserver observer_low; TestBitrateObserver observer_mid; - allocator_->AddObserver(&observer_low, 10, 50, 0, false, "low", 2.0); - allocator_->AddObserver(&observer_mid, 10, 50, 0, false, "mid", 4.0); + AddObserver(&observer_low, 10, 50, 0, false, "low", 2.0); + AddObserver(&observer_mid, 10, 50, 0, false, "mid", 4.0); allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs); EXPECT_EQ(40u, observer_low.last_bitrate_bps_); @@ -694,12 +708,12 @@ TEST_F(BitrateAllocatorTest, const double kHighBitratePriority = 8.0; const double kTotalBitratePriority = kLowBitratePriority + kMidBitratePriority + kHighBitratePriority; - allocator_->AddObserver(&observer_low, 0, kMaxBitrate, 0, false, "low", - kLowBitratePriority); - allocator_->AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, "mid", - kMidBitratePriority); - allocator_->AddObserver(&observer_high, 0, kMaxBitrate, 0, false, "high", - kHighBitratePriority); + AddObserver(&observer_low, 0, kMaxBitrate, 0, false, "low", + kLowBitratePriority); + AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, "mid", + kMidBitratePriority); + AddObserver(&observer_high, 0, kMaxBitrate, 0, false, "high", + kHighBitratePriority); allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs); @@ -740,12 +754,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) { const uint32_t kRemainingBitrate = kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate); - allocator_->AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false, - "low", kLowBitratePriority); - allocator_->AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, - "mid", kMidBitratePriority); - allocator_->AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, - "high", kHighBitratePriority); + AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false, "low", + kLowBitratePriority); + AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid", + kMidBitratePriority); + AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high", + kHighBitratePriority); allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs); @@ -784,12 +798,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) { // available bitrate, so 70 bps would be sufficient network bandwidth. const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate; - allocator_->AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false, - "low", kLowBitratePriority); - allocator_->AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, - "mid", kMidBitratePriority); - allocator_->AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, - "high", kHighBitratePriority); + AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false, "low", + kLowBitratePriority); + AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid", + kMidBitratePriority); + AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high", + kHighBitratePriority); allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs); @@ -818,12 +832,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) { TestBitrateObserver observer_low; TestBitrateObserver observer_mid; TestBitrateObserver observer_high; - allocator_->AddObserver(&observer_low, 10, 40, 0, false, "low", 2.0); + AddObserver(&observer_low, 10, 40, 0, false, "low", 2.0); // Scaled allocation above the min allocation is the same for these two, // meaning they will get allocated their max at the same time. // Scaled (target allocation) = (max - min) / bitrate priority - allocator_->AddObserver(&observer_mid, 10, 30, 0, false, "mid", 4.0); - allocator_->AddObserver(&observer_high, 10, 50, 0, false, "high", 8.0); + AddObserver(&observer_mid, 10, 30, 0, false, "mid", 4.0); + AddObserver(&observer_high, 10, 50, 0, false, "high", 8.0); allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs); EXPECT_EQ(30u, observer_low.last_bitrate_bps_); diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc index 720f290fb3..8d9b480026 100644 --- a/video/video_send_stream_impl.cc +++ b/video/video_send_stream_impl.cc @@ -531,9 +531,12 @@ void VideoSendStreamImpl::Start() { void VideoSendStreamImpl::StartupVideoSendStream() { RTC_DCHECK_RUN_ON(worker_queue_); bitrate_allocator_->AddObserver( - this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, - max_padding_bitrate_, !config_->suspend_below_min_bitrate, - config_->track_id, encoder_bitrate_priority_, has_packet_feedback_); + this, + MediaStreamAllocationConfig{ + static_cast(encoder_min_bitrate_bps_), + encoder_max_bitrate_bps_, static_cast(max_padding_bitrate_), + !config_->suspend_below_min_bitrate, config_->track_id, + encoder_bitrate_priority_, has_packet_feedback_}); // Start monitoring encoder activity. { rtc::CritScope lock(&encoder_activity_crit_sect_); @@ -588,9 +591,12 @@ void VideoSendStreamImpl::SignalEncoderActive() { RTC_DCHECK_RUN_ON(worker_queue_); RTC_LOG(LS_INFO) << "SignalEncoderActive, Encoder is active."; bitrate_allocator_->AddObserver( - this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, - max_padding_bitrate_, !config_->suspend_below_min_bitrate, - config_->track_id, encoder_bitrate_priority_, has_packet_feedback_); + this, + MediaStreamAllocationConfig{ + static_cast(encoder_min_bitrate_bps_), + encoder_max_bitrate_bps_, static_cast(max_padding_bitrate_), + !config_->suspend_below_min_bitrate, config_->track_id, + encoder_bitrate_priority_, has_packet_feedback_}); } void VideoSendStreamImpl::OnEncoderConfigurationChanged( @@ -645,9 +651,12 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged( // The send stream is started already. Update the allocator with new bitrate // limits. bitrate_allocator_->AddObserver( - this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_, - max_padding_bitrate_, !config_->suspend_below_min_bitrate, - config_->track_id, encoder_bitrate_priority_, has_packet_feedback_); + this, MediaStreamAllocationConfig{ + static_cast(encoder_min_bitrate_bps_), + encoder_max_bitrate_bps_, + static_cast(max_padding_bitrate_), + !config_->suspend_below_min_bitrate, config_->track_id, + encoder_bitrate_priority_, has_packet_feedback_}); } }