webrtc/call/bitrate_allocator_unittest.cc - Issue 2518923003: Pass time constant to bwe smoothing filter.

Unified Diff: webrtc/call/bitrate_allocator_unittest.cc

Issue 2518923003: Pass time constant to bwe smoothing filter. (Closed)

Patch Set: Removed Optional in SetBitrate Created 4 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: webrtc/call/bitrate_allocator_unittest.cc

diff --git a/webrtc/call/bitrate_allocator_unittest.cc b/webrtc/call/bitrate_allocator_unittest.cc

index 5d0395d82cae9d2dfe94140e547c9c7f729ea8b3..bf1f092de3db379c2b24c3ec5512092a2cd95059 100644

--- a/webrtc/call/bitrate_allocator_unittest.cc

+++ b/webrtc/call/bitrate_allocator_unittest.cc

@@ -34,6 +34,7 @@ class TestBitrateObserver : public BitrateAllocatorObserver {

: last_bitrate_bps_(0),

last_fraction_loss_(0),

last_rtt_ms_(0),

+ last_probing_interval_ms_(0),

protection_ratio_(0.0) {}

void SetBitrateProtectionRatio(double protection_ratio) {

@@ -42,22 +43,25 @@ class TestBitrateObserver : public BitrateAllocatorObserver {

uint32_t OnBitrateUpdated(uint32_t bitrate_bps,

uint8_t fraction_loss,

- int64_t rtt) override {

+ int64_t rtt,

+ int64_t probing_interval_ms) override {

last_bitrate_bps_ = bitrate_bps;

last_fraction_loss_ = fraction_loss;

last_rtt_ms_ = rtt;

+ last_probing_interval_ms_ = probing_interval_ms;

return bitrate_bps * protection_ratio_;

}

uint32_t last_bitrate_bps_;

uint8_t last_fraction_loss_;

int64_t last_rtt_ms_;

+ int last_probing_interval_ms_;

double protection_ratio_;

};

class BitrateAllocatorTest : public ::testing::Test {

protected:

BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) {

- allocator_->OnNetworkChanged(300000u, 0, 0);

+ allocator_->OnNetworkChanged(300000u, 0, 0, 0);

minyue-webrtc 2016/11/28 12:00:00 should we use something more meaningful, e.g., kDe

michaelt 2016/11/28 13:03:37 Done.

}

~BitrateAllocatorTest() {}

@@ -75,12 +79,12 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {

allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000,

kPadUpToBitrateBps, true);

EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));

- allocator_->OnNetworkChanged(200000, 0, 0);

+ allocator_->OnNetworkChanged(200000, 0, 0, 0);

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);

+ allocator_->OnNetworkChanged(4000000, 0, 0, 0);

EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));

// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.

@@ -96,7 +100,7 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {

true);

EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));

EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(1500000, 0, 0);

+ allocator_->OnNetworkChanged(1500000, 0, 0, 0);

EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);

}

@@ -114,7 +118,7 @@ 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);

+ allocator_->OnNetworkChanged(200000, 0, 50, 0);

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_);

@@ -123,7 +127,7 @@ 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);

+ allocator_->OnNetworkChanged(500000, 0, 50, 0);

const uint32_t kBitrateToShare = 500000 - 200000 - 100000;

EXPECT_EQ(100000u + kBitrateToShare / 2,

bitrate_observer_1.last_bitrate_bps_);

@@ -132,14 +136,14 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {

// Limited by 2x max bitrates since we leave room for FEC and

// retransmissions.

- allocator_->OnNetworkChanged(1500000, 0, 50);

+ allocator_->OnNetworkChanged(1500000, 0, 50, 0);

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);

+ allocator_->OnNetworkChanged(0, 0, 50, 0);

EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

}

@@ -161,7 +165,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {

protected:

BitrateAllocatorTestNoEnforceMin()

: allocator_(new BitrateAllocator(&limit_observer_)) {

- allocator_->OnNetworkChanged(300000u, 0, 0);

+ allocator_->OnNetworkChanged(300000u, 0, 0, 0);

}

~BitrateAllocatorTestNoEnforceMin() {}

@@ -180,11 +184,11 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {

EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));

// High BWE.

