Propagating total_bitrate_bps from BitrateAllocator to ProbeController, part 1.
Added total_bitrate_bps to LimitObserver::OnAllocationLimitsChanged.
Bug: webrtc:8955
Change-Id: Ied9b2d24ab97cff21518ce70d5d35dfd8230ed08
Reviewed-on: https://webrtc-review.googlesource.com/58801
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22233}diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index 4130e68..5b4ff5c 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -75,9 +75,10 @@
class MockLimitObserver : public BitrateAllocator::LimitObserver {
public:
- MOCK_METHOD2(OnAllocationLimitsChanged,
+ MOCK_METHOD3(OnAllocationLimitsChanged,
void(uint32_t min_send_bitrate_bps,
- uint32_t max_padding_bitrate_bps));
+ uint32_t max_padding_bitrate_bps,
+ uint32_t total_bitrate_bps));
};
std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc
index 0b8ce39..c0a0518 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -179,6 +179,7 @@
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
uint32_t total_requested_padding_bitrate = 0;
uint32_t total_requested_min_bitrate = 0;
+ uint32_t total_requested_bitrate = 0;
for (const auto& config : bitrate_observer_configs_) {
uint32_t stream_padding = config.pad_up_bitrate_bps;
@@ -189,6 +190,7 @@
std::max(config.MinBitrateWithHysteresis(), stream_padding);
}
total_requested_padding_bitrate += stream_padding;
+ total_requested_bitrate += config.max_bitrate_bps;
}
if (total_requested_padding_bitrate == total_requested_padding_bitrate_ &&
@@ -204,7 +206,8 @@
<< "bps, total_requested_padding_bitrate: "
<< total_requested_padding_bitrate << "bps";
limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate,
- total_requested_padding_bitrate);
+ total_requested_padding_bitrate,
+ total_requested_bitrate);
}
void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {
diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h
index b1afc8c..f1d4f08 100644
--- a/call/bitrate_allocator.h
+++ b/call/bitrate_allocator.h
@@ -52,9 +52,9 @@
// bitrate and max padding bitrate is changed.
class LimitObserver {
public:
- virtual void OnAllocationLimitsChanged(
- uint32_t min_send_bitrate_bps,
- uint32_t max_padding_bitrate_bps) = 0;
+ virtual void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
+ uint32_t max_padding_bitrate_bps,
+ uint32_t total_bitrate_bps) = 0;
protected:
virtual ~LimitObserver() {}
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index 154d14e..57c0b98 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -24,9 +24,10 @@
class MockLimitObserver : public BitrateAllocator::LimitObserver {
public:
- MOCK_METHOD2(OnAllocationLimitsChanged,
+ MOCK_METHOD3(OnAllocationLimitsChanged,
void(uint32_t min_send_bitrate_bps,
- uint32_t max_padding_bitrate_bps));
+ uint32_t max_padding_bitrate_bps,
+ uint32_t total_bitrate_bps));
};
class TestBitrateObserver : public BitrateAllocatorObserver {
@@ -79,10 +80,12 @@
TestBitrateObserver bitrate_observer;
const uint32_t kMinSendBitrateBps = 100000;
const uint32_t kPadUpToBitrateBps = 50000;
+ const uint32_t kMaxBitrateBps = 1500000;
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
- kPadUpToBitrateBps));
- allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
+ EXPECT_CALL(limit_observer_,
+ OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
+ kMaxBitrateBps));
+ allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
@@ -96,36 +99,49 @@
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
EXPECT_CALL(limit_observer_,
- OnAllocationLimitsChanged(kMinSendBitrateBps, 0));
+ OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
true, "", kDefaultBitratePriority);
EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
- allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0,
- true, "", kDefaultBitratePriority);
+ allocator_->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(1500000, 0, 0, kDefaultProbingIntervalMs);
+ allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
}
TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2;
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0));
- allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, "",
+ const uint32_t kObs1StartBitrateBps = 100000;
+ const uint32_t kObs2StartBitrateBps = 200000;
+ const uint32_t kObs1MaxBitrateBps = 300000;
+ const uint32_t kObs2MaxBitrateBps = 300000;
+
+ EXPECT_CALL(
+ limit_observer_,
+ OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps));
+ allocator_->AddObserver(&bitrate_observer_1, kObs1StartBitrateBps,
+ kObs1MaxBitrateBps, 0, true, "",
kDefaultBitratePriority);
- EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
- EXPECT_CALL(limit_observer_,
- OnAllocationLimitsChanged(100000 + 200000, 0));
- allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, "",
+ EXPECT_EQ(static_cast<int>(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);
- EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
+ EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
+ allocator_->GetStartBitrate(&bitrate_observer_2));
// Test too low start bitrate, hence lower than sum of min. Min bitrates
// will
// be allocated to all observers.
- allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs);
+ allocator_->OnNetworkChanged(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_);
@@ -135,7 +151,8 @@
// Test a bitrate which should be distributed equally.
allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs);
- const uint32_t kBitrateToShare = 500000 - 200000 - 100000;
+ const uint32_t kBitrateToShare =
+ 500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
EXPECT_EQ(100000u + kBitrateToShare / 2,
bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u + kBitrateToShare / 2,
@@ -159,13 +176,15 @@
TestBitrateObserver bitrate_observer;
const uint32_t kMinSendBitrateBps = 100000;
const uint32_t kPadUpToBitrateBps = 50000;
+ const uint32_t kMaxBitrateBps = 1500000;
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps,
- kPadUpToBitrateBps));
- allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,
+ EXPECT_CALL(limit_observer_,
+ OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
+ kMaxBitrateBps));
+ allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "",
kDefaultBitratePriority);
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer);
}
@@ -187,7 +206,7 @@
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, 120000));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000, _));
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
@@ -200,7 +219,7 @@
allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer_1);
}
@@ -272,7 +291,7 @@
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, 168000));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000, _));
allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
@@ -300,7 +319,7 @@
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
// Just enough to enable video again.
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->OnNetworkChanged(168000, 0, fraction_loss,
kDefaultProbingIntervalMs);
EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_);
@@ -402,7 +421,7 @@
TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_1;
- EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _));
allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
@@ -415,7 +434,7 @@
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));
+ EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _));
allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
diff --git a/call/call.cc b/call/call.cc
index 323763a..d730fdb 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -233,7 +233,8 @@
// Implements BitrateAllocator::LimitObserver.
void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
- uint32_t max_padding_bitrate_bps) override;
+ uint32_t max_padding_bitrate_bps,
+ uint32_t total_bitrate_bps) override;
private:
DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
@@ -1074,7 +1075,8 @@
}
void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
- uint32_t max_padding_bitrate_bps) {
+ uint32_t max_padding_bitrate_bps,
+ uint32_t total_bitrate_bps) {
transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps,
max_padding_bitrate_bps);
rtc::CritScope lock(&bitrate_crit_);
