Index: webrtc/call/bitrate_allocator_unittest.cc |
diff --git a/webrtc/call/bitrate_allocator_unittest.cc b/webrtc/call/bitrate_allocator_unittest.cc |
index 4017645c1d6f022988184fb5ac67b44ccc509649..9cb5f6cf99d8cb3dbb807d7a46fe8f11c343db24 100644 |
--- a/webrtc/call/bitrate_allocator_unittest.cc |
+++ b/webrtc/call/bitrate_allocator_unittest.cc |
@@ -21,18 +21,18 @@ namespace webrtc { |
class TestBitrateObserver : public BitrateAllocatorObserver { |
public: |
TestBitrateObserver() |
- : last_bitrate_(0), last_fraction_loss_(0), last_rtt_(0) {} |
+ : last_bitrate_bps_(0), last_fraction_loss_(0), last_rtt_ms_(0) {} |
- virtual void OnBitrateUpdated(uint32_t bitrate, |
- uint8_t fraction_loss, |
- int64_t rtt) { |
- last_bitrate_ = bitrate; |
+ void OnBitrateUpdated(uint32_t bitrate_bps, |
+ uint8_t fraction_loss, |
+ int64_t rtt) override { |
+ last_bitrate_bps_ = bitrate_bps; |
last_fraction_loss_ = fraction_loss; |
- last_rtt_ = rtt; |
+ last_rtt_ms_ = rtt; |
} |
- uint32_t last_bitrate_; |
+ uint32_t last_bitrate_bps_; |
uint8_t last_fraction_loss_; |
- int64_t last_rtt_; |
+ int64_t last_rtt_ms_; |
}; |
class BitrateAllocatorTest : public ::testing::Test { |
@@ -51,12 +51,12 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
EXPECT_EQ(300000, start_bitrate); |
allocator_->OnNetworkChanged(200000, 0, 0); |
- EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); |
+ EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); |
// 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); |
- EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
+ EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer, 100000, 4000000, true); |
EXPECT_EQ(4000000, start_bitrate); |
@@ -64,9 +64,9 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
EXPECT_EQ(3000000, start_bitrate); |
- EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
+ EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
allocator_->OnNetworkChanged(1500000, 0, 0); |
- EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_); |
+ EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); |
} |
TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
@@ -82,29 +82,31 @@ 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(200000, 0, 50); |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
+ 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_); |
- EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); |
+ EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
- EXPECT_EQ(50, bitrate_observer_2.last_rtt_); |
+ EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); |
// Test a bitrate which should be distributed equally. |
allocator_->OnNetworkChanged(500000, 0, 50); |
const uint32_t kBitrateToShare = 500000 - 200000 - 100000; |
- EXPECT_EQ(100000u + kBitrateToShare / 2, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(200000u + kBitrateToShare / 2, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(100000u + kBitrateToShare / 2, |
+ bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(200000u + kBitrateToShare / 2, |
+ bitrate_observer_2.last_bitrate_bps_); |
// Limited by 2x max bitrates since we leave room for FEC and retransmissions. |
allocator_->OnNetworkChanged(1500000, 0, 50); |
- EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_); |
+ 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); |
- EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
} |
class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
@@ -117,21 +119,21 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
std::unique_ptr<BitrateAllocator> allocator_; |
}; |
-// The following three tests verify that the EnforceMinBitrate() method works |
-// as intended. |
+// The following three tests verify enforcing a minimum bitrate works as |
+// intended. |
TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
TestBitrateObserver bitrate_observer_1; |
int start_bitrate = |
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); |
EXPECT_EQ(300000, start_bitrate); |
- // High REMB. |
+ // High BWE. |
allocator_->OnNetworkChanged(150000, 0, 0); |
- EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_); |
+ EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); |
- // Low REMB. |
+ // Low BWE. |
allocator_->OnNetworkChanged(10000, 0, 0); |
- EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); |
+ EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
allocator_->RemoveObserver(&bitrate_observer_1); |
} |
@@ -148,52 +150,59 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, false); |
EXPECT_EQ(200000, start_bitrate); |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
+ EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, false); |
EXPECT_EQ(0, start_bitrate); |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
- // High REMB. Make sure the controllers get a fair share of the surplus |
- // (i.e., what is left after each controller gets its min rate). |
+ // 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); |
// 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; |
- EXPECT_EQ(100000u + bitrate_to_share / 3, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(200000u + bitrate_to_share / 3, bitrate_observer_2.last_bitrate_); |
- EXPECT_EQ(300000u + bitrate_to_share / 3, bitrate_observer_3.last_bitrate_); |
- |
- // High REMB, but below the sum of min bitrates. |
+ EXPECT_EQ(100000u + bitrate_to_share / 3, |
+ bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(200000u + bitrate_to_share / 3, |
+ bitrate_observer_2.last_bitrate_bps_); |
+ EXPECT_EQ(300000u + bitrate_to_share / 3, |
+ bitrate_observer_3.last_bitrate_bps_); |
+ |
+ // BWE below the sum of observer's min bitrate. |
+ allocator_->OnNetworkChanged(300000, 0, 0); |
+ 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); |
- // Verify that the first and second observers get their min bitrates, and the |
- // third gets the remainder. |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min bitrate. |
- EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min bitrate. |
- EXPECT_EQ(200000u, bitrate_observer_3.last_bitrate_); // Remainder. |
+ 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. |
- // Low REMB. |
+ // Below min for all. |
allocator_->OnNetworkChanged(10000, 0, 0); |
- // Verify that the first observer gets all the rate, and the rest get zero. |
- EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); |
+ 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_); |
- allocator_->OnNetworkChanged(0, 0, 0); |
// Verify that zero estimated bandwidth, means that that all gets zero, |
// regardless of set min bitrate. |
- EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); |
+ allocator_->OnNetworkChanged(0, 0, 0); |
+ 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_); |
allocator_->RemoveObserver(&bitrate_observer_1); |
allocator_->RemoveObserver(&bitrate_observer_2); |
allocator_->RemoveObserver(&bitrate_observer_3); |
} |
-TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { |
+TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { |
TestBitrateObserver bitrate_observer_1; |
TestBitrateObserver bitrate_observer_2; |
TestBitrateObserver bitrate_observer_3; |
@@ -204,19 +213,19 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, true); |
EXPECT_EQ(200000, start_bitrate); |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
+ EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
start_bitrate = |
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, true); |
EXPECT_EQ(300000, start_bitrate); |
- EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_)); |
- EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_)); |
+ EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); |
+ EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); |
- // Low REMB. Verify that all observers still get their respective min bitrate. |
+ // Low BWE. Verify that all observers still get their respective min bitrate. |
allocator_->OnNetworkChanged(1000, 0, 0); |
- EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min cap. |
- EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. |
- EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. |
+ 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. |
allocator_->RemoveObserver(&bitrate_observer_1); |
allocator_->RemoveObserver(&bitrate_observer_2); |
@@ -232,7 +241,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { |
// Set network down, ie, no available bitrate. |
allocator_->OnNetworkChanged(0, 0, 0); |
- EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); |
+ EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
TestBitrateObserver bitrate_observer_2; |
start_bitrate = |
@@ -241,13 +250,111 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { |
// 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. |
EXPECT_EQ(300000 / 2, start_bitrate); |
- EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
// Set network back up. |
allocator_->OnNetworkChanged(1500000, 0, 50); |
- EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_); |
- EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_); |
+ EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); |
+ EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); |
+} |
+ |
+TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { |
+ TestBitrateObserver enforced_observer; |
+ int start_bitrate = |
+ allocator_->AddObserver(&enforced_observer, 6000, 30000, true); |
+ EXPECT_EQ(60000, start_bitrate); |
+ |
+ TestBitrateObserver not_enforced_observer; |
+ start_bitrate = |
+ allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, false); |
+ EXPECT_EQ(270000, start_bitrate); |
+ EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(36000, 0, 50); |
+ EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(35000, 0, 50); |
+ EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(5000, 0, 50); |
+ EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(36000, 0, 50); |
+ EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(55000, 0, 50); |
+ EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(56000, 0, 50); |
+ EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(56000, 0, 50); |
+ EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); |
+ EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); |
+ |
+ allocator_->RemoveObserver(&enforced_observer); |
+ allocator_->RemoveObserver(¬_enforced_observer); |
+} |
+ |
+TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { |
+ TestBitrateObserver observer; |
+ int start_bitrate = |
+ allocator_->AddObserver(&observer, 30000, 300000, false); |
+ EXPECT_EQ(300000, start_bitrate); |
+ |
+ allocator_->OnNetworkChanged(30000, 0, 50); |
+ EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(20000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(30000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(49000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(50000, 0, 50); |
+ EXPECT_EQ(50000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(30000, 0, 50); |
+ EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->RemoveObserver(&observer); |
+} |
+ |
+TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { |
+ TestBitrateObserver observer; |
+ int start_bitrate = |
+ allocator_->AddObserver(&observer, 300000, 600000, false); |
+ EXPECT_EQ(300000, start_bitrate); |
+ |
+ allocator_->OnNetworkChanged(300000, 0, 50); |
+ EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(200000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(300000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(329000, 0, 50); |
+ EXPECT_EQ(0u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(330000, 0, 50); |
+ EXPECT_EQ(330000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->OnNetworkChanged(300000, 0, 50); |
+ EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
+ |
+ allocator_->RemoveObserver(&observer); |
} |
} // namespace webrtc |