- allocator_->OnNetworkChanged(150000, 0, 0);

+ allocator_->OnNetworkChanged(150000, 0, 0, 0);

EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);

// Low BWE.

- allocator_->OnNetworkChanged(10000, 0, 0);

+ allocator_->OnNetworkChanged(10000, 0, 0, 0);

EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));

@@ -210,7 +214,7 @@ 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);

+ allocator_->OnNetworkChanged(690000, 0, 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;

@@ -222,27 +226,27 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {

bitrate_observer_3.last_bitrate_bps_);

// BWE below the sum of observer's min bitrate.

- allocator_->OnNetworkChanged(300000, 0, 0);

+ allocator_->OnNetworkChanged(300000, 0, 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);

+ allocator_->OnNetworkChanged(500000, 0, 0, 0);

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);

+ allocator_->OnNetworkChanged(10000, 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_);

// Verify that zero estimated bandwidth, means that that all gets zero,

// regardless of set min bitrate.

- allocator_->OnNetworkChanged(0, 0, 0);

+ allocator_->OnNetworkChanged(0, 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_);

@@ -262,34 +266,34 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {

EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));

// High BWE.

- allocator_->OnNetworkChanged(150000, 0, 0);

+ allocator_->OnNetworkChanged(150000, 0, 0, 0);

EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);

// Add loss and use a part of the bitrate for protection.

double protection_ratio = 0.4;

uint8_t fraction_loss = protection_ratio * 256;

bitrate_observer.SetBitrateProtectionRatio(protection_ratio);

- allocator_->OnNetworkChanged(200000, 0, fraction_loss);

+ allocator_->OnNetworkChanged(200000, 0, fraction_loss, 0);

EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);

// Above the min threshold, but not enough given the protection used.

- allocator_->OnNetworkChanged(139000, 0, fraction_loss);

+ allocator_->OnNetworkChanged(139000, 0, fraction_loss, 0);

EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);

// Verify the hysteresis is added for the protection.

- allocator_->OnNetworkChanged(150000, 0, fraction_loss);

+ allocator_->OnNetworkChanged(150000, 0, fraction_loss, 0);

EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);

// Just enough to enable video again.

- allocator_->OnNetworkChanged(168000, 0, fraction_loss);

+ allocator_->OnNetworkChanged(168000, 0, fraction_loss, 0);

EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_);

// Remove all protection and make sure video is not paused as earlier.

bitrate_observer.SetBitrateProtectionRatio(0.0);

- allocator_->OnNetworkChanged(140000, 0, 0);

+ allocator_->OnNetworkChanged(140000, 0, 0, 0);

EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(139000, 0, 0);

+ allocator_->OnNetworkChanged(139000, 0, 0, 0);

EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_);

EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0));

@@ -308,37 +312,37 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {

// Enough bitrate for both.

bitrate_observer_2.SetBitrateProtectionRatio(0.5);

- allocator_->OnNetworkChanged(300000, 0, 0);

+ allocator_->OnNetworkChanged(300000, 0, 0, 0);

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);

+ allocator_->OnNetworkChanged(330000, 0, 0, 0);

EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

- allocator_->OnNetworkChanged(100000, 0, 0);

+ allocator_->OnNetworkChanged(100000, 0, 0, 0);

EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

- allocator_->OnNetworkChanged(99999, 0, 0);

+ allocator_->OnNetworkChanged(99999, 0, 0, 0);

EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

- allocator_->OnNetworkChanged(119000, 0, 0);

+ allocator_->OnNetworkChanged(119000, 0, 0, 0);

EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

- allocator_->OnNetworkChanged(120000, 0, 0);

+ allocator_->OnNetworkChanged(120000, 0, 0, 0);

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);

+ allocator_->OnNetworkChanged(429000, 0, 0, 0);

EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

- allocator_->OnNetworkChanged(430000, 0, 0);

+ allocator_->OnNetworkChanged(430000, 0, 0, 0);

EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);

@@ -365,7 +369,7 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {

// Low BWE. Verify that all observers still get their respective min

// bitrate.

- allocator_->OnNetworkChanged(1000, 0, 0);

+ allocator_->OnNetworkChanged(1000, 0, 0, 0);

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.

@@ -383,7 +387,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {

EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));

