stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include <algorithm> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 12 | #include <memory> |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 15 | #include "call/bitrate_allocator.h" |
| 16 | #include "modules/bitrate_controller/include/bitrate_controller.h" |
| 17 | #include "test/gmock.h" |
| 18 | #include "test/gtest.h" |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 19 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 20 | using testing::NiceMock; |
| 21 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 22 | namespace webrtc { |
| 23 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 24 | class MockLimitObserver : public BitrateAllocator::LimitObserver { |
| 25 | public: |
| 26 | MOCK_METHOD2(OnAllocationLimitsChanged, |
| 27 | void(uint32_t min_send_bitrate_bps, |
| 28 | uint32_t max_padding_bitrate_bps)); |
| 29 | }; |
| 30 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 31 | class TestBitrateObserver : public BitrateAllocatorObserver { |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 32 | public: |
| 33 | TestBitrateObserver() |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 34 | : last_bitrate_bps_(0), |
| 35 | last_fraction_loss_(0), |
| 36 | last_rtt_ms_(0), |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 37 | last_probing_interval_ms_(0), |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 38 | protection_ratio_(0.0) {} |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 39 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 40 | void SetBitrateProtectionRatio(double protection_ratio) { |
| 41 | protection_ratio_ = protection_ratio; |
| 42 | } |
| 43 | |
| 44 | uint32_t OnBitrateUpdated(uint32_t bitrate_bps, |
| 45 | uint8_t fraction_loss, |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 46 | int64_t rtt, |
| 47 | int64_t probing_interval_ms) override { |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 48 | last_bitrate_bps_ = bitrate_bps; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 49 | last_fraction_loss_ = fraction_loss; |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 50 | last_rtt_ms_ = rtt; |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 51 | last_probing_interval_ms_ = probing_interval_ms; |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 52 | return bitrate_bps * protection_ratio_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 53 | } |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 54 | uint32_t last_bitrate_bps_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 55 | uint8_t last_fraction_loss_; |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 56 | int64_t last_rtt_ms_; |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 57 | int last_probing_interval_ms_; |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 58 | double protection_ratio_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 59 | }; |
| 60 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 61 | namespace { |
| 62 | constexpr int64_t kDefaultProbingIntervalMs = 3000; |
| 63 | } |
| 64 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 65 | class BitrateAllocatorTest : public ::testing::Test { |
| 66 | protected: |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 67 | BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) { |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 68 | allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 69 | } |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 70 | ~BitrateAllocatorTest() {} |
| 71 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 72 | NiceMock<MockLimitObserver> limit_observer_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 73 | std::unique_ptr<BitrateAllocator> allocator_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 74 | }; |
| 75 | |
| 76 | TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
| 77 | TestBitrateObserver bitrate_observer; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 78 | const uint32_t kMinSendBitrateBps = 100000; |
| 79 | const uint32_t kPadUpToBitrateBps = 50000; |
| 80 | |
| 81 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, |
| 82 | kPadUpToBitrateBps)); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 83 | allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 84 | kPadUpToBitrateBps, true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 85 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 86 | allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 87 | EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 88 | |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 89 | // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 90 | // bitrate for FEC/retransmissions (see todo in BitrateAllocator). |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 91 | allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 92 | EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 93 | |
| 94 | // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. |
| 95 | EXPECT_CALL(limit_observer_, |
| 96 | OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 97 | allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 98 | true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 99 | EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 100 | |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 101 | allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 102 | true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 103 | EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 104 | EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 105 | allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 106 | EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
| 110 | TestBitrateObserver bitrate_observer_1; |
| 111 | TestBitrateObserver bitrate_observer_2; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 112 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 113 | allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 114 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
| 115 | EXPECT_CALL(limit_observer_, |
| 116 | OnAllocationLimitsChanged(100000 + 200000, 0)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 117 | allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 118 | EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 119 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 120 | // Test too low start bitrate, hence lower than sum of min. Min bitrates |
| 121 | // will |
| 122 | // be allocated to all observers. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 123 | allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 124 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 125 | EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); |
| 126 | EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); |
| 127 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
| 128 | EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
| 129 | EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 130 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 131 | // Test a bitrate which should be distributed equally. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 132 | allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 133 | const uint32_t kBitrateToShare = 500000 - 200000 - 100000; |
| 134 | EXPECT_EQ(100000u + kBitrateToShare / 2, |
| 135 | bitrate_observer_1.last_bitrate_bps_); |
| 136 | EXPECT_EQ(200000u + kBitrateToShare / 2, |
| 137 | bitrate_observer_2.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 138 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 139 | // Limited by 2x max bitrates since we leave room for FEC and |
| 140 | // retransmissions. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 141 | allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 142 | EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_); |
| 143 | EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_); |
perkj | ec81bcd | 2016-05-11 06:01:13 -0700 | [diff] [blame] | 144 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 145 | // Verify that if the bandwidth estimate is set to zero, the allocated |
| 146 | // rate is |
| 147 | // zero. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 148 | allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 149 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 150 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 151 | } |
| 152 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 153 | TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) { |
| 154 | TestBitrateObserver bitrate_observer; |
| 155 | const uint32_t kMinSendBitrateBps = 100000; |
| 156 | const uint32_t kPadUpToBitrateBps = 50000; |
| 157 | |
| 158 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, |
| 159 | kPadUpToBitrateBps)); |
| 160 | allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 161 | kPadUpToBitrateBps, true, ""); |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 162 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
| 163 | allocator_->RemoveObserver(&bitrate_observer); |
| 164 | } |
| 165 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 166 | class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
| 167 | protected: |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 168 | BitrateAllocatorTestNoEnforceMin() |
| 169 | : allocator_(new BitrateAllocator(&limit_observer_)) { |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 170 | allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 171 | } |
| 172 | ~BitrateAllocatorTestNoEnforceMin() {} |
| 173 | |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 174 | NiceMock<MockLimitObserver> limit_observer_; |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame] | 175 | std::unique_ptr<BitrateAllocator> allocator_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 176 | }; |
| 177 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 178 | // The following three tests verify enforcing a minimum bitrate works as |
| 179 | // intended. |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 180 | TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
| 181 | TestBitrateObserver bitrate_observer_1; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 182 | // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since |
| 183 | // AddObserver is called with |enforce_min_bitrate| = false. |
philipel | 5ef2bc1 | 2017-02-21 07:28:31 -0800 | [diff] [blame] | 184 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 185 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 186 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 187 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 188 | // High BWE. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 189 | allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 190 | EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 191 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 192 | // Low BWE. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 193 | allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 194 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 195 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 196 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
| 197 | allocator_->RemoveObserver(&bitrate_observer_1); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 198 | } |
| 199 | |
| 200 | TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
| 201 | TestBitrateObserver bitrate_observer_1; |
| 202 | TestBitrateObserver bitrate_observer_2; |
| 203 | TestBitrateObserver bitrate_observer_3; |
| 204 | // Set up the observers with min bitrates at 100000, 200000, and 300000. |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 205 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 206 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 207 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 208 | allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 209 | EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 210 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 211 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 212 | allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 213 | EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 214 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 215 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 216 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 217 | // High BWE. Make sure the controllers get a fair share of the surplus (i.e., |
| 218 | // what is left after each controller gets its min rate). |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 219 | allocator_->OnNetworkChanged(690000, 0, 0, kDefaultProbingIntervalMs); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 220 | // Verify that each observer gets its min rate (sum of min rates is 600000), |
| 221 | // and that the remaining 90000 is divided equally among the three. |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 222 | uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 223 | EXPECT_EQ(100000u + bitrate_to_share / 3, |
| 224 | bitrate_observer_1.last_bitrate_bps_); |
| 225 | EXPECT_EQ(200000u + bitrate_to_share / 3, |
| 226 | bitrate_observer_2.last_bitrate_bps_); |
| 227 | EXPECT_EQ(300000u + bitrate_to_share / 3, |
| 228 | bitrate_observer_3.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 229 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 230 | // BWE below the sum of observer's min bitrate. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 231 | allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 232 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate. |
| 233 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate. |
| 234 | EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
| 235 | |
| 236 | // Increased BWE, but still below the sum of configured min bitrates for all |
| 237 | // observers and too little for observer 3. 1 and 2 will share the rest. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 238 | allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 239 | EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split. |
| 240 | EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split. |
| 241 | EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing. |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 242 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 243 | // Below min for all. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 244 | allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 245 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 246 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 247 | EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 248 | |
perkj | ec81bcd | 2016-05-11 06:01:13 -0700 | [diff] [blame] | 249 | // Verify that zero estimated bandwidth, means that that all gets zero, |
| 250 | // regardless of set min bitrate. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 251 | allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 252 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 253 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 254 | EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); |
perkj | ec81bcd | 2016-05-11 06:01:13 -0700 | [diff] [blame] | 255 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 256 | allocator_->RemoveObserver(&bitrate_observer_1); |
| 257 | allocator_->RemoveObserver(&bitrate_observer_2); |
| 258 | allocator_->RemoveObserver(&bitrate_observer_3); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 259 | } |
| 260 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 261 | TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) { |
| 262 | TestBitrateObserver bitrate_observer; |
| 263 | // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since |
| 264 | // AddObserver is called with |enforce_min_bitrate| = false. |
philipel | 5ef2bc1 | 2017-02-21 07:28:31 -0800 | [diff] [blame] | 265 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 266 | allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 267 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); |
| 268 | |
| 269 | // High BWE. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 270 | allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 271 | EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_); |
| 272 | |
| 273 | // Add loss and use a part of the bitrate for protection. |
| 274 | double protection_ratio = 0.4; |
| 275 | uint8_t fraction_loss = protection_ratio * 256; |
| 276 | bitrate_observer.SetBitrateProtectionRatio(protection_ratio); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 277 | allocator_->OnNetworkChanged(200000, 0, fraction_loss, |
| 278 | kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 279 | EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_); |
| 280 | |
| 281 | // Above the min threshold, but not enough given the protection used. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 282 | allocator_->OnNetworkChanged(139000, 0, fraction_loss, |
| 283 | kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 284 | EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); |
| 285 | |
| 286 | // Verify the hysteresis is added for the protection. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 287 | allocator_->OnNetworkChanged(150000, 0, fraction_loss, |
| 288 | kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 289 | EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); |
| 290 | |
| 291 | // Just enough to enable video again. |
philipel | 5ef2bc1 | 2017-02-21 07:28:31 -0800 | [diff] [blame] | 292 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 293 | allocator_->OnNetworkChanged(168000, 0, fraction_loss, |
| 294 | kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 295 | EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_); |
| 296 | |
| 297 | // Remove all protection and make sure video is not paused as earlier. |
| 298 | bitrate_observer.SetBitrateProtectionRatio(0.0); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 299 | allocator_->OnNetworkChanged(140000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 300 | EXPECT_EQ(140000u, bitrate_observer.last_bitrate_bps_); |
| 301 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 302 | allocator_->OnNetworkChanged(139000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 303 | EXPECT_EQ(139000u, bitrate_observer.last_bitrate_bps_); |
| 304 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 305 | allocator_->RemoveObserver(&bitrate_observer); |
| 306 | } |
| 307 | |
| 308 | TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) { |
| 309 | TestBitrateObserver bitrate_observer_1; |
| 310 | TestBitrateObserver bitrate_observer_2; |
| 311 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 312 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 313 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 314 | allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 315 | EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
| 316 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 317 | |
| 318 | // Enough bitrate for both. |
| 319 | bitrate_observer_2.SetBitrateProtectionRatio(0.5); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 320 | allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 321 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 322 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); |
| 323 | |
| 324 | // Above min for observer 2, but too little given the protection used. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 325 | allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 326 | EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_); |
| 327 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 328 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 329 | allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 330 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 331 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 332 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 333 | allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 334 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 335 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 336 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 337 | allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 338 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 339 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 340 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 341 | allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 342 | EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_); |
| 343 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 344 | |
| 345 | // Verify the protection is accounted for before resuming observer 2. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 346 | allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 347 | EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_); |
| 348 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
| 349 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 350 | allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 351 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
| 352 | EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_); |
| 353 | |
| 354 | allocator_->RemoveObserver(&bitrate_observer_1); |
| 355 | allocator_->RemoveObserver(&bitrate_observer_2); |
| 356 | } |
| 357 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 358 | TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) { |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 359 | TestBitrateObserver bitrate_observer_1; |
| 360 | TestBitrateObserver bitrate_observer_2; |
| 361 | TestBitrateObserver bitrate_observer_3; |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 362 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 363 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 364 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
| 365 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 366 | allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 367 | EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 368 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 369 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 370 | allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 371 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3)); |
| 372 | EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_)); |
| 373 | EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 374 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 375 | // Low BWE. Verify that all observers still get their respective min |
| 376 | // bitrate. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 377 | allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 378 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap. |
| 379 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap. |
| 380 | EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap. |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 381 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 382 | allocator_->RemoveObserver(&bitrate_observer_1); |
| 383 | allocator_->RemoveObserver(&bitrate_observer_2); |
| 384 | allocator_->RemoveObserver(&bitrate_observer_3); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 385 | } |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 386 | |
| 387 | TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { |
| 388 | TestBitrateObserver bitrate_observer_1; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 389 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0)); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 390 | |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 391 | allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, ""); |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 392 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 393 | |
| 394 | // Set network down, ie, no available bitrate. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 395 | allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 396 | |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 397 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 398 | |
| 399 | TestBitrateObserver bitrate_observer_2; |
perkj | 71ee44c | 2016-06-15 00:47:53 -0700 | [diff] [blame] | 400 | // Adding an observer while the network is down should not affect the limits. |
| 401 | EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0)); |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 402 | allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, ""); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 403 | |
| 404 | // Expect the start_bitrate to be set as if the network was still up but that |
| 405 | // the new observer have been notified that the network is down. |
perkj | 57c21f9 | 2016-06-17 07:27:16 -0700 | [diff] [blame] | 406 | EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 407 | EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); |
| 408 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 409 | |
| 410 | // Set network back up. |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 411 | allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 412 | EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_); |
| 413 | EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_); |
| 414 | } |
| 415 | |
| 416 | TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) { |
| 417 | TestBitrateObserver enforced_observer; |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 418 | allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 419 | EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 420 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 421 | TestBitrateObserver not_enforced_observer; |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 422 | allocator_->AddObserver(¬_enforced_observer, 30000, 2500000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 423 | EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer)); |
| 424 | EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 425 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 426 | allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 427 | EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 428 | EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 429 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 430 | allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 431 | EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 432 | EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 433 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 434 | allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 435 | EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 436 | EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 437 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 438 | allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 439 | EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 440 | EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 441 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 442 | allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 443 | EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_); |
| 444 | EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 445 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 446 | allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 447 | EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_); |
| 448 | EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 449 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 450 | allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 451 | EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_); |
| 452 | EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 453 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 454 | allocator_->RemoveObserver(&enforced_observer); |
| 455 | allocator_->RemoveObserver(¬_enforced_observer); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) { |
| 459 | TestBitrateObserver observer; |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 460 | allocator_->AddObserver(&observer, 30000, 300000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 461 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 462 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 463 | allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 464 | EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 465 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 466 | allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 467 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 468 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 469 | allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 470 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 471 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 472 | allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 473 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 474 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 475 | allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 476 | EXPECT_EQ(50000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 477 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 478 | allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 479 | EXPECT_EQ(30000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 480 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 481 | allocator_->RemoveObserver(&observer); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 482 | } |
| 483 | |
| 484 | TEST_F(BitrateAllocatorTest, AvoidTogglePercent) { |
| 485 | TestBitrateObserver observer; |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 486 | allocator_->AddObserver(&observer, 300000, 600000, 0, false, ""); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 487 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 488 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 489 | allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 490 | EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 491 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 492 | allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 493 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 494 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 495 | allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 496 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 497 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 498 | allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 499 | EXPECT_EQ(0u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 500 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 501 | allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 502 | EXPECT_EQ(330000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 503 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 504 | allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs); |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 505 | EXPECT_EQ(300000u, observer.last_bitrate_bps_); |
mflodman | 101f250 | 2016-06-09 17:21:19 +0200 | [diff] [blame] | 506 | |
mflodman | 48a4beb | 2016-07-01 13:03:59 +0200 | [diff] [blame] | 507 | allocator_->RemoveObserver(&observer); |
perkj | fea9309 | 2016-05-14 00:58:48 -0700 | [diff] [blame] | 508 | } |
| 509 | |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 510 | TEST_F(BitrateAllocatorTest, PassProbingInterval) { |
| 511 | TestBitrateObserver observer; |
Alex Narest | b3944f0 | 2017-10-13 14:56:18 +0200 | [diff] [blame] | 512 | allocator_->AddObserver(&observer, 300000, 600000, 0, false, ""); |
minyue | 78b4d56 | 2016-11-30 04:47:39 -0800 | [diff] [blame] | 513 | EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer)); |
| 514 | |
| 515 | allocator_->OnNetworkChanged(300000, 0, 50, 5000); |
| 516 | EXPECT_EQ(5000, observer.last_probing_interval_ms_); |
| 517 | |
| 518 | allocator_->RemoveObserver(&observer); |
| 519 | } |
| 520 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 521 | } // namespace webrtc |