blob: 69dfa1a0359746207cd52b2565d15a276f2dbcbe [file] [log] [blame]
stefan@webrtc.org792f1a12015-03-04 12:24:26 +00001/*
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
Jonas Olssona4d87372019-07-05 19:08:33 +020011#include "call/bitrate_allocator.h"
12
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000013#include <algorithm>
kwibergb25345e2016-03-12 06:10:44 -080014#include <memory>
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000015#include <vector>
16
Sebastian Jansson4ad51d82019-06-11 11:24:40 +020017#include "system_wrappers/include/clock.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020018#include "test/gmock.h"
19#include "test/gtest.h"
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000020
Seth Hampsonfe73d6a2017-11-14 10:49:06 -080021using ::testing::_;
Rasmus Brandt681de202019-02-04 15:09:34 +010022using ::testing::NiceMock;
perkj71ee44c2016-06-15 00:47:53 -070023
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000024namespace webrtc {
Sebastian Janssonfe617a32018-03-21 12:45:20 +010025// Emulating old interface for test suite compatibility.
26// TODO(srte): Update tests to reflect new interface.
27class LimitObserverWrapper : public BitrateAllocator::LimitObserver {
28 public:
Sebastian Janssonfe617a32018-03-21 12:45:20 +010029 virtual void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
30 uint32_t max_padding_bitrate_bps,
31 uint32_t total_bitrate_bps) = 0;
32};
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000033
Sebastian Janssonfe617a32018-03-21 12:45:20 +010034class MockLimitObserver : public LimitObserverWrapper {
perkj71ee44c2016-06-15 00:47:53 -070035 public:
philipelf69e7682018-02-28 13:06:28 +010036 MOCK_METHOD3(OnAllocationLimitsChanged,
perkj71ee44c2016-06-15 00:47:53 -070037 void(uint32_t min_send_bitrate_bps,
philipelf69e7682018-02-28 13:06:28 +010038 uint32_t max_padding_bitrate_bps,
39 uint32_t total_bitrate_bps));
perkj71ee44c2016-06-15 00:47:53 -070040};
41
mflodman86aabb22016-03-11 15:44:32 +010042class TestBitrateObserver : public BitrateAllocatorObserver {
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000043 public:
44 TestBitrateObserver()
mflodman48a4beb2016-07-01 13:03:59 +020045 : last_bitrate_bps_(0),
46 last_fraction_loss_(0),
47 last_rtt_ms_(0),
minyue78b4d562016-11-30 04:47:39 -080048 last_probing_interval_ms_(0),
mflodman48a4beb2016-07-01 13:03:59 +020049 protection_ratio_(0.0) {}
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000050
mflodman48a4beb2016-07-01 13:03:59 +020051 void SetBitrateProtectionRatio(double protection_ratio) {
52 protection_ratio_ = protection_ratio;
53 }
54
Sebastian Janssonc0e4d452018-10-25 15:08:32 +020055 uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override {
Sebastian Jansson13e59032018-11-21 19:13:07 +010056 last_bitrate_bps_ = update.target_bitrate.bps();
57 last_fraction_loss_ =
58 rtc::dchecked_cast<uint8_t>(update.packet_loss_ratio * 256);
59 last_rtt_ms_ = update.round_trip_time.ms();
60 last_probing_interval_ms_ = update.bwe_period.ms();
61 return update.target_bitrate.bps() * protection_ratio_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000062 }
mflodman101f2502016-06-09 17:21:19 +020063 uint32_t last_bitrate_bps_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000064 uint8_t last_fraction_loss_;
mflodman101f2502016-06-09 17:21:19 +020065 int64_t last_rtt_ms_;
minyue78b4d562016-11-30 04:47:39 -080066 int last_probing_interval_ms_;
mflodman48a4beb2016-07-01 13:03:59 +020067 double protection_ratio_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000068};
69
Sebastian Jansson89c94b92018-11-20 17:16:36 +010070class BitrateAllocatorForTest : public BitrateAllocator {
71 public:
72 using BitrateAllocator::BitrateAllocator;
73 void OnNetworkChanged(uint32_t target_bitrate_bps,
74 uint8_t fraction_loss,
75 int64_t rtt,
76 int64_t bwe_period_ms) {
77 BitrateAllocator::OnNetworkChanged(target_bitrate_bps, target_bitrate_bps,
78 fraction_loss, rtt, bwe_period_ms);
79 }
80};
81
minyue78b4d562016-11-30 04:47:39 -080082namespace {
83constexpr int64_t kDefaultProbingIntervalMs = 3000;
Seth Hampson24722b32017-12-22 09:36:42 -080084const double kDefaultBitratePriority = 1.0;
Yves Gerey665174f2018-06-19 15:03:05 +020085} // namespace
minyue78b4d562016-11-30 04:47:39 -080086
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000087class BitrateAllocatorTest : public ::testing::Test {
88 protected:
Sebastian Jansson89c94b92018-11-20 17:16:36 +010089 BitrateAllocatorTest()
Sebastian Janssonda6806c2019-03-04 17:05:12 +010090 : allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(),
91 &limit_observer_)) {
minyue78b4d562016-11-30 04:47:39 -080092 allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
Stefan Holmere5904162015-03-26 11:11:06 +010093 }
stefan@webrtc.org792f1a12015-03-04 12:24:26 +000094 ~BitrateAllocatorTest() {}
Sebastian Jansson24ad7202018-04-19 08:25:12 +020095 void AddObserver(BitrateAllocatorObserver* observer,
96 uint32_t min_bitrate_bps,
97 uint32_t max_bitrate_bps,
98 uint32_t pad_up_bitrate_bps,
99 bool enforce_min_bitrate,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200100 double bitrate_priority) {
101 allocator_->AddObserver(
Jonas Olsson0182a032019-07-09 12:31:20 +0200102 observer,
103 {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
104 /* priority_bitrate */ 0, enforce_min_bitrate, bitrate_priority});
Sebastian Jansson464a5572019-02-12 13:32:32 +0100105 }
106 MediaStreamAllocationConfig DefaultConfig() const {
107 MediaStreamAllocationConfig default_config;
108 default_config.min_bitrate_bps = 0;
109 default_config.max_bitrate_bps = 1500000;
110 default_config.pad_up_bitrate_bps = 0;
111 default_config.priority_bitrate_bps = 0;
112 default_config.enforce_min_bitrate = true;
Sebastian Jansson464a5572019-02-12 13:32:32 +0100113 default_config.bitrate_priority = kDefaultBitratePriority;
114 return default_config;
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200115 }
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000116
perkj71ee44c2016-06-15 00:47:53 -0700117 NiceMock<MockLimitObserver> limit_observer_;
Sebastian Jansson89c94b92018-11-20 17:16:36 +0100118 std::unique_ptr<BitrateAllocatorForTest> allocator_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000119};
120
Sebastian Jansson464a5572019-02-12 13:32:32 +0100121TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
122 TestBitrateObserver stream_a;
123 auto config_a = DefaultConfig();
124 config_a.min_bitrate_bps = 100000;
125 config_a.priority_bitrate_bps = 0;
126 allocator_->AddObserver(&stream_a, config_a);
127
128 TestBitrateObserver stream_b;
129 auto config_b = DefaultConfig();
130 config_b.min_bitrate_bps = 100000;
131 config_b.max_bitrate_bps = 300000;
132 config_b.priority_bitrate_bps = 300000;
133 allocator_->AddObserver(&stream_b, config_b);
134
135 allocator_->OnNetworkChanged(100000, 0, 0, 0);
136 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
137 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
138
139 allocator_->OnNetworkChanged(200000, 0, 0, 0);
140 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
141 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
142
143 allocator_->OnNetworkChanged(300000, 0, 0, 0);
144 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
145 EXPECT_EQ(stream_b.last_bitrate_bps_, 200000u);
146
147 allocator_->OnNetworkChanged(400000, 0, 0, 0);
148 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
149 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
150
151 allocator_->OnNetworkChanged(800000, 0, 0, 0);
152 EXPECT_EQ(stream_a.last_bitrate_bps_, 500000u);
153 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
154}
155
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000156TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
157 TestBitrateObserver bitrate_observer;
perkj71ee44c2016-06-15 00:47:53 -0700158 const uint32_t kMinSendBitrateBps = 100000;
159 const uint32_t kPadUpToBitrateBps = 50000;
philipelf69e7682018-02-28 13:06:28 +0100160 const uint32_t kMaxBitrateBps = 1500000;
perkj71ee44c2016-06-15 00:47:53 -0700161
philipelf69e7682018-02-28 13:06:28 +0100162 EXPECT_CALL(limit_observer_,
163 OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
164 kMaxBitrateBps));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200165 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
Jonas Olsson0182a032019-07-09 12:31:20 +0200166 kPadUpToBitrateBps, true, kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700167 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
minyue78b4d562016-11-30 04:47:39 -0800168 allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
perkj57c21f92016-06-17 07:27:16 -0700169 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000170
Peter Boström8e4e8b02015-09-15 15:08:03 +0200171 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max
mflodman0e7e2592015-11-12 21:02:42 -0800172 // bitrate for FEC/retransmissions (see todo in BitrateAllocator).
minyue78b4d562016-11-30 04:47:39 -0800173 allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs);
perkj57c21f92016-06-17 07:27:16 -0700174 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
perkj71ee44c2016-06-15 00:47:53 -0700175
176 // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
177 EXPECT_CALL(limit_observer_,
philipelf69e7682018-02-28 13:06:28 +0100178 OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
Jonas Olsson0182a032019-07-09 12:31:20 +0200179 AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200180 kDefaultBitratePriority);
Sebastian Jansson448f4d52018-04-04 14:52:07 +0200181 EXPECT_CALL(limit_observer_,
182 OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
perkj57c21f92016-06-17 07:27:16 -0700183 EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000184
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200185 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 12:31:20 +0200186 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700187 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
mflodman101f2502016-06-09 17:21:19 +0200188 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
philipelf69e7682018-02-28 13:06:28 +0100189 allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200190 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000191}
192
193TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
194 TestBitrateObserver bitrate_observer_1;
195 TestBitrateObserver bitrate_observer_2;
philipelf69e7682018-02-28 13:06:28 +0100196 const uint32_t kObs1StartBitrateBps = 100000;
197 const uint32_t kObs2StartBitrateBps = 200000;
198 const uint32_t kObs1MaxBitrateBps = 300000;
199 const uint32_t kObs2MaxBitrateBps = 300000;
200
201 EXPECT_CALL(
202 limit_observer_,
203 OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200204 AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0,
Jonas Olsson0182a032019-07-09 12:31:20 +0200205 true, kDefaultBitratePriority);
philipelf69e7682018-02-28 13:06:28 +0100206 EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
207 allocator_->GetStartBitrate(&bitrate_observer_1));
208 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
209 kObs1StartBitrateBps + kObs2StartBitrateBps,
210 0, kObs1MaxBitrateBps + kObs2MaxBitrateBps));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200211 AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0,
Jonas Olsson0182a032019-07-09 12:31:20 +0200212 true, kDefaultBitratePriority);
philipelf69e7682018-02-28 13:06:28 +0100213 EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
214 allocator_->GetStartBitrate(&bitrate_observer_2));
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000215
mflodman48a4beb2016-07-01 13:03:59 +0200216 // Test too low start bitrate, hence lower than sum of min. Min bitrates
217 // will
218 // be allocated to all observers.
philipelf69e7682018-02-28 13:06:28 +0100219 allocator_->OnNetworkChanged(kObs2StartBitrateBps, 0, 50,
220 kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200221 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
222 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
223 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
224 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
225 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_);
226 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000227
mflodman48a4beb2016-07-01 13:03:59 +0200228 // Test a bitrate which should be distributed equally.
minyue78b4d562016-11-30 04:47:39 -0800229 allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs);
philipelf69e7682018-02-28 13:06:28 +0100230 const uint32_t kBitrateToShare =
231 500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
mflodman48a4beb2016-07-01 13:03:59 +0200232 EXPECT_EQ(100000u + kBitrateToShare / 2,
233 bitrate_observer_1.last_bitrate_bps_);
234 EXPECT_EQ(200000u + kBitrateToShare / 2,
235 bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000236
mflodman48a4beb2016-07-01 13:03:59 +0200237 // Limited by 2x max bitrates since we leave room for FEC and
238 // retransmissions.
minyue78b4d562016-11-30 04:47:39 -0800239 allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200240 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_);
241 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_);
perkjec81bcd2016-05-11 06:01:13 -0700242
mflodman48a4beb2016-07-01 13:03:59 +0200243 // Verify that if the bandwidth estimate is set to zero, the allocated
244 // rate is
245 // zero.
minyue78b4d562016-11-30 04:47:39 -0800246 allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200247 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
248 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000249}
250
perkj71ee44c2016-06-15 00:47:53 -0700251TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
252 TestBitrateObserver bitrate_observer;
253 const uint32_t kMinSendBitrateBps = 100000;
254 const uint32_t kPadUpToBitrateBps = 50000;
philipelf69e7682018-02-28 13:06:28 +0100255 const uint32_t kMaxBitrateBps = 1500000;
perkj71ee44c2016-06-15 00:47:53 -0700256
philipelf69e7682018-02-28 13:06:28 +0100257 EXPECT_CALL(limit_observer_,
258 OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
259 kMaxBitrateBps));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200260 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
Jonas Olsson0182a032019-07-09 12:31:20 +0200261 kPadUpToBitrateBps, true, kDefaultBitratePriority);
philipelf69e7682018-02-28 13:06:28 +0100262 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
perkj71ee44c2016-06-15 00:47:53 -0700263 allocator_->RemoveObserver(&bitrate_observer);
264}
265
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000266class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
267 protected:
perkj71ee44c2016-06-15 00:47:53 -0700268 BitrateAllocatorTestNoEnforceMin()
Sebastian Janssonda6806c2019-03-04 17:05:12 +0100269 : allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(),
270 &limit_observer_)) {
minyue78b4d562016-11-30 04:47:39 -0800271 allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000272 }
273 ~BitrateAllocatorTestNoEnforceMin() {}
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200274 void AddObserver(BitrateAllocatorObserver* observer,
275 uint32_t min_bitrate_bps,
276 uint32_t max_bitrate_bps,
277 uint32_t pad_up_bitrate_bps,
278 bool enforce_min_bitrate,
279 std::string track_id,
280 double bitrate_priority) {
281 allocator_->AddObserver(
Sebastian Jansson464a5572019-02-12 13:32:32 +0100282 observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,
Jonas Olsson0182a032019-07-09 12:31:20 +0200283 enforce_min_bitrate, bitrate_priority});
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200284 }
perkj71ee44c2016-06-15 00:47:53 -0700285 NiceMock<MockLimitObserver> limit_observer_;
Sebastian Jansson89c94b92018-11-20 17:16:36 +0100286 std::unique_ptr<BitrateAllocatorForTest> allocator_;
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000287};
288
mflodman101f2502016-06-09 17:21:19 +0200289// The following three tests verify enforcing a minimum bitrate works as
290// intended.
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000291TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
292 TestBitrateObserver bitrate_observer_1;
perkj71ee44c2016-06-15 00:47:53 -0700293 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
294 // AddObserver is called with |enforce_min_bitrate| = false.
Sebastian Jansson448f4d52018-04-04 14:52:07 +0200295 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
philipelf69e7682018-02-28 13:06:28 +0100296 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000, _));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200297 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
298 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200299 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000300
mflodman48a4beb2016-07-01 13:03:59 +0200301 // High BWE.
minyue78b4d562016-11-30 04:47:39 -0800302 allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200303 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000304
mflodman48a4beb2016-07-01 13:03:59 +0200305 // Low BWE.
minyue78b4d562016-11-30 04:47:39 -0800306 allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200307 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000308
philipelf69e7682018-02-28 13:06:28 +0100309 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
mflodman48a4beb2016-07-01 13:03:59 +0200310 allocator_->RemoveObserver(&bitrate_observer_1);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000311}
312
313TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
314 TestBitrateObserver bitrate_observer_1;
315 TestBitrateObserver bitrate_observer_2;
316 TestBitrateObserver bitrate_observer_3;
317 // Set up the observers with min bitrates at 100000, 200000, and 300000.
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200318 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
319 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700320 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
Stefan Holmere5904162015-03-26 11:11:06 +0100321
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200322 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
323 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700324 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 17:21:19 +0200325 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
Stefan Holmere5904162015-03-26 11:11:06 +0100326
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200327 AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
328 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700329 EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
mflodman101f2502016-06-09 17:21:19 +0200330 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
331 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000332
mflodman101f2502016-06-09 17:21:19 +0200333 // High BWE. Make sure the controllers get a fair share of the surplus (i.e.,
334 // what is left after each controller gets its min rate).
minyue78b4d562016-11-30 04:47:39 -0800335 allocator_->OnNetworkChanged(690000, 0, 0, kDefaultProbingIntervalMs);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000336 // Verify that each observer gets its min rate (sum of min rates is 600000),
337 // and that the remaining 90000 is divided equally among the three.
Stefan Holmere5904162015-03-26 11:11:06 +0100338 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
mflodman101f2502016-06-09 17:21:19 +0200339 EXPECT_EQ(100000u + bitrate_to_share / 3,
340 bitrate_observer_1.last_bitrate_bps_);
341 EXPECT_EQ(200000u + bitrate_to_share / 3,
342 bitrate_observer_2.last_bitrate_bps_);
343 EXPECT_EQ(300000u + bitrate_to_share / 3,
344 bitrate_observer_3.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000345
mflodman101f2502016-06-09 17:21:19 +0200346 // BWE below the sum of observer's min bitrate.
minyue78b4d562016-11-30 04:47:39 -0800347 allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200348 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate.
349 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate.
Yves Gerey665174f2018-06-19 15:03:05 +0200350 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
mflodman101f2502016-06-09 17:21:19 +0200351
352 // Increased BWE, but still below the sum of configured min bitrates for all
353 // observers and too little for observer 3. 1 and 2 will share the rest.
minyue78b4d562016-11-30 04:47:39 -0800354 allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200355 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split.
356 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split.
Yves Gerey665174f2018-06-19 15:03:05 +0200357 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000358
mflodman101f2502016-06-09 17:21:19 +0200359 // Below min for all.
minyue78b4d562016-11-30 04:47:39 -0800360 allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200361 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
362 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
363 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000364
perkjec81bcd2016-05-11 06:01:13 -0700365 // Verify that zero estimated bandwidth, means that that all gets zero,
366 // regardless of set min bitrate.
minyue78b4d562016-11-30 04:47:39 -0800367 allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200368 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
369 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
370 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
perkjec81bcd2016-05-11 06:01:13 -0700371
mflodman86aabb22016-03-11 15:44:32 +0100372 allocator_->RemoveObserver(&bitrate_observer_1);
373 allocator_->RemoveObserver(&bitrate_observer_2);
374 allocator_->RemoveObserver(&bitrate_observer_3);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000375}
376
mflodman48a4beb2016-07-01 13:03:59 +0200377TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
Erik Språngd1d7b232018-12-06 17:31:25 +0100378 const uint32_t kMinBitrateBps = 100000;
379 const uint32_t kMaxBitrateBps = 400000;
380 // Hysteresis adds another 10% or 20kbps to min bitrate.
381 const uint32_t kMinStartBitrateBps =
382 kMinBitrateBps + std::max(20000u, kMinBitrateBps / 10);
383
mflodman48a4beb2016-07-01 13:03:59 +0200384 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
385 // AddObserver is called with |enforce_min_bitrate| = false.
Erik Språngd1d7b232018-12-06 17:31:25 +0100386 TestBitrateObserver bitrate_observer;
387 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, kMaxBitrateBps));
388 AddObserver(&bitrate_observer, kMinBitrateBps, kMaxBitrateBps, 0, false, "",
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200389 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200390 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
391
392 // High BWE.
minyue78b4d562016-11-30 04:47:39 -0800393 allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200394 EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
395
396 // Add loss and use a part of the bitrate for protection.
Erik Språngd1d7b232018-12-06 17:31:25 +0100397 const double kProtectionRatio = 0.4;
Rasmus Brandt681de202019-02-04 15:09:34 +0100398 const uint8_t fraction_loss = kProtectionRatio * 256;
Erik Språngd1d7b232018-12-06 17:31:25 +0100399 bitrate_observer.SetBitrateProtectionRatio(kProtectionRatio);
Rasmus Brandt681de202019-02-04 15:09:34 +0100400 allocator_->OnNetworkChanged(200000, 0, fraction_loss,
minyue78b4d562016-11-30 04:47:39 -0800401 kDefaultProbingIntervalMs);
Rasmus Brandt681de202019-02-04 15:09:34 +0100402 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 13:03:59 +0200403
404 // Above the min threshold, but not enough given the protection used.
Erik Språngd1d7b232018-12-06 17:31:25 +0100405 // Limits changed, as we will video is now off and we need to pad up to the
406 // start bitrate.
Erik Språngd1d7b232018-12-06 17:31:25 +0100407 // Verify the hysteresis is added for the protection.
408 const uint32_t kMinStartBitrateWithProtectionBps =
409 static_cast<uint32_t>(kMinStartBitrateBps * (1 + kProtectionRatio));
410 EXPECT_CALL(limit_observer_,
411 OnAllocationLimitsChanged(0, kMinStartBitrateWithProtectionBps,
Rasmus Brandt681de202019-02-04 15:09:34 +0100412 kMaxBitrateBps));
Erik Språngd1d7b232018-12-06 17:31:25 +0100413 allocator_->OnNetworkChanged(kMinStartBitrateBps + 1000, 0, fraction_loss,
minyue78b4d562016-11-30 04:47:39 -0800414 kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200415 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
416
Erik Språngd1d7b232018-12-06 17:31:25 +0100417 allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0,
418 fraction_loss, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200419 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
420
421 // Just enough to enable video again.
Rasmus Brandt681de202019-02-04 15:09:34 +0100422 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, kMaxBitrateBps));
Erik Språngd1d7b232018-12-06 17:31:25 +0100423 allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps, 0,
424 fraction_loss, kDefaultProbingIntervalMs);
425 EXPECT_EQ(kMinStartBitrateWithProtectionBps,
426 bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 13:03:59 +0200427
428 // Remove all protection and make sure video is not paused as earlier.
429 bitrate_observer.SetBitrateProtectionRatio(0.0);
Erik Språngd1d7b232018-12-06 17:31:25 +0100430 allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0, 0,
431 kDefaultProbingIntervalMs);
432 EXPECT_EQ(kMinStartBitrateWithProtectionBps - 1000,
433 bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 13:03:59 +0200434
Erik Språngd1d7b232018-12-06 17:31:25 +0100435 allocator_->OnNetworkChanged(kMinStartBitrateBps, 0, 0,
436 kDefaultProbingIntervalMs);
437 EXPECT_EQ(kMinStartBitrateBps, bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 13:03:59 +0200438
Erik Språngd1d7b232018-12-06 17:31:25 +0100439 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, 0));
mflodman48a4beb2016-07-01 13:03:59 +0200440 allocator_->RemoveObserver(&bitrate_observer);
441}
442
Rasmus Brandt681de202019-02-04 15:09:34 +0100443TEST_F(BitrateAllocatorTest,
444 TotalAllocationLimitsAreUnaffectedByProtectionRatio) {
445 TestBitrateObserver bitrate_observer;
446
447 const uint32_t kMinBitrateBps = 100000;
448 const uint32_t kMaxBitrateBps = 400000;
449
450 // Register |bitrate_observer| and expect total allocation limits to change.
451 EXPECT_CALL(limit_observer_,
452 OnAllocationLimitsChanged(kMinBitrateBps, 0, kMaxBitrateBps))
453 .Times(1);
Sebastian Jansson464a5572019-02-12 13:32:32 +0100454 MediaStreamAllocationConfig allocation_config = DefaultConfig();
455 allocation_config.min_bitrate_bps = kMinBitrateBps;
456 allocation_config.max_bitrate_bps = kMaxBitrateBps;
457 allocator_->AddObserver(&bitrate_observer, allocation_config);
Rasmus Brandt681de202019-02-04 15:09:34 +0100458
459 // Observer uses 20% of it's allocated bitrate for protection.
460 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
461 // Total allocation limits are unaffected by the protection rate change.
462 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_, _, _)).Times(0);
463 allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
464
465 // Observer uses 0% of it's allocated bitrate for protection.
466 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.0);
467 // Total allocation limits are unaffected by the protection rate change.
468 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_, _, _)).Times(0);
469 allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
470
471 // Observer again uses 20% of it's allocated bitrate for protection.
472 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
473 // Total allocation limits are unaffected by the protection rate change.
474 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_, _, _)).Times(0);
475 allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
476}
477
mflodman48a4beb2016-07-01 13:03:59 +0200478TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
479 TestBitrateObserver bitrate_observer_1;
480 TestBitrateObserver bitrate_observer_2;
481
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200482 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
483 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200484 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200485 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
486 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200487 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
488 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
489
490 // Enough bitrate for both.
491 bitrate_observer_2.SetBitrateProtectionRatio(0.5);
minyue78b4d562016-11-30 04:47:39 -0800492 allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200493 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
494 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
495
496 // Above min for observer 2, but too little given the protection used.
minyue78b4d562016-11-30 04:47:39 -0800497 allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200498 EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);
499 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
500
minyue78b4d562016-11-30 04:47:39 -0800501 allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200502 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
503 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
504
minyue78b4d562016-11-30 04:47:39 -0800505 allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200506 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
507 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
508
minyue78b4d562016-11-30 04:47:39 -0800509 allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200510 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
511 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
512
minyue78b4d562016-11-30 04:47:39 -0800513 allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200514 EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_);
515 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
516
517 // Verify the protection is accounted for before resuming observer 2.
minyue78b4d562016-11-30 04:47:39 -0800518 allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200519 EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);
520 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
521
minyue78b4d562016-11-30 04:47:39 -0800522 allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200523 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
524 EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);
525
526 allocator_->RemoveObserver(&bitrate_observer_1);
527 allocator_->RemoveObserver(&bitrate_observer_2);
528}
529
mflodman101f2502016-06-09 17:21:19 +0200530TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000531 TestBitrateObserver bitrate_observer_1;
532 TestBitrateObserver bitrate_observer_2;
533 TestBitrateObserver bitrate_observer_3;
Stefan Holmere5904162015-03-26 11:11:06 +0100534
Jonas Olsson0182a032019-07-09 12:31:20 +0200535 AddObserver(&bitrate_observer_1, 100000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200536 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700537 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
538
Jonas Olsson0182a032019-07-09 12:31:20 +0200539 AddObserver(&bitrate_observer_2, 200000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200540 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700541 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 17:21:19 +0200542 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
Stefan Holmere5904162015-03-26 11:11:06 +0100543
Jonas Olsson0182a032019-07-09 12:31:20 +0200544 AddObserver(&bitrate_observer_3, 300000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200545 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200546 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
547 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
548 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000549
mflodman48a4beb2016-07-01 13:03:59 +0200550 // Low BWE. Verify that all observers still get their respective min
551 // bitrate.
minyue78b4d562016-11-30 04:47:39 -0800552 allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200553 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap.
554 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap.
555 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap.
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000556
mflodman48a4beb2016-07-01 13:03:59 +0200557 allocator_->RemoveObserver(&bitrate_observer_1);
558 allocator_->RemoveObserver(&bitrate_observer_2);
559 allocator_->RemoveObserver(&bitrate_observer_3);
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000560}
perkjfea93092016-05-14 00:58:48 -0700561
562TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
563 TestBitrateObserver bitrate_observer_1;
philipelf69e7682018-02-28 13:06:28 +0100564 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _));
perkj57c21f92016-06-17 07:27:16 -0700565
Jonas Olsson0182a032019-07-09 12:31:20 +0200566 AddObserver(&bitrate_observer_1, 50000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200567 kDefaultBitratePriority);
perkj57c21f92016-06-17 07:27:16 -0700568 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
perkjfea93092016-05-14 00:58:48 -0700569
570 // Set network down, ie, no available bitrate.
minyue78b4d562016-11-30 04:47:39 -0800571 allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
perkjfea93092016-05-14 00:58:48 -0700572
mflodman101f2502016-06-09 17:21:19 +0200573 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
perkjfea93092016-05-14 00:58:48 -0700574
575 TestBitrateObserver bitrate_observer_2;
perkj71ee44c2016-06-15 00:47:53 -0700576 // Adding an observer while the network is down should not affect the limits.
philipelf69e7682018-02-28 13:06:28 +0100577 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _));
Jonas Olsson0182a032019-07-09 12:31:20 +0200578 AddObserver(&bitrate_observer_2, 50000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200579 kDefaultBitratePriority);
perkjfea93092016-05-14 00:58:48 -0700580
581 // Expect the start_bitrate to be set as if the network was still up but that
582 // the new observer have been notified that the network is down.
perkj57c21f92016-06-17 07:27:16 -0700583 EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 17:21:19 +0200584 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
585 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
perkjfea93092016-05-14 00:58:48 -0700586
587 // Set network back up.
minyue78b4d562016-11-30 04:47:39 -0800588 allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
mflodman101f2502016-06-09 17:21:19 +0200589 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);
590 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);
591}
592
593TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
594 TestBitrateObserver enforced_observer;
Jonas Olsson0182a032019-07-09 12:31:20 +0200595 AddObserver(&enforced_observer, 6000, 30000, 0, true,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200596 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200597 EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
mflodman101f2502016-06-09 17:21:19 +0200598
mflodman48a4beb2016-07-01 13:03:59 +0200599 TestBitrateObserver not_enforced_observer;
Jonas Olsson0182a032019-07-09 12:31:20 +0200600 AddObserver(&not_enforced_observer, 30000, 2500000, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200601 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200602 EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
603 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200604
minyue78b4d562016-11-30 04:47:39 -0800605 allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200606 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
607 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200608
minyue78b4d562016-11-30 04:47:39 -0800609 allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200610 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
611 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200612
minyue78b4d562016-11-30 04:47:39 -0800613 allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200614 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
615 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200616
minyue78b4d562016-11-30 04:47:39 -0800617 allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200618 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
619 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200620
minyue78b4d562016-11-30 04:47:39 -0800621 allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200622 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
623 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200624
minyue78b4d562016-11-30 04:47:39 -0800625 allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200626 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
627 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200628
minyue78b4d562016-11-30 04:47:39 -0800629 allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200630 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);
631 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200632
mflodman48a4beb2016-07-01 13:03:59 +0200633 allocator_->RemoveObserver(&enforced_observer);
634 allocator_->RemoveObserver(&not_enforced_observer);
mflodman101f2502016-06-09 17:21:19 +0200635}
636
637TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
638 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 12:31:20 +0200639 AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200640 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
mflodman101f2502016-06-09 17:21:19 +0200641
minyue78b4d562016-11-30 04:47:39 -0800642 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200643 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200644
minyue78b4d562016-11-30 04:47:39 -0800645 allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200646 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200647
minyue78b4d562016-11-30 04:47:39 -0800648 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200649 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200650
minyue78b4d562016-11-30 04:47:39 -0800651 allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200652 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200653
minyue78b4d562016-11-30 04:47:39 -0800654 allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200655 EXPECT_EQ(50000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200656
minyue78b4d562016-11-30 04:47:39 -0800657 allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200658 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200659
mflodman48a4beb2016-07-01 13:03:59 +0200660 allocator_->RemoveObserver(&observer);
mflodman101f2502016-06-09 17:21:19 +0200661}
662
663TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
664 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 12:31:20 +0200665 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
mflodman48a4beb2016-07-01 13:03:59 +0200666 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
mflodman101f2502016-06-09 17:21:19 +0200667
minyue78b4d562016-11-30 04:47:39 -0800668 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200669 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200670
minyue78b4d562016-11-30 04:47:39 -0800671 allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200672 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200673
minyue78b4d562016-11-30 04:47:39 -0800674 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200675 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200676
minyue78b4d562016-11-30 04:47:39 -0800677 allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200678 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200679
minyue78b4d562016-11-30 04:47:39 -0800680 allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200681 EXPECT_EQ(330000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200682
minyue78b4d562016-11-30 04:47:39 -0800683 allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
mflodman48a4beb2016-07-01 13:03:59 +0200684 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 17:21:19 +0200685
mflodman48a4beb2016-07-01 13:03:59 +0200686 allocator_->RemoveObserver(&observer);
perkjfea93092016-05-14 00:58:48 -0700687}
688
minyue78b4d562016-11-30 04:47:39 -0800689TEST_F(BitrateAllocatorTest, PassProbingInterval) {
690 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 12:31:20 +0200691 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
minyue78b4d562016-11-30 04:47:39 -0800692 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
693
694 allocator_->OnNetworkChanged(300000, 0, 50, 5000);
695 EXPECT_EQ(5000, observer.last_probing_interval_ms_);
696
697 allocator_->RemoveObserver(&observer);
698}
699
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800700TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
701 TestBitrateObserver observer;
702 const uint32_t kMinSendBitrateBps = 10;
703 const uint32_t kMaxSendBitrateBps = 60;
704 const uint32_t kNetworkBandwidthBps = 30;
705
Jonas Olsson0182a032019-07-09 12:31:20 +0200706 AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800707 allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
708 kDefaultProbingIntervalMs);
709
710 EXPECT_EQ(kNetworkBandwidthBps, observer.last_bitrate_bps_);
711
712 allocator_->RemoveObserver(&observer);
713}
714
715// Tests that two observers with the same bitrate priority are allocated
716// their bitrate evenly.
717TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
718 TestBitrateObserver observer_low_1;
719 TestBitrateObserver observer_low_2;
720 const uint32_t kMinSendBitrateBps = 10;
721 const uint32_t kMaxSendBitrateBps = 60;
722 const uint32_t kNetworkBandwidthBps = 60;
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200723 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
Jonas Olsson0182a032019-07-09 12:31:20 +0200724 2.0);
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200725 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
Jonas Olsson0182a032019-07-09 12:31:20 +0200726 2.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800727 allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
728 kDefaultProbingIntervalMs);
729
730 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
731 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
732
733 allocator_->RemoveObserver(&observer_low_1);
734 allocator_->RemoveObserver(&observer_low_2);
735}
736
737// Tests that there is no difference in functionality when the min bitrate is
738// enforced.
739TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
740 TestBitrateObserver observer_low_1;
741 TestBitrateObserver observer_low_2;
742 const uint32_t kMinSendBitrateBps = 0;
743 const uint32_t kMaxSendBitrateBps = 60;
744 const uint32_t kNetworkBandwidthBps = 60;
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200745 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 12:31:20 +0200746 2.0);
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200747 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 12:31:20 +0200748 2.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800749 allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
750 kDefaultProbingIntervalMs);
751
752 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
753 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
754
755 allocator_->RemoveObserver(&observer_low_1);
756 allocator_->RemoveObserver(&observer_low_2);
757}
758
759// Tests that if the available bandwidth is the sum of the max bitrate
760// of all observers, they will be allocated their max.
761TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
762 TestBitrateObserver observer_low;
763 TestBitrateObserver observer_mid;
764 const uint32_t kMinSendBitrateBps = 0;
765 const uint32_t kMaxSendBitrateBps = 60;
766 const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2;
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200767 AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 12:31:20 +0200768 2.0);
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200769 AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 12:31:20 +0200770 4.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800771 allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
772 kDefaultProbingIntervalMs);
773
774 EXPECT_EQ(kMaxSendBitrateBps, observer_low.last_bitrate_bps_);
775 EXPECT_EQ(kMaxSendBitrateBps, observer_mid.last_bitrate_bps_);
776
777 allocator_->RemoveObserver(&observer_low);
778 allocator_->RemoveObserver(&observer_mid);
779}
780
781// Tests that after a higher bitrate priority observer has been allocated its
782// max bitrate the lower priority observer will then be allocated the remaining
783// bitrate.
784TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
785 TestBitrateObserver observer_low;
786 TestBitrateObserver observer_mid;
Jonas Olsson0182a032019-07-09 12:31:20 +0200787 AddObserver(&observer_low, 10, 50, 0, false, 2.0);
788 AddObserver(&observer_mid, 10, 50, 0, false, 4.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800789 allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs);
790
791 EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
792 EXPECT_EQ(50u, observer_mid.last_bitrate_bps_);
793
794 allocator_->RemoveObserver(&observer_low);
795 allocator_->RemoveObserver(&observer_mid);
796}
797
798// Tests that three observers with three different bitrate priorities will all
799// be allocated bitrate according to their relative bitrate priority.
800TEST_F(BitrateAllocatorTest,
801 PriorityRateThreeObserversAllocatedRelativeAmounts) {
802 TestBitrateObserver observer_low;
803 TestBitrateObserver observer_mid;
804 TestBitrateObserver observer_high;
805 const uint32_t kMaxBitrate = 100;
806 // Not enough bandwidth to fill any observer's max bitrate.
807 const uint32_t kNetworkBandwidthBps = 70;
808 const double kLowBitratePriority = 2.0;
809 const double kMidBitratePriority = 4.0;
810 const double kHighBitratePriority = 8.0;
811 const double kTotalBitratePriority =
812 kLowBitratePriority + kMidBitratePriority + kHighBitratePriority;
Jonas Olsson0182a032019-07-09 12:31:20 +0200813 AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority);
814 AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority);
815 AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800816 allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
817 kDefaultProbingIntervalMs);
818
819 const double kLowFractionAllocated =
820 kLowBitratePriority / kTotalBitratePriority;
821 const double kMidFractionAllocated =
822 kMidBitratePriority / kTotalBitratePriority;
823 const double kHighFractionAllocated =
824 kHighBitratePriority / kTotalBitratePriority;
825 EXPECT_EQ(kLowFractionAllocated * kNetworkBandwidthBps,
826 observer_low.last_bitrate_bps_);
827 EXPECT_EQ(kMidFractionAllocated * kNetworkBandwidthBps,
828 observer_mid.last_bitrate_bps_);
829 EXPECT_EQ(kHighFractionAllocated * kNetworkBandwidthBps,
830 observer_high.last_bitrate_bps_);
831
832 allocator_->RemoveObserver(&observer_low);
833 allocator_->RemoveObserver(&observer_mid);
834 allocator_->RemoveObserver(&observer_high);
835}
836
837// Tests that after the high priority observer has been allocated its maximum
838// bitrate, the other two observers are still allocated bitrate according to
839// their relative bitrate priority.
840TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
841 TestBitrateObserver observer_low;
842 const double kLowBitratePriority = 2.0;
843 TestBitrateObserver observer_mid;
844 const double kMidBitratePriority = 4.0;
845 TestBitrateObserver observer_high;
846 const double kHighBitratePriority = 8.0;
847
848 const uint32_t kAvailableBitrate = 90;
849 const uint32_t kMaxBitrate = 40;
850 const uint32_t kMinBitrate = 10;
851 // Remaining bitrate after allocating to all mins and knowing that the high
852 // priority observer will have its max bitrate allocated.
853 const uint32_t kRemainingBitrate =
854 kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate);
855
Jonas Olsson0182a032019-07-09 12:31:20 +0200856 AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200857 kLowBitratePriority);
Jonas Olsson0182a032019-07-09 12:31:20 +0200858 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200859 kMidBitratePriority);
Jonas Olsson0182a032019-07-09 12:31:20 +0200860 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200861 kHighBitratePriority);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800862 allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
863 kDefaultProbingIntervalMs);
864
865 const double kLowFractionAllocated =
866 kLowBitratePriority / (kLowBitratePriority + kMidBitratePriority);
867 const double kMidFractionAllocated =
868 kMidBitratePriority / (kLowBitratePriority + kMidBitratePriority);
869 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kLowFractionAllocated),
870 observer_low.last_bitrate_bps_);
871 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
872 observer_mid.last_bitrate_bps_);
873 EXPECT_EQ(40u, observer_high.last_bitrate_bps_);
874
875 allocator_->RemoveObserver(&observer_low);
876 allocator_->RemoveObserver(&observer_mid);
877 allocator_->RemoveObserver(&observer_high);
878}
879
880// Tests that after the low priority observer has been allocated its maximum
881// bitrate, the other two observers are still allocated bitrate according to
882// their relative bitrate priority.
883TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
884 TestBitrateObserver observer_low;
885 const double kLowBitratePriority = 2.0;
886 const uint32_t kLowMaxBitrate = 10;
887 TestBitrateObserver observer_mid;
888 const double kMidBitratePriority = 4.0;
889 TestBitrateObserver observer_high;
890 const double kHighBitratePriority = 8.0;
891
892 const uint32_t kMinBitrate = 0;
893 const uint32_t kMaxBitrate = 60;
894 const uint32_t kAvailableBitrate = 100;
895 // Remaining bitrate knowing that the low priority observer is allocated its
896 // max bitrate. We know this because it is allocated 2.0/14.0 (1/7) of the
897 // available bitrate, so 70 bps would be sufficient network bandwidth.
898 const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate;
899
Jonas Olsson0182a032019-07-09 12:31:20 +0200900 AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200901 kLowBitratePriority);
Jonas Olsson0182a032019-07-09 12:31:20 +0200902 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200903 kMidBitratePriority);
Jonas Olsson0182a032019-07-09 12:31:20 +0200904 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 08:25:12 +0200905 kHighBitratePriority);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800906 allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
907 kDefaultProbingIntervalMs);
908
909 const double kMidFractionAllocated =
910 kMidBitratePriority / (kMidBitratePriority + kHighBitratePriority);
911 const double kHighFractionAllocated =
912 kHighBitratePriority / (kMidBitratePriority + kHighBitratePriority);
913 EXPECT_EQ(kLowMaxBitrate, observer_low.last_bitrate_bps_);
914 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
915 observer_mid.last_bitrate_bps_);
916 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kHighFractionAllocated),
917 observer_high.last_bitrate_bps_);
918
919 allocator_->RemoveObserver(&observer_low);
920 allocator_->RemoveObserver(&observer_mid);
921 allocator_->RemoveObserver(&observer_high);
922}
923
924// Tests that after two observers are allocated bitrate to their max, the
925// the remaining observer is allocated what's left appropriately. This test
926// handles an edge case where the medium and high observer reach their
927// "relative" max allocation at the same time. The high has 40 to allocate
928// above its min, and the mid has 20 to allocate above its min, which scaled
929// by their bitrate priority is the same for each.
930TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
931 TestBitrateObserver observer_low;
932 TestBitrateObserver observer_mid;
933 TestBitrateObserver observer_high;
Jonas Olsson0182a032019-07-09 12:31:20 +0200934 AddObserver(&observer_low, 10, 40, 0, false, 2.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800935 // Scaled allocation above the min allocation is the same for these two,
936 // meaning they will get allocated their max at the same time.
937 // Scaled (target allocation) = (max - min) / bitrate priority
Jonas Olsson0182a032019-07-09 12:31:20 +0200938 AddObserver(&observer_mid, 10, 30, 0, false, 4.0);
939 AddObserver(&observer_high, 10, 50, 0, false, 8.0);
Seth Hampsonfe73d6a2017-11-14 10:49:06 -0800940 allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs);
941
942 EXPECT_EQ(30u, observer_low.last_bitrate_bps_);
943 EXPECT_EQ(30u, observer_mid.last_bitrate_bps_);
944 EXPECT_EQ(50u, observer_high.last_bitrate_bps_);
945
946 allocator_->RemoveObserver(&observer_low);
947 allocator_->RemoveObserver(&observer_mid);
948 allocator_->RemoveObserver(&observer_high);
949}
950
stefan@webrtc.org792f1a12015-03-04 12:24:26 +0000951} // namespace webrtc