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 "call/bitrate_allocator.h"
12
13 #include <algorithm>
14 #include <memory>
15 #include <vector>
16
17 #include "absl/strings/string_view.h"
18 #include "system_wrappers/include/clock.h"
19 #include "test/gmock.h"
20 #include "test/gtest.h"
21
22 using ::testing::_;
23 using ::testing::AllOf;
24 using ::testing::Field;
25 using ::testing::NiceMock;
26
27 namespace webrtc {
28
29 namespace {
AllocationLimitsEq(uint32_t min_allocatable_rate_bps,uint32_t max_padding_rate_bps,uint32_t max_allocatable_rate_bps)30 auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
31 uint32_t max_padding_rate_bps,
32 uint32_t max_allocatable_rate_bps) {
33 return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
34 DataRate::BitsPerSec(min_allocatable_rate_bps)),
35 Field(&BitrateAllocationLimits::max_allocatable_rate,
36 DataRate::BitsPerSec(max_allocatable_rate_bps)),
37 Field(&BitrateAllocationLimits::max_padding_rate,
38 DataRate::BitsPerSec(max_padding_rate_bps)));
39 }
40
AllocationLimitsEq(uint32_t min_allocatable_rate_bps,uint32_t max_padding_rate_bps)41 auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
42 uint32_t max_padding_rate_bps) {
43 return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
44 DataRate::BitsPerSec(min_allocatable_rate_bps)),
45 Field(&BitrateAllocationLimits::max_padding_rate,
46 DataRate::BitsPerSec(max_padding_rate_bps)));
47 }
48
49 class MockLimitObserver : public BitrateAllocator::LimitObserver {
50 public:
51 MOCK_METHOD(void,
52 OnAllocationLimitsChanged,
53 (BitrateAllocationLimits),
54 (override));
55 };
56
57 class TestBitrateObserver : public BitrateAllocatorObserver {
58 public:
TestBitrateObserver()59 TestBitrateObserver()
60 : last_bitrate_bps_(0),
61 last_fraction_loss_(0),
62 last_rtt_ms_(0),
63 last_probing_interval_ms_(0),
64 protection_ratio_(0.0) {}
65
SetBitrateProtectionRatio(double protection_ratio)66 void SetBitrateProtectionRatio(double protection_ratio) {
67 protection_ratio_ = protection_ratio;
68 }
69
OnBitrateUpdated(BitrateAllocationUpdate update)70 uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override {
71 last_bitrate_bps_ = update.target_bitrate.bps();
72 last_fraction_loss_ =
73 rtc::dchecked_cast<uint8_t>(update.packet_loss_ratio * 256);
74 last_rtt_ms_ = update.round_trip_time.ms();
75 last_probing_interval_ms_ = update.bwe_period.ms();
76 return update.target_bitrate.bps() * protection_ratio_;
77 }
78 uint32_t last_bitrate_bps_;
79 uint8_t last_fraction_loss_;
80 int64_t last_rtt_ms_;
81 int last_probing_interval_ms_;
82 double protection_ratio_;
83 };
84
85 constexpr int64_t kDefaultProbingIntervalMs = 3000;
86 const double kDefaultBitratePriority = 1.0;
87
CreateTargetRateMessage(uint32_t target_bitrate_bps,uint8_t fraction_loss,int64_t rtt_ms,int64_t bwe_period_ms)88 TargetTransferRate CreateTargetRateMessage(uint32_t target_bitrate_bps,
89 uint8_t fraction_loss,
90 int64_t rtt_ms,
91 int64_t bwe_period_ms) {
92 TargetTransferRate msg;
93 // The timestamp is just for log output, keeping it fixed just means fewer log
94 // messages in the test.
95 msg.at_time = Timestamp::Seconds(10000);
96 msg.target_rate = DataRate::BitsPerSec(target_bitrate_bps);
97 msg.stable_target_rate = msg.target_rate;
98 msg.network_estimate.bandwidth = msg.target_rate;
99 msg.network_estimate.loss_rate_ratio = fraction_loss / 255.0;
100 msg.network_estimate.round_trip_time = TimeDelta::Millis(rtt_ms);
101 msg.network_estimate.bwe_period = TimeDelta::Millis(bwe_period_ms);
102 return msg;
103 }
104 } // namespace
105
106 class BitrateAllocatorTest : public ::testing::Test {
107 protected:
BitrateAllocatorTest()108 BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) {
109 allocator_->OnNetworkEstimateChanged(
110 CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
111 }
~BitrateAllocatorTest()112 ~BitrateAllocatorTest() {}
AddObserver(BitrateAllocatorObserver * observer,uint32_t min_bitrate_bps,uint32_t max_bitrate_bps,uint32_t pad_up_bitrate_bps,bool enforce_min_bitrate,double bitrate_priority)113 void AddObserver(BitrateAllocatorObserver* observer,
114 uint32_t min_bitrate_bps,
115 uint32_t max_bitrate_bps,
116 uint32_t pad_up_bitrate_bps,
117 bool enforce_min_bitrate,
118 double bitrate_priority) {
119 allocator_->AddObserver(
120 observer,
121 {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
122 /* priority_bitrate */ 0, enforce_min_bitrate, bitrate_priority});
123 }
DefaultConfig() const124 MediaStreamAllocationConfig DefaultConfig() const {
125 MediaStreamAllocationConfig default_config;
126 default_config.min_bitrate_bps = 0;
127 default_config.max_bitrate_bps = 1500000;
128 default_config.pad_up_bitrate_bps = 0;
129 default_config.priority_bitrate_bps = 0;
130 default_config.enforce_min_bitrate = true;
131 default_config.bitrate_priority = kDefaultBitratePriority;
132 return default_config;
133 }
134
135 NiceMock<MockLimitObserver> limit_observer_;
136 std::unique_ptr<BitrateAllocator> allocator_;
137 };
138
TEST_F(BitrateAllocatorTest,RespectsPriorityBitrate)139 TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
140 TestBitrateObserver stream_a;
141 auto config_a = DefaultConfig();
142 config_a.min_bitrate_bps = 100000;
143 config_a.priority_bitrate_bps = 0;
144 allocator_->AddObserver(&stream_a, config_a);
145
146 TestBitrateObserver stream_b;
147 auto config_b = DefaultConfig();
148 config_b.min_bitrate_bps = 100000;
149 config_b.max_bitrate_bps = 300000;
150 config_b.priority_bitrate_bps = 300000;
151 allocator_->AddObserver(&stream_b, config_b);
152
153 allocator_->OnNetworkEstimateChanged(
154 CreateTargetRateMessage(100000, 0, 0, 0));
155 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
156 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
157
158 allocator_->OnNetworkEstimateChanged(
159 CreateTargetRateMessage(200000, 0, 0, 0));
160 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
161 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
162
163 allocator_->OnNetworkEstimateChanged(
164 CreateTargetRateMessage(300000, 0, 0, 0));
165 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
166 EXPECT_EQ(stream_b.last_bitrate_bps_, 200000u);
167
168 allocator_->OnNetworkEstimateChanged(
169 CreateTargetRateMessage(400000, 0, 0, 0));
170 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
171 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
172
173 allocator_->OnNetworkEstimateChanged(
174 CreateTargetRateMessage(800000, 0, 0, 0));
175 EXPECT_EQ(stream_a.last_bitrate_bps_, 500000u);
176 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
177 }
178
TEST_F(BitrateAllocatorTest,UpdatingBitrateObserver)179 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
180 TestBitrateObserver bitrate_observer;
181 const uint32_t kMinSendBitrateBps = 100000;
182 const uint32_t kPadUpToBitrateBps = 50000;
183 const uint32_t kMaxBitrateBps = 1500000;
184
185 EXPECT_CALL(limit_observer_,
186 OnAllocationLimitsChanged(AllocationLimitsEq(
187 kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)));
188 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
189 kPadUpToBitrateBps, true, kDefaultBitratePriority);
190 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
191 allocator_->OnNetworkEstimateChanged(
192 CreateTargetRateMessage(200000, 0, 0, kDefaultProbingIntervalMs));
193 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
194
195 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max
196 // bitrate for FEC/retransmissions (see todo in BitrateAllocator).
197 allocator_->OnNetworkEstimateChanged(
198 CreateTargetRateMessage(4000000, 0, 0, kDefaultProbingIntervalMs));
199 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
200
201 // Expect `max_padding_bitrate_bps` to change to 0 if the observer is updated.
202 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
203 AllocationLimitsEq(kMinSendBitrateBps, 0)));
204 AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true,
205 kDefaultBitratePriority);
206 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
207 AllocationLimitsEq(kMinSendBitrateBps, 0)));
208 EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
209
210 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true,
211 kDefaultBitratePriority);
212 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
213 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
214 allocator_->OnNetworkEstimateChanged(
215 CreateTargetRateMessage(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs));
216 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
217 }
218
TEST_F(BitrateAllocatorTest,TwoBitrateObserversOneRtcpObserver)219 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
220 TestBitrateObserver bitrate_observer_1;
221 TestBitrateObserver bitrate_observer_2;
222 const uint32_t kObs1StartBitrateBps = 100000;
223 const uint32_t kObs2StartBitrateBps = 200000;
224 const uint32_t kObs1MaxBitrateBps = 300000;
225 const uint32_t kObs2MaxBitrateBps = 300000;
226
227 EXPECT_CALL(limit_observer_,
228 OnAllocationLimitsChanged(AllocationLimitsEq(
229 kObs1StartBitrateBps, 0, kObs1MaxBitrateBps)));
230 AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0,
231 true, kDefaultBitratePriority);
232 EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
233 allocator_->GetStartBitrate(&bitrate_observer_1));
234 EXPECT_CALL(limit_observer_,
235 OnAllocationLimitsChanged(AllocationLimitsEq(
236 kObs1StartBitrateBps + kObs2StartBitrateBps, 0,
237 kObs1MaxBitrateBps + kObs2MaxBitrateBps)));
238 AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0,
239 true, kDefaultBitratePriority);
240 EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
241 allocator_->GetStartBitrate(&bitrate_observer_2));
242
243 // Test too low start bitrate, hence lower than sum of min. Min bitrates
244 // will
245 // be allocated to all observers.
246 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
247 kObs2StartBitrateBps, 0, 50, kDefaultProbingIntervalMs));
248 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
249 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
250 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
251 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
252 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_);
253 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_);
254
255 // Test a bitrate which should be distributed equally.
256 allocator_->OnNetworkEstimateChanged(
257 CreateTargetRateMessage(500000, 0, 50, kDefaultProbingIntervalMs));
258 const uint32_t kBitrateToShare =
259 500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
260 EXPECT_EQ(100000u + kBitrateToShare / 2,
261 bitrate_observer_1.last_bitrate_bps_);
262 EXPECT_EQ(200000u + kBitrateToShare / 2,
263 bitrate_observer_2.last_bitrate_bps_);
264
265 // Limited by 2x max bitrates since we leave room for FEC and
266 // retransmissions.
267 allocator_->OnNetworkEstimateChanged(
268 CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
269 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_);
270 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_);
271
272 // Verify that if the bandwidth estimate is set to zero, the allocated
273 // rate is
274 // zero.
275 allocator_->OnNetworkEstimateChanged(
276 CreateTargetRateMessage(0, 0, 50, kDefaultProbingIntervalMs));
277 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
278 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
279 }
280
TEST_F(BitrateAllocatorTest,RemoveObserverTriggersLimitObserver)281 TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
282 TestBitrateObserver bitrate_observer;
283 const uint32_t kMinSendBitrateBps = 100000;
284 const uint32_t kPadUpToBitrateBps = 50000;
285 const uint32_t kMaxBitrateBps = 1500000;
286
287 EXPECT_CALL(limit_observer_,
288 OnAllocationLimitsChanged(AllocationLimitsEq(
289 kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)));
290 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
291 kPadUpToBitrateBps, true, kDefaultBitratePriority);
292 EXPECT_CALL(limit_observer_,
293 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
294 allocator_->RemoveObserver(&bitrate_observer);
295 }
296
297 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
298 protected:
BitrateAllocatorTestNoEnforceMin()299 BitrateAllocatorTestNoEnforceMin()
300 : allocator_(new BitrateAllocator(&limit_observer_)) {
301 allocator_->OnNetworkEstimateChanged(
302 CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
303 }
~BitrateAllocatorTestNoEnforceMin()304 ~BitrateAllocatorTestNoEnforceMin() {}
AddObserver(BitrateAllocatorObserver * observer,uint32_t min_bitrate_bps,uint32_t max_bitrate_bps,uint32_t pad_up_bitrate_bps,bool enforce_min_bitrate,absl::string_view track_id,double bitrate_priority)305 void AddObserver(BitrateAllocatorObserver* observer,
306 uint32_t min_bitrate_bps,
307 uint32_t max_bitrate_bps,
308 uint32_t pad_up_bitrate_bps,
309 bool enforce_min_bitrate,
310 absl::string_view track_id,
311 double bitrate_priority) {
312 allocator_->AddObserver(
313 observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,
314 enforce_min_bitrate, bitrate_priority});
315 }
316 NiceMock<MockLimitObserver> limit_observer_;
317 std::unique_ptr<BitrateAllocator> allocator_;
318 };
319
320 // The following three tests verify enforcing a minimum bitrate works as
321 // intended.
TEST_F(BitrateAllocatorTestNoEnforceMin,OneBitrateObserver)322 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
323 TestBitrateObserver bitrate_observer_1;
324 // Expect OnAllocationLimitsChanged with `min_send_bitrate_bps` = 0 since
325 // AddObserver is called with `enforce_min_bitrate` = false.
326 EXPECT_CALL(limit_observer_,
327 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
328 EXPECT_CALL(limit_observer_,
329 OnAllocationLimitsChanged(AllocationLimitsEq(0, 120000)));
330 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
331 kDefaultBitratePriority);
332 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
333
334 // High BWE.
335 allocator_->OnNetworkEstimateChanged(
336 CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
337 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
338
339 // Low BWE.
340 allocator_->OnNetworkEstimateChanged(
341 CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
342 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
343
344 EXPECT_CALL(limit_observer_,
345 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
346 allocator_->RemoveObserver(&bitrate_observer_1);
347 }
348
TEST_F(BitrateAllocatorTestNoEnforceMin,ThreeBitrateObservers)349 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
350 TestBitrateObserver bitrate_observer_1;
351 TestBitrateObserver bitrate_observer_2;
352 TestBitrateObserver bitrate_observer_3;
353 // Set up the observers with min bitrates at 100000, 200000, and 300000.
354 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
355 kDefaultBitratePriority);
356 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
357
358 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
359 kDefaultBitratePriority);
360 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
361 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
362
363 AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
364 kDefaultBitratePriority);
365 EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
366 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
367 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
368
369 // High BWE. Make sure the controllers get a fair share of the surplus (i.e.,
370 // what is left after each controller gets its min rate).
371 allocator_->OnNetworkEstimateChanged(
372 CreateTargetRateMessage(690000, 0, 0, kDefaultProbingIntervalMs));
373 // Verify that each observer gets its min rate (sum of min rates is 600000),
374 // and that the remaining 90000 is divided equally among the three.
375 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
376 EXPECT_EQ(100000u + bitrate_to_share / 3,
377 bitrate_observer_1.last_bitrate_bps_);
378 EXPECT_EQ(200000u + bitrate_to_share / 3,
379 bitrate_observer_2.last_bitrate_bps_);
380 EXPECT_EQ(300000u + bitrate_to_share / 3,
381 bitrate_observer_3.last_bitrate_bps_);
382
383 // BWE below the sum of observer's min bitrate.
384 allocator_->OnNetworkEstimateChanged(
385 CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
386 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate.
387 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate.
388 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
389
390 // Increased BWE, but still below the sum of configured min bitrates for all
391 // observers and too little for observer 3. 1 and 2 will share the rest.
392 allocator_->OnNetworkEstimateChanged(
393 CreateTargetRateMessage(500000, 0, 0, kDefaultProbingIntervalMs));
394 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split.
395 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split.
396 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
397
398 // Below min for all.
399 allocator_->OnNetworkEstimateChanged(
400 CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
401 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
402 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
403 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
404
405 // Verify that zero estimated bandwidth, means that that all gets zero,
406 // regardless of set min bitrate.
407 allocator_->OnNetworkEstimateChanged(
408 CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
409 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
410 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
411 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
412
413 allocator_->RemoveObserver(&bitrate_observer_1);
414 allocator_->RemoveObserver(&bitrate_observer_2);
415 allocator_->RemoveObserver(&bitrate_observer_3);
416 }
417
TEST_F(BitrateAllocatorTestNoEnforceMin,OneBitrateObserverWithPacketLoss)418 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
419 const uint32_t kMinBitrateBps = 100000;
420 const uint32_t kMaxBitrateBps = 400000;
421 // Hysteresis adds another 10% or 20kbps to min bitrate.
422 const uint32_t kMinStartBitrateBps =
423 kMinBitrateBps + std::max(20000u, kMinBitrateBps / 10);
424
425 // Expect OnAllocationLimitsChanged with `min_send_bitrate_bps` = 0 since
426 // AddObserver is called with `enforce_min_bitrate` = false.
427 TestBitrateObserver bitrate_observer;
428 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
429 AllocationLimitsEq(0, 0, kMaxBitrateBps)));
430 AddObserver(&bitrate_observer, kMinBitrateBps, kMaxBitrateBps, 0, false, "",
431 kDefaultBitratePriority);
432 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
433
434 // High BWE.
435 allocator_->OnNetworkEstimateChanged(
436 CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
437 EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
438
439 // Add loss and use a part of the bitrate for protection.
440 const double kProtectionRatio = 0.4;
441 const uint8_t fraction_loss = kProtectionRatio * 256;
442 bitrate_observer.SetBitrateProtectionRatio(kProtectionRatio);
443 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
444 200000, 0, fraction_loss, kDefaultProbingIntervalMs));
445 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
446
447 // Above the min threshold, but not enough given the protection used.
448 // Limits changed, as we will video is now off and we need to pad up to the
449 // start bitrate.
450 // Verify the hysteresis is added for the protection.
451 const uint32_t kMinStartBitrateWithProtectionBps =
452 static_cast<uint32_t>(kMinStartBitrateBps * (1 + kProtectionRatio));
453 EXPECT_CALL(limit_observer_,
454 OnAllocationLimitsChanged(AllocationLimitsEq(
455 0, kMinStartBitrateWithProtectionBps, kMaxBitrateBps)));
456 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
457 kMinStartBitrateBps + 1000, 0, fraction_loss, kDefaultProbingIntervalMs));
458 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
459
460 allocator_->OnNetworkEstimateChanged(
461 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0,
462 fraction_loss, kDefaultProbingIntervalMs));
463 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
464
465 // Just enough to enable video again.
466 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
467 AllocationLimitsEq(0, 0, kMaxBitrateBps)));
468 allocator_->OnNetworkEstimateChanged(
469 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps, 0,
470 fraction_loss, kDefaultProbingIntervalMs));
471 EXPECT_EQ(kMinStartBitrateWithProtectionBps,
472 bitrate_observer.last_bitrate_bps_);
473
474 // Remove all protection and make sure video is not paused as earlier.
475 bitrate_observer.SetBitrateProtectionRatio(0.0);
476 allocator_->OnNetworkEstimateChanged(
477 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0, 0,
478 kDefaultProbingIntervalMs));
479 EXPECT_EQ(kMinStartBitrateWithProtectionBps - 1000,
480 bitrate_observer.last_bitrate_bps_);
481
482 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
483 kMinStartBitrateBps, 0, 0, kDefaultProbingIntervalMs));
484 EXPECT_EQ(kMinStartBitrateBps, bitrate_observer.last_bitrate_bps_);
485
486 EXPECT_CALL(limit_observer_,
487 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0, 0)));
488 allocator_->RemoveObserver(&bitrate_observer);
489 }
490
TEST_F(BitrateAllocatorTest,TotalAllocationLimitsAreUnaffectedByProtectionRatio)491 TEST_F(BitrateAllocatorTest,
492 TotalAllocationLimitsAreUnaffectedByProtectionRatio) {
493 TestBitrateObserver bitrate_observer;
494
495 const uint32_t kMinBitrateBps = 100000;
496 const uint32_t kMaxBitrateBps = 400000;
497
498 // Register `bitrate_observer` and expect total allocation limits to change.
499 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(AllocationLimitsEq(
500 kMinBitrateBps, 0, kMaxBitrateBps)))
501 .Times(1);
502 MediaStreamAllocationConfig allocation_config = DefaultConfig();
503 allocation_config.min_bitrate_bps = kMinBitrateBps;
504 allocation_config.max_bitrate_bps = kMaxBitrateBps;
505 allocator_->AddObserver(&bitrate_observer, allocation_config);
506
507 // Observer uses 20% of it's allocated bitrate for protection.
508 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
509 // Total allocation limits are unaffected by the protection rate change.
510 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
511 allocator_->OnNetworkEstimateChanged(
512 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
513
514 // Observer uses 0% of it's allocated bitrate for protection.
515 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.0);
516 // Total allocation limits are unaffected by the protection rate change.
517 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
518 allocator_->OnNetworkEstimateChanged(
519 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
520
521 // Observer again uses 20% of it's allocated bitrate for protection.
522 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
523 // Total allocation limits are unaffected by the protection rate change.
524 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
525 allocator_->OnNetworkEstimateChanged(
526 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
527 }
528
TEST_F(BitrateAllocatorTestNoEnforceMin,TwoBitrateObserverWithPacketLoss)529 TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
530 TestBitrateObserver bitrate_observer_1;
531 TestBitrateObserver bitrate_observer_2;
532
533 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
534 kDefaultBitratePriority);
535 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
536 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
537 kDefaultBitratePriority);
538 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
539 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
540
541 // Enough bitrate for both.
542 bitrate_observer_2.SetBitrateProtectionRatio(0.5);
543 allocator_->OnNetworkEstimateChanged(
544 CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
545 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
546 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
547
548 // Above min for observer 2, but too little given the protection used.
549 allocator_->OnNetworkEstimateChanged(
550 CreateTargetRateMessage(330000, 0, 0, kDefaultProbingIntervalMs));
551 EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);
552 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
553
554 allocator_->OnNetworkEstimateChanged(
555 CreateTargetRateMessage(100000, 0, 0, kDefaultProbingIntervalMs));
556 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
557 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
558
559 allocator_->OnNetworkEstimateChanged(
560 CreateTargetRateMessage(99999, 0, 0, kDefaultProbingIntervalMs));
561 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
562 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
563
564 allocator_->OnNetworkEstimateChanged(
565 CreateTargetRateMessage(119000, 0, 0, kDefaultProbingIntervalMs));
566 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
567 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
568
569 allocator_->OnNetworkEstimateChanged(
570 CreateTargetRateMessage(120000, 0, 0, kDefaultProbingIntervalMs));
571 EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_);
572 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
573
574 // Verify the protection is accounted for before resuming observer 2.
575 allocator_->OnNetworkEstimateChanged(
576 CreateTargetRateMessage(429000, 0, 0, kDefaultProbingIntervalMs));
577 EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);
578 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
579
580 allocator_->OnNetworkEstimateChanged(
581 CreateTargetRateMessage(430000, 0, 0, kDefaultProbingIntervalMs));
582 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
583 EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);
584
585 allocator_->RemoveObserver(&bitrate_observer_1);
586 allocator_->RemoveObserver(&bitrate_observer_2);
587 }
588
TEST_F(BitrateAllocatorTest,ThreeBitrateObserversLowBweEnforceMin)589 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
590 TestBitrateObserver bitrate_observer_1;
591 TestBitrateObserver bitrate_observer_2;
592 TestBitrateObserver bitrate_observer_3;
593
594 AddObserver(&bitrate_observer_1, 100000, 400000, 0, true,
595 kDefaultBitratePriority);
596 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
597
598 AddObserver(&bitrate_observer_2, 200000, 400000, 0, true,
599 kDefaultBitratePriority);
600 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
601 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
602
603 AddObserver(&bitrate_observer_3, 300000, 400000, 0, true,
604 kDefaultBitratePriority);
605 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
606 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
607 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
608
609 // Low BWE. Verify that all observers still get their respective min
610 // bitrate.
611 allocator_->OnNetworkEstimateChanged(
612 CreateTargetRateMessage(1000, 0, 0, kDefaultProbingIntervalMs));
613 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap.
614 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap.
615 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap.
616
617 allocator_->RemoveObserver(&bitrate_observer_1);
618 allocator_->RemoveObserver(&bitrate_observer_2);
619 allocator_->RemoveObserver(&bitrate_observer_3);
620 }
621
TEST_F(BitrateAllocatorTest,AddObserverWhileNetworkDown)622 TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
623 TestBitrateObserver bitrate_observer_1;
624 EXPECT_CALL(limit_observer_,
625 OnAllocationLimitsChanged(AllocationLimitsEq(50000, 0)));
626
627 AddObserver(&bitrate_observer_1, 50000, 400000, 0, true,
628 kDefaultBitratePriority);
629 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
630
631 // Set network down, ie, no available bitrate.
632 allocator_->OnNetworkEstimateChanged(
633 CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
634
635 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
636
637 TestBitrateObserver bitrate_observer_2;
638 // Adding an observer while the network is down should not affect the limits.
639 EXPECT_CALL(limit_observer_,
640 OnAllocationLimitsChanged(AllocationLimitsEq(50000 + 50000, 0)));
641 AddObserver(&bitrate_observer_2, 50000, 400000, 0, true,
642 kDefaultBitratePriority);
643
644 // Expect the start_bitrate to be set as if the network was still up but that
645 // the new observer have been notified that the network is down.
646 EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2));
647 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
648 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
649
650 // Set network back up.
651 allocator_->OnNetworkEstimateChanged(
652 CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
653 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);
654 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);
655 }
656
TEST_F(BitrateAllocatorTest,MixedEnforecedConfigs)657 TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
658 TestBitrateObserver enforced_observer;
659 AddObserver(&enforced_observer, 6000, 30000, 0, true,
660 kDefaultBitratePriority);
661 EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
662
663 TestBitrateObserver not_enforced_observer;
664 AddObserver(¬_enforced_observer, 30000, 2500000, 0, false,
665 kDefaultBitratePriority);
666 EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_enforced_observer));
667 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
668
669 allocator_->OnNetworkEstimateChanged(
670 CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
671 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
672 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);
673
674 allocator_->OnNetworkEstimateChanged(
675 CreateTargetRateMessage(35000, 0, 50, kDefaultProbingIntervalMs));
676 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
677 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
678
679 allocator_->OnNetworkEstimateChanged(
680 CreateTargetRateMessage(5000, 0, 50, kDefaultProbingIntervalMs));
681 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
682 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
683
684 allocator_->OnNetworkEstimateChanged(
685 CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
686 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
687 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
688
689 allocator_->OnNetworkEstimateChanged(
690 CreateTargetRateMessage(55000, 0, 50, kDefaultProbingIntervalMs));
691 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
692 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
693
694 allocator_->OnNetworkEstimateChanged(
695 CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
696 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
697 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);
698
699 allocator_->OnNetworkEstimateChanged(
700 CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
701 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);
702 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);
703
704 allocator_->RemoveObserver(&enforced_observer);
705 allocator_->RemoveObserver(¬_enforced_observer);
706 }
707
TEST_F(BitrateAllocatorTest,AvoidToggleAbsolute)708 TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
709 TestBitrateObserver observer;
710 AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority);
711 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
712
713 allocator_->OnNetworkEstimateChanged(
714 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
715 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
716
717 allocator_->OnNetworkEstimateChanged(
718 CreateTargetRateMessage(20000, 0, 50, kDefaultProbingIntervalMs));
719 EXPECT_EQ(0u, observer.last_bitrate_bps_);
720
721 allocator_->OnNetworkEstimateChanged(
722 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
723 EXPECT_EQ(0u, observer.last_bitrate_bps_);
724
725 allocator_->OnNetworkEstimateChanged(
726 CreateTargetRateMessage(49000, 0, 50, kDefaultProbingIntervalMs));
727 EXPECT_EQ(0u, observer.last_bitrate_bps_);
728
729 allocator_->OnNetworkEstimateChanged(
730 CreateTargetRateMessage(50000, 0, 50, kDefaultProbingIntervalMs));
731 EXPECT_EQ(50000u, observer.last_bitrate_bps_);
732
733 allocator_->OnNetworkEstimateChanged(
734 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
735 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
736
737 allocator_->RemoveObserver(&observer);
738 }
739
TEST_F(BitrateAllocatorTest,AvoidTogglePercent)740 TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
741 TestBitrateObserver observer;
742 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
743 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
744
745 allocator_->OnNetworkEstimateChanged(
746 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
747 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
748
749 allocator_->OnNetworkEstimateChanged(
750 CreateTargetRateMessage(200000, 0, 50, kDefaultProbingIntervalMs));
751 EXPECT_EQ(0u, observer.last_bitrate_bps_);
752
753 allocator_->OnNetworkEstimateChanged(
754 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
755 EXPECT_EQ(0u, observer.last_bitrate_bps_);
756
757 allocator_->OnNetworkEstimateChanged(
758 CreateTargetRateMessage(329000, 0, 50, kDefaultProbingIntervalMs));
759 EXPECT_EQ(0u, observer.last_bitrate_bps_);
760
761 allocator_->OnNetworkEstimateChanged(
762 CreateTargetRateMessage(330000, 0, 50, kDefaultProbingIntervalMs));
763 EXPECT_EQ(330000u, observer.last_bitrate_bps_);
764
765 allocator_->OnNetworkEstimateChanged(
766 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
767 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
768
769 allocator_->RemoveObserver(&observer);
770 }
771
TEST_F(BitrateAllocatorTest,PassProbingInterval)772 TEST_F(BitrateAllocatorTest, PassProbingInterval) {
773 TestBitrateObserver observer;
774 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
775 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
776
777 allocator_->OnNetworkEstimateChanged(
778 CreateTargetRateMessage(300000, 0, 50, 5000));
779 EXPECT_EQ(5000, observer.last_probing_interval_ms_);
780
781 allocator_->RemoveObserver(&observer);
782 }
783
TEST_F(BitrateAllocatorTest,PriorityRateOneObserverBasic)784 TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
785 TestBitrateObserver observer;
786 const uint32_t kMinSendBitrateBps = 10;
787 const uint32_t kMaxSendBitrateBps = 60;
788 const uint32_t kNetworkBandwidthBps = 30;
789
790 AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0);
791 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
792 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
793
794 EXPECT_EQ(kNetworkBandwidthBps, observer.last_bitrate_bps_);
795
796 allocator_->RemoveObserver(&observer);
797 }
798
799 // Tests that two observers with the same bitrate priority are allocated
800 // their bitrate evenly.
TEST_F(BitrateAllocatorTest,PriorityRateTwoObserversBasic)801 TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
802 TestBitrateObserver observer_low_1;
803 TestBitrateObserver observer_low_2;
804 const uint32_t kMinSendBitrateBps = 10;
805 const uint32_t kMaxSendBitrateBps = 60;
806 const uint32_t kNetworkBandwidthBps = 60;
807 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
808 2.0);
809 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
810 2.0);
811 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
812 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
813
814 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
815 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
816
817 allocator_->RemoveObserver(&observer_low_1);
818 allocator_->RemoveObserver(&observer_low_2);
819 }
820
821 // Tests that there is no difference in functionality when the min bitrate is
822 // enforced.
TEST_F(BitrateAllocatorTest,PriorityRateTwoObserversBasicMinEnforced)823 TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
824 TestBitrateObserver observer_low_1;
825 TestBitrateObserver observer_low_2;
826 const uint32_t kMinSendBitrateBps = 0;
827 const uint32_t kMaxSendBitrateBps = 60;
828 const uint32_t kNetworkBandwidthBps = 60;
829 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
830 2.0);
831 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
832 2.0);
833 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
834 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
835
836 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
837 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
838
839 allocator_->RemoveObserver(&observer_low_1);
840 allocator_->RemoveObserver(&observer_low_2);
841 }
842
843 // Tests that if the available bandwidth is the sum of the max bitrate
844 // of all observers, they will be allocated their max.
TEST_F(BitrateAllocatorTest,PriorityRateTwoObserversBothAllocatedMax)845 TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
846 TestBitrateObserver observer_low;
847 TestBitrateObserver observer_mid;
848 const uint32_t kMinSendBitrateBps = 0;
849 const uint32_t kMaxSendBitrateBps = 60;
850 const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2;
851 AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
852 2.0);
853 AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
854 4.0);
855 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
856 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
857
858 EXPECT_EQ(kMaxSendBitrateBps, observer_low.last_bitrate_bps_);
859 EXPECT_EQ(kMaxSendBitrateBps, observer_mid.last_bitrate_bps_);
860
861 allocator_->RemoveObserver(&observer_low);
862 allocator_->RemoveObserver(&observer_mid);
863 }
864
865 // Tests that after a higher bitrate priority observer has been allocated its
866 // max bitrate the lower priority observer will then be allocated the remaining
867 // bitrate.
TEST_F(BitrateAllocatorTest,PriorityRateTwoObserversOneAllocatedToMax)868 TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
869 TestBitrateObserver observer_low;
870 TestBitrateObserver observer_mid;
871 AddObserver(&observer_low, 10, 50, 0, false, 2.0);
872 AddObserver(&observer_mid, 10, 50, 0, false, 4.0);
873 allocator_->OnNetworkEstimateChanged(
874 CreateTargetRateMessage(90, 0, 0, kDefaultProbingIntervalMs));
875
876 EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
877 EXPECT_EQ(50u, observer_mid.last_bitrate_bps_);
878
879 allocator_->RemoveObserver(&observer_low);
880 allocator_->RemoveObserver(&observer_mid);
881 }
882
883 // Tests that three observers with three different bitrate priorities will all
884 // be allocated bitrate according to their relative bitrate priority.
TEST_F(BitrateAllocatorTest,PriorityRateThreeObserversAllocatedRelativeAmounts)885 TEST_F(BitrateAllocatorTest,
886 PriorityRateThreeObserversAllocatedRelativeAmounts) {
887 TestBitrateObserver observer_low;
888 TestBitrateObserver observer_mid;
889 TestBitrateObserver observer_high;
890 const uint32_t kMaxBitrate = 100;
891 // Not enough bandwidth to fill any observer's max bitrate.
892 const uint32_t kNetworkBandwidthBps = 70;
893 const double kLowBitratePriority = 2.0;
894 const double kMidBitratePriority = 4.0;
895 const double kHighBitratePriority = 8.0;
896 const double kTotalBitratePriority =
897 kLowBitratePriority + kMidBitratePriority + kHighBitratePriority;
898 AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority);
899 AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority);
900 AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority);
901 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
902 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
903
904 const double kLowFractionAllocated =
905 kLowBitratePriority / kTotalBitratePriority;
906 const double kMidFractionAllocated =
907 kMidBitratePriority / kTotalBitratePriority;
908 const double kHighFractionAllocated =
909 kHighBitratePriority / kTotalBitratePriority;
910 EXPECT_EQ(kLowFractionAllocated * kNetworkBandwidthBps,
911 observer_low.last_bitrate_bps_);
912 EXPECT_EQ(kMidFractionAllocated * kNetworkBandwidthBps,
913 observer_mid.last_bitrate_bps_);
914 EXPECT_EQ(kHighFractionAllocated * kNetworkBandwidthBps,
915 observer_high.last_bitrate_bps_);
916
917 allocator_->RemoveObserver(&observer_low);
918 allocator_->RemoveObserver(&observer_mid);
919 allocator_->RemoveObserver(&observer_high);
920 }
921
922 // Tests that after the high priority observer has been allocated its maximum
923 // bitrate, the other two observers are still allocated bitrate according to
924 // their relative bitrate priority.
TEST_F(BitrateAllocatorTest,PriorityRateThreeObserversHighAllocatedToMax)925 TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
926 TestBitrateObserver observer_low;
927 const double kLowBitratePriority = 2.0;
928 TestBitrateObserver observer_mid;
929 const double kMidBitratePriority = 4.0;
930 TestBitrateObserver observer_high;
931 const double kHighBitratePriority = 8.0;
932
933 const uint32_t kAvailableBitrate = 90;
934 const uint32_t kMaxBitrate = 40;
935 const uint32_t kMinBitrate = 10;
936 // Remaining bitrate after allocating to all mins and knowing that the high
937 // priority observer will have its max bitrate allocated.
938 const uint32_t kRemainingBitrate =
939 kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate);
940
941 AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false,
942 kLowBitratePriority);
943 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
944 kMidBitratePriority);
945 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
946 kHighBitratePriority);
947 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
948 kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
949
950 const double kLowFractionAllocated =
951 kLowBitratePriority / (kLowBitratePriority + kMidBitratePriority);
952 const double kMidFractionAllocated =
953 kMidBitratePriority / (kLowBitratePriority + kMidBitratePriority);
954 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kLowFractionAllocated),
955 observer_low.last_bitrate_bps_);
956 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
957 observer_mid.last_bitrate_bps_);
958 EXPECT_EQ(40u, observer_high.last_bitrate_bps_);
959
960 allocator_->RemoveObserver(&observer_low);
961 allocator_->RemoveObserver(&observer_mid);
962 allocator_->RemoveObserver(&observer_high);
963 }
964
965 // Tests that after the low priority observer has been allocated its maximum
966 // bitrate, the other two observers are still allocated bitrate according to
967 // their relative bitrate priority.
TEST_F(BitrateAllocatorTest,PriorityRateThreeObserversLowAllocatedToMax)968 TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
969 TestBitrateObserver observer_low;
970 const double kLowBitratePriority = 2.0;
971 const uint32_t kLowMaxBitrate = 10;
972 TestBitrateObserver observer_mid;
973 const double kMidBitratePriority = 4.0;
974 TestBitrateObserver observer_high;
975 const double kHighBitratePriority = 8.0;
976
977 const uint32_t kMinBitrate = 0;
978 const uint32_t kMaxBitrate = 60;
979 const uint32_t kAvailableBitrate = 100;
980 // Remaining bitrate knowing that the low priority observer is allocated its
981 // max bitrate. We know this because it is allocated 2.0/14.0 (1/7) of the
982 // available bitrate, so 70 bps would be sufficient network bandwidth.
983 const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate;
984
985 AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false,
986 kLowBitratePriority);
987 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
988 kMidBitratePriority);
989 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
990 kHighBitratePriority);
991 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
992 kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
993
994 const double kMidFractionAllocated =
995 kMidBitratePriority / (kMidBitratePriority + kHighBitratePriority);
996 const double kHighFractionAllocated =
997 kHighBitratePriority / (kMidBitratePriority + kHighBitratePriority);
998 EXPECT_EQ(kLowMaxBitrate, observer_low.last_bitrate_bps_);
999 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
1000 observer_mid.last_bitrate_bps_);
1001 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kHighFractionAllocated),
1002 observer_high.last_bitrate_bps_);
1003
1004 allocator_->RemoveObserver(&observer_low);
1005 allocator_->RemoveObserver(&observer_mid);
1006 allocator_->RemoveObserver(&observer_high);
1007 }
1008
1009 // Tests that after two observers are allocated bitrate to their max, the
1010 // the remaining observer is allocated what's left appropriately. This test
1011 // handles an edge case where the medium and high observer reach their
1012 // "relative" max allocation at the same time. The high has 40 to allocate
1013 // above its min, and the mid has 20 to allocate above its min, which scaled
1014 // by their bitrate priority is the same for each.
TEST_F(BitrateAllocatorTest,PriorityRateThreeObserversTwoAllocatedToMax)1015 TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
1016 TestBitrateObserver observer_low;
1017 TestBitrateObserver observer_mid;
1018 TestBitrateObserver observer_high;
1019 AddObserver(&observer_low, 10, 40, 0, false, 2.0);
1020 // Scaled allocation above the min allocation is the same for these two,
1021 // meaning they will get allocated their max at the same time.
1022 // Scaled (target allocation) = (max - min) / bitrate priority
1023 AddObserver(&observer_mid, 10, 30, 0, false, 4.0);
1024 AddObserver(&observer_high, 10, 50, 0, false, 8.0);
1025 allocator_->OnNetworkEstimateChanged(
1026 CreateTargetRateMessage(110, 0, 0, kDefaultProbingIntervalMs));
1027
1028 EXPECT_EQ(30u, observer_low.last_bitrate_bps_);
1029 EXPECT_EQ(30u, observer_mid.last_bitrate_bps_);
1030 EXPECT_EQ(50u, observer_high.last_bitrate_bps_);
1031
1032 allocator_->RemoveObserver(&observer_low);
1033 allocator_->RemoveObserver(&observer_mid);
1034 allocator_->RemoveObserver(&observer_high);
1035 }
1036
1037 } // namespace webrtc
1038