// Set network down, ie, no available bitrate.

- allocator_->OnNetworkChanged(0, 0, 0);

+ allocator_->OnNetworkChanged(0, 0, 0, 0);

EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);

@@ -399,7 +403,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {

EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);

// Set network back up.

- allocator_->OnNetworkChanged(1500000, 0, 50);

+ allocator_->OnNetworkChanged(1500000, 0, 50, 0);

EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);

EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);

}

@@ -414,31 +418,31 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {

EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));

EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(36000, 0, 50);

+ allocator_->OnNetworkChanged(36000, 0, 50, 0);

EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(35000, 0, 50);

+ allocator_->OnNetworkChanged(35000, 0, 50, 0);

EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(5000, 0, 50);

+ allocator_->OnNetworkChanged(5000, 0, 50, 0);

EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(36000, 0, 50);

+ allocator_->OnNetworkChanged(36000, 0, 50, 0);

EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(55000, 0, 50);

+ allocator_->OnNetworkChanged(55000, 0, 50, 0);

EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(56000, 0, 50);

+ allocator_->OnNetworkChanged(56000, 0, 50, 0);

EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(56000, 0, 50);

+ allocator_->OnNetworkChanged(56000, 0, 50, 0);

EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);

EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);

@@ -451,22 +455,22 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {

allocator_->AddObserver(&observer, 30000, 300000, 0, false);

EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));

- allocator_->OnNetworkChanged(30000, 0, 50);

+ allocator_->OnNetworkChanged(30000, 0, 50, 0);

EXPECT_EQ(30000u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(20000, 0, 50);

+ allocator_->OnNetworkChanged(20000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(30000, 0, 50);

+ allocator_->OnNetworkChanged(30000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(49000, 0, 50);

+ allocator_->OnNetworkChanged(49000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(50000, 0, 50);

+ allocator_->OnNetworkChanged(50000, 0, 50, 0);

EXPECT_EQ(50000u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(30000, 0, 50);

+ allocator_->OnNetworkChanged(30000, 0, 50, 0);

EXPECT_EQ(30000u, observer.last_bitrate_bps_);

allocator_->RemoveObserver(&observer);

@@ -477,25 +481,39 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {

allocator_->AddObserver(&observer, 300000, 600000, 0, false);

EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));

- allocator_->OnNetworkChanged(300000, 0, 50);

+ allocator_->OnNetworkChanged(300000, 0, 50, 0);

EXPECT_EQ(300000u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(200000, 0, 50);

+ allocator_->OnNetworkChanged(200000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(300000, 0, 50);

+ allocator_->OnNetworkChanged(300000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(329000, 0, 50);

+ allocator_->OnNetworkChanged(329000, 0, 50, 0);

EXPECT_EQ(0u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(330000, 0, 50);

+ allocator_->OnNetworkChanged(330000, 0, 50, 0);

EXPECT_EQ(330000u, observer.last_bitrate_bps_);

- allocator_->OnNetworkChanged(300000, 0, 50);

+ allocator_->OnNetworkChanged(300000, 0, 50, 0);

EXPECT_EQ(300000u, observer.last_bitrate_bps_);

allocator_->RemoveObserver(&observer);

}

+TEST_F(BitrateAllocatorTest, PassProbingInterval) {

+ TestBitrateObserver observer;

+ allocator_->AddObserver(&observer, 300000, 600000, 0, false);

+ EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));

+ allocator_->OnNetworkChanged(300000, 0, 50, 5000);

+ EXPECT_EQ(5000, observer.last_probing_interval_ms_);

+ allocator_->OnNetworkChanged(300000, 0, 50, 8000);

minyue-webrtc 2016/11/28 12:00:00 what is the additional value of testing the second

michaelt 2016/11/28 13:03:37 It shows that in the observe not just a fixed valu

+ EXPECT_EQ(8000, observer.last_probing_interval_ms_);

+ allocator_->RemoveObserver(&observer);

} // namespace webrtc

« webrtc/audio/audio_send_stream_unittest.cc ('K') | « webrtc/call/bitrate_allocator.cc ('k') | webrtc/call/call.cc » ('j') | webrtc/voice_engine/channel.cc » ('J')