blob: 00fb23694832902a3029fd9f838e07d245647c61 [file] [log] [blame]
stefan@webrtc.org792f1a12015-03-04 12:24:261/*
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 17:08:3311#include "call/bitrate_allocator.h"
12
stefan@webrtc.org792f1a12015-03-04 12:24:2613#include <algorithm>
kwibergb25345e2016-03-12 14:10:4414#include <memory>
stefan@webrtc.org792f1a12015-03-04 12:24:2615#include <vector>
16
Sebastian Jansson4ad51d82019-06-11 09:24:4017#include "system_wrappers/include/clock.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3118#include "test/gmock.h"
19#include "test/gtest.h"
stefan@webrtc.org792f1a12015-03-04 12:24:2620
Seth Hampsonfe73d6a2017-11-14 18:49:0621using ::testing::_;
Sebastian Jansson93b1ea22019-09-18 16:31:5222using ::testing::AllOf;
23using ::testing::Field;
Rasmus Brandt681de202019-02-04 14:09:3424using ::testing::NiceMock;
perkj71ee44c2016-06-15 07:47:5325
stefan@webrtc.org792f1a12015-03-04 12:24:2626namespace webrtc {
27
Sebastian Jansson40de3cc2019-09-19 12:54:4328namespace {
Sebastian Jansson93b1ea22019-09-18 16:31:5229auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
30 uint32_t max_padding_rate_bps,
31 uint32_t max_allocatable_rate_bps) {
32 return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
Danil Chapovalovcad3e0e2020-02-17 17:46:0733 DataRate::BitsPerSec(min_allocatable_rate_bps)),
Sebastian Jansson93b1ea22019-09-18 16:31:5234 Field(&BitrateAllocationLimits::max_allocatable_rate,
Danil Chapovalovcad3e0e2020-02-17 17:46:0735 DataRate::BitsPerSec(max_allocatable_rate_bps)),
Sebastian Jansson93b1ea22019-09-18 16:31:5236 Field(&BitrateAllocationLimits::max_padding_rate,
Danil Chapovalovcad3e0e2020-02-17 17:46:0737 DataRate::BitsPerSec(max_padding_rate_bps)));
Sebastian Jansson93b1ea22019-09-18 16:31:5238}
39
40auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
41 uint32_t max_padding_rate_bps) {
42 return AllOf(Field(&BitrateAllocationLimits::min_allocatable_rate,
Danil Chapovalovcad3e0e2020-02-17 17:46:0743 DataRate::BitsPerSec(min_allocatable_rate_bps)),
Sebastian Jansson93b1ea22019-09-18 16:31:5244 Field(&BitrateAllocationLimits::max_padding_rate,
Danil Chapovalovcad3e0e2020-02-17 17:46:0745 DataRate::BitsPerSec(max_padding_rate_bps)));
Sebastian Jansson93b1ea22019-09-18 16:31:5246}
47
48class MockLimitObserver : public BitrateAllocator::LimitObserver {
perkj71ee44c2016-06-15 07:47:5349 public:
Danil Chapovalov9a5efe92020-05-14 20:06:1850 MOCK_METHOD(void,
51 OnAllocationLimitsChanged,
52 (BitrateAllocationLimits),
53 (override));
perkj71ee44c2016-06-15 07:47:5354};
55
mflodman86aabb22016-03-11 14:44:3256class TestBitrateObserver : public BitrateAllocatorObserver {
stefan@webrtc.org792f1a12015-03-04 12:24:2657 public:
58 TestBitrateObserver()
mflodman48a4beb2016-07-01 11:03:5959 : last_bitrate_bps_(0),
60 last_fraction_loss_(0),
61 last_rtt_ms_(0),
minyue78b4d562016-11-30 12:47:3962 last_probing_interval_ms_(0),
mflodman48a4beb2016-07-01 11:03:5963 protection_ratio_(0.0) {}
stefan@webrtc.org792f1a12015-03-04 12:24:2664
mflodman48a4beb2016-07-01 11:03:5965 void SetBitrateProtectionRatio(double protection_ratio) {
66 protection_ratio_ = protection_ratio;
67 }
68
Sebastian Janssonc0e4d452018-10-25 13:08:3269 uint32_t OnBitrateUpdated(BitrateAllocationUpdate update) override {
Sebastian Jansson13e59032018-11-21 18:13:0770 last_bitrate_bps_ = update.target_bitrate.bps();
71 last_fraction_loss_ =
72 rtc::dchecked_cast<uint8_t>(update.packet_loss_ratio * 256);
73 last_rtt_ms_ = update.round_trip_time.ms();
74 last_probing_interval_ms_ = update.bwe_period.ms();
75 return update.target_bitrate.bps() * protection_ratio_;
stefan@webrtc.org792f1a12015-03-04 12:24:2676 }
mflodman101f2502016-06-09 15:21:1977 uint32_t last_bitrate_bps_;
stefan@webrtc.org792f1a12015-03-04 12:24:2678 uint8_t last_fraction_loss_;
mflodman101f2502016-06-09 15:21:1979 int64_t last_rtt_ms_;
minyue78b4d562016-11-30 12:47:3980 int last_probing_interval_ms_;
mflodman48a4beb2016-07-01 11:03:5981 double protection_ratio_;
stefan@webrtc.org792f1a12015-03-04 12:24:2682};
83
minyue78b4d562016-11-30 12:47:3984constexpr int64_t kDefaultProbingIntervalMs = 3000;
Seth Hampson24722b32017-12-22 17:36:4285const double kDefaultBitratePriority = 1.0;
Sebastian Jansson40de3cc2019-09-19 12:54:4386
87TargetTransferRate CreateTargetRateMessage(uint32_t target_bitrate_bps,
88 uint8_t fraction_loss,
89 int64_t rtt_ms,
90 int64_t bwe_period_ms) {
91 TargetTransferRate msg;
92 // The timestamp is just for log output, keeping it fixed just means fewer log
93 // messages in the test.
Danil Chapovalov0c626af2020-02-10 10:16:0094 msg.at_time = Timestamp::Seconds(10000);
Danil Chapovalovcad3e0e2020-02-17 17:46:0795 msg.target_rate = DataRate::BitsPerSec(target_bitrate_bps);
Sebastian Jansson40de3cc2019-09-19 12:54:4396 msg.stable_target_rate = msg.target_rate;
97 msg.network_estimate.bandwidth = msg.target_rate;
98 msg.network_estimate.loss_rate_ratio = fraction_loss / 255.0;
Danil Chapovalov0c626af2020-02-10 10:16:0099 msg.network_estimate.round_trip_time = TimeDelta::Millis(rtt_ms);
100 msg.network_estimate.bwe_period = TimeDelta::Millis(bwe_period_ms);
Sebastian Jansson40de3cc2019-09-19 12:54:43101 return msg;
102}
Yves Gerey665174f2018-06-19 13:03:05103} // namespace
minyue78b4d562016-11-30 12:47:39104
stefan@webrtc.org792f1a12015-03-04 12:24:26105class BitrateAllocatorTest : public ::testing::Test {
106 protected:
Sebastian Jansson40de3cc2019-09-19 12:54:43107 BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) {
108 allocator_->OnNetworkEstimateChanged(
109 CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
Stefan Holmere5904162015-03-26 10:11:06110 }
stefan@webrtc.org792f1a12015-03-04 12:24:26111 ~BitrateAllocatorTest() {}
Sebastian Jansson24ad7202018-04-19 06:25:12112 void AddObserver(BitrateAllocatorObserver* observer,
113 uint32_t min_bitrate_bps,
114 uint32_t max_bitrate_bps,
115 uint32_t pad_up_bitrate_bps,
116 bool enforce_min_bitrate,
Sebastian Jansson24ad7202018-04-19 06:25:12117 double bitrate_priority) {
118 allocator_->AddObserver(
Jonas Olsson0182a032019-07-09 10:31:20119 observer,
120 {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
121 /* priority_bitrate */ 0, enforce_min_bitrate, bitrate_priority});
Sebastian Jansson464a5572019-02-12 12:32:32122 }
123 MediaStreamAllocationConfig DefaultConfig() const {
124 MediaStreamAllocationConfig default_config;
125 default_config.min_bitrate_bps = 0;
126 default_config.max_bitrate_bps = 1500000;
127 default_config.pad_up_bitrate_bps = 0;
128 default_config.priority_bitrate_bps = 0;
129 default_config.enforce_min_bitrate = true;
Sebastian Jansson464a5572019-02-12 12:32:32130 default_config.bitrate_priority = kDefaultBitratePriority;
131 return default_config;
Sebastian Jansson24ad7202018-04-19 06:25:12132 }
stefan@webrtc.org792f1a12015-03-04 12:24:26133
perkj71ee44c2016-06-15 07:47:53134 NiceMock<MockLimitObserver> limit_observer_;
Sebastian Jansson40de3cc2019-09-19 12:54:43135 std::unique_ptr<BitrateAllocator> allocator_;
stefan@webrtc.org792f1a12015-03-04 12:24:26136};
137
Sebastian Jansson464a5572019-02-12 12:32:32138TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
139 TestBitrateObserver stream_a;
140 auto config_a = DefaultConfig();
141 config_a.min_bitrate_bps = 100000;
142 config_a.priority_bitrate_bps = 0;
143 allocator_->AddObserver(&stream_a, config_a);
144
145 TestBitrateObserver stream_b;
146 auto config_b = DefaultConfig();
147 config_b.min_bitrate_bps = 100000;
148 config_b.max_bitrate_bps = 300000;
149 config_b.priority_bitrate_bps = 300000;
150 allocator_->AddObserver(&stream_b, config_b);
151
Sebastian Jansson40de3cc2019-09-19 12:54:43152 allocator_->OnNetworkEstimateChanged(
153 CreateTargetRateMessage(100000, 0, 0, 0));
Sebastian Jansson464a5572019-02-12 12:32:32154 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
155 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
156
Sebastian Jansson40de3cc2019-09-19 12:54:43157 allocator_->OnNetworkEstimateChanged(
158 CreateTargetRateMessage(200000, 0, 0, 0));
Sebastian Jansson464a5572019-02-12 12:32:32159 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
160 EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
161
Sebastian Jansson40de3cc2019-09-19 12:54:43162 allocator_->OnNetworkEstimateChanged(
163 CreateTargetRateMessage(300000, 0, 0, 0));
Sebastian Jansson464a5572019-02-12 12:32:32164 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
165 EXPECT_EQ(stream_b.last_bitrate_bps_, 200000u);
166
Sebastian Jansson40de3cc2019-09-19 12:54:43167 allocator_->OnNetworkEstimateChanged(
168 CreateTargetRateMessage(400000, 0, 0, 0));
Sebastian Jansson464a5572019-02-12 12:32:32169 EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
170 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
171
Sebastian Jansson40de3cc2019-09-19 12:54:43172 allocator_->OnNetworkEstimateChanged(
173 CreateTargetRateMessage(800000, 0, 0, 0));
Sebastian Jansson464a5572019-02-12 12:32:32174 EXPECT_EQ(stream_a.last_bitrate_bps_, 500000u);
175 EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
176}
177
stefan@webrtc.org792f1a12015-03-04 12:24:26178TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
179 TestBitrateObserver bitrate_observer;
perkj71ee44c2016-06-15 07:47:53180 const uint32_t kMinSendBitrateBps = 100000;
181 const uint32_t kPadUpToBitrateBps = 50000;
philipelf69e7682018-02-28 12:06:28182 const uint32_t kMaxBitrateBps = 1500000;
perkj71ee44c2016-06-15 07:47:53183
philipelf69e7682018-02-28 12:06:28184 EXPECT_CALL(limit_observer_,
Sebastian Jansson93b1ea22019-09-18 16:31:52185 OnAllocationLimitsChanged(AllocationLimitsEq(
186 kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)));
Sebastian Jansson24ad7202018-04-19 06:25:12187 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
Jonas Olsson0182a032019-07-09 10:31:20188 kPadUpToBitrateBps, true, kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16189 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
Sebastian Jansson40de3cc2019-09-19 12:54:43190 allocator_->OnNetworkEstimateChanged(
191 CreateTargetRateMessage(200000, 0, 0, kDefaultProbingIntervalMs));
perkj57c21f92016-06-17 14:27:16192 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
stefan@webrtc.org792f1a12015-03-04 12:24:26193
Peter Boström8e4e8b02015-09-15 13:08:03194 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max
mflodman0e7e2592015-11-13 05:02:42195 // bitrate for FEC/retransmissions (see todo in BitrateAllocator).
Sebastian Jansson40de3cc2019-09-19 12:54:43196 allocator_->OnNetworkEstimateChanged(
197 CreateTargetRateMessage(4000000, 0, 0, kDefaultProbingIntervalMs));
perkj57c21f92016-06-17 14:27:16198 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
perkj71ee44c2016-06-15 07:47:53199
200 // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
Sebastian Jansson93b1ea22019-09-18 16:31:52201 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
202 AllocationLimitsEq(kMinSendBitrateBps, 0)));
Jonas Olsson0182a032019-07-09 10:31:20203 AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12204 kDefaultBitratePriority);
Sebastian Jansson93b1ea22019-09-18 16:31:52205 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
206 AllocationLimitsEq(kMinSendBitrateBps, 0)));
perkj57c21f92016-06-17 14:27:16207 EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
stefan@webrtc.org792f1a12015-03-04 12:24:26208
Sebastian Jansson24ad7202018-04-19 06:25:12209 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 10:31:20210 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16211 EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
mflodman101f2502016-06-09 15:21:19212 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
Sebastian Jansson40de3cc2019-09-19 12:54:43213 allocator_->OnNetworkEstimateChanged(
214 CreateTargetRateMessage(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19215 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26216}
217
218TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
219 TestBitrateObserver bitrate_observer_1;
220 TestBitrateObserver bitrate_observer_2;
philipelf69e7682018-02-28 12:06:28221 const uint32_t kObs1StartBitrateBps = 100000;
222 const uint32_t kObs2StartBitrateBps = 200000;
223 const uint32_t kObs1MaxBitrateBps = 300000;
224 const uint32_t kObs2MaxBitrateBps = 300000;
225
Sebastian Jansson93b1ea22019-09-18 16:31:52226 EXPECT_CALL(limit_observer_,
227 OnAllocationLimitsChanged(AllocationLimitsEq(
228 kObs1StartBitrateBps, 0, kObs1MaxBitrateBps)));
Sebastian Jansson24ad7202018-04-19 06:25:12229 AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0,
Jonas Olsson0182a032019-07-09 10:31:20230 true, kDefaultBitratePriority);
philipelf69e7682018-02-28 12:06:28231 EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
232 allocator_->GetStartBitrate(&bitrate_observer_1));
Sebastian Jansson93b1ea22019-09-18 16:31:52233 EXPECT_CALL(limit_observer_,
234 OnAllocationLimitsChanged(AllocationLimitsEq(
235 kObs1StartBitrateBps + kObs2StartBitrateBps, 0,
236 kObs1MaxBitrateBps + kObs2MaxBitrateBps)));
Sebastian Jansson24ad7202018-04-19 06:25:12237 AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0,
Jonas Olsson0182a032019-07-09 10:31:20238 true, kDefaultBitratePriority);
philipelf69e7682018-02-28 12:06:28239 EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
240 allocator_->GetStartBitrate(&bitrate_observer_2));
stefan@webrtc.org792f1a12015-03-04 12:24:26241
mflodman48a4beb2016-07-01 11:03:59242 // Test too low start bitrate, hence lower than sum of min. Min bitrates
243 // will
244 // be allocated to all observers.
Sebastian Jansson40de3cc2019-09-19 12:54:43245 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
246 kObs2StartBitrateBps, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59247 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
248 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
249 EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
250 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
251 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_);
252 EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_);
stefan@webrtc.org792f1a12015-03-04 12:24:26253
mflodman48a4beb2016-07-01 11:03:59254 // Test a bitrate which should be distributed equally.
Sebastian Jansson40de3cc2019-09-19 12:54:43255 allocator_->OnNetworkEstimateChanged(
256 CreateTargetRateMessage(500000, 0, 50, kDefaultProbingIntervalMs));
philipelf69e7682018-02-28 12:06:28257 const uint32_t kBitrateToShare =
258 500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
mflodman48a4beb2016-07-01 11:03:59259 EXPECT_EQ(100000u + kBitrateToShare / 2,
260 bitrate_observer_1.last_bitrate_bps_);
261 EXPECT_EQ(200000u + kBitrateToShare / 2,
262 bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26263
mflodman48a4beb2016-07-01 11:03:59264 // Limited by 2x max bitrates since we leave room for FEC and
265 // retransmissions.
Sebastian Jansson40de3cc2019-09-19 12:54:43266 allocator_->OnNetworkEstimateChanged(
267 CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59268 EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_);
269 EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_);
perkjec81bcd2016-05-11 13:01:13270
mflodman48a4beb2016-07-01 11:03:59271 // Verify that if the bandwidth estimate is set to zero, the allocated
272 // rate is
273 // zero.
Sebastian Jansson40de3cc2019-09-19 12:54:43274 allocator_->OnNetworkEstimateChanged(
275 CreateTargetRateMessage(0, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59276 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
277 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26278}
279
perkj71ee44c2016-06-15 07:47:53280TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
281 TestBitrateObserver bitrate_observer;
282 const uint32_t kMinSendBitrateBps = 100000;
283 const uint32_t kPadUpToBitrateBps = 50000;
philipelf69e7682018-02-28 12:06:28284 const uint32_t kMaxBitrateBps = 1500000;
perkj71ee44c2016-06-15 07:47:53285
philipelf69e7682018-02-28 12:06:28286 EXPECT_CALL(limit_observer_,
Sebastian Jansson93b1ea22019-09-18 16:31:52287 OnAllocationLimitsChanged(AllocationLimitsEq(
288 kMinSendBitrateBps, kPadUpToBitrateBps, kMaxBitrateBps)));
Sebastian Jansson24ad7202018-04-19 06:25:12289 AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
Jonas Olsson0182a032019-07-09 10:31:20290 kPadUpToBitrateBps, true, kDefaultBitratePriority);
Sebastian Jansson93b1ea22019-09-18 16:31:52291 EXPECT_CALL(limit_observer_,
292 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
perkj71ee44c2016-06-15 07:47:53293 allocator_->RemoveObserver(&bitrate_observer);
294}
295
stefan@webrtc.org792f1a12015-03-04 12:24:26296class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
297 protected:
perkj71ee44c2016-06-15 07:47:53298 BitrateAllocatorTestNoEnforceMin()
Sebastian Jansson40de3cc2019-09-19 12:54:43299 : allocator_(new BitrateAllocator(&limit_observer_)) {
300 allocator_->OnNetworkEstimateChanged(
301 CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
stefan@webrtc.org792f1a12015-03-04 12:24:26302 }
303 ~BitrateAllocatorTestNoEnforceMin() {}
Sebastian Jansson24ad7202018-04-19 06:25:12304 void AddObserver(BitrateAllocatorObserver* observer,
305 uint32_t min_bitrate_bps,
306 uint32_t max_bitrate_bps,
307 uint32_t pad_up_bitrate_bps,
308 bool enforce_min_bitrate,
309 std::string track_id,
310 double bitrate_priority) {
311 allocator_->AddObserver(
Sebastian Jansson464a5572019-02-12 12:32:32312 observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps, 0,
Jonas Olsson0182a032019-07-09 10:31:20313 enforce_min_bitrate, bitrate_priority});
Sebastian Jansson24ad7202018-04-19 06:25:12314 }
perkj71ee44c2016-06-15 07:47:53315 NiceMock<MockLimitObserver> limit_observer_;
Sebastian Jansson40de3cc2019-09-19 12:54:43316 std::unique_ptr<BitrateAllocator> allocator_;
stefan@webrtc.org792f1a12015-03-04 12:24:26317};
318
mflodman101f2502016-06-09 15:21:19319// The following three tests verify enforcing a minimum bitrate works as
320// intended.
stefan@webrtc.org792f1a12015-03-04 12:24:26321TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
322 TestBitrateObserver bitrate_observer_1;
perkj71ee44c2016-06-15 07:47:53323 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
324 // AddObserver is called with |enforce_min_bitrate| = false.
Sebastian Jansson93b1ea22019-09-18 16:31:52325 EXPECT_CALL(limit_observer_,
326 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
327 EXPECT_CALL(limit_observer_,
328 OnAllocationLimitsChanged(AllocationLimitsEq(0, 120000)));
Sebastian Jansson24ad7202018-04-19 06:25:12329 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
330 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59331 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
stefan@webrtc.org792f1a12015-03-04 12:24:26332
mflodman48a4beb2016-07-01 11:03:59333 // High BWE.
Sebastian Jansson40de3cc2019-09-19 12:54:43334 allocator_->OnNetworkEstimateChanged(
335 CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59336 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26337
mflodman48a4beb2016-07-01 11:03:59338 // Low BWE.
Sebastian Jansson40de3cc2019-09-19 12:54:43339 allocator_->OnNetworkEstimateChanged(
340 CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59341 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26342
Sebastian Jansson93b1ea22019-09-18 16:31:52343 EXPECT_CALL(limit_observer_,
344 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0)));
mflodman48a4beb2016-07-01 11:03:59345 allocator_->RemoveObserver(&bitrate_observer_1);
stefan@webrtc.org792f1a12015-03-04 12:24:26346}
347
348TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
349 TestBitrateObserver bitrate_observer_1;
350 TestBitrateObserver bitrate_observer_2;
351 TestBitrateObserver bitrate_observer_3;
352 // Set up the observers with min bitrates at 100000, 200000, and 300000.
Sebastian Jansson24ad7202018-04-19 06:25:12353 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
354 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16355 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
Stefan Holmere5904162015-03-26 10:11:06356
Sebastian Jansson24ad7202018-04-19 06:25:12357 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
358 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16359 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 15:21:19360 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
Stefan Holmere5904162015-03-26 10:11:06361
Sebastian Jansson24ad7202018-04-19 06:25:12362 AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
363 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16364 EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
mflodman101f2502016-06-09 15:21:19365 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
366 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26367
mflodman101f2502016-06-09 15:21:19368 // High BWE. Make sure the controllers get a fair share of the surplus (i.e.,
369 // what is left after each controller gets its min rate).
Sebastian Jansson40de3cc2019-09-19 12:54:43370 allocator_->OnNetworkEstimateChanged(
371 CreateTargetRateMessage(690000, 0, 0, kDefaultProbingIntervalMs));
stefan@webrtc.org792f1a12015-03-04 12:24:26372 // Verify that each observer gets its min rate (sum of min rates is 600000),
373 // and that the remaining 90000 is divided equally among the three.
Stefan Holmere5904162015-03-26 10:11:06374 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
mflodman101f2502016-06-09 15:21:19375 EXPECT_EQ(100000u + bitrate_to_share / 3,
376 bitrate_observer_1.last_bitrate_bps_);
377 EXPECT_EQ(200000u + bitrate_to_share / 3,
378 bitrate_observer_2.last_bitrate_bps_);
379 EXPECT_EQ(300000u + bitrate_to_share / 3,
380 bitrate_observer_3.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26381
mflodman101f2502016-06-09 15:21:19382 // BWE below the sum of observer's min bitrate.
Sebastian Jansson40de3cc2019-09-19 12:54:43383 allocator_->OnNetworkEstimateChanged(
384 CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19385 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate.
386 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate.
Yves Gerey665174f2018-06-19 13:03:05387 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
mflodman101f2502016-06-09 15:21:19388
389 // Increased BWE, but still below the sum of configured min bitrates for all
390 // observers and too little for observer 3. 1 and 2 will share the rest.
Sebastian Jansson40de3cc2019-09-19 12:54:43391 allocator_->OnNetworkEstimateChanged(
392 CreateTargetRateMessage(500000, 0, 0, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19393 EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split.
394 EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split.
Yves Gerey665174f2018-06-19 13:03:05395 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
stefan@webrtc.org792f1a12015-03-04 12:24:26396
mflodman101f2502016-06-09 15:21:19397 // Below min for all.
Sebastian Jansson40de3cc2019-09-19 12:54:43398 allocator_->OnNetworkEstimateChanged(
399 CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19400 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
401 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
402 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
stefan@webrtc.org792f1a12015-03-04 12:24:26403
perkjec81bcd2016-05-11 13:01:13404 // Verify that zero estimated bandwidth, means that that all gets zero,
405 // regardless of set min bitrate.
Sebastian Jansson40de3cc2019-09-19 12:54:43406 allocator_->OnNetworkEstimateChanged(
407 CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19408 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
409 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
410 EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
perkjec81bcd2016-05-11 13:01:13411
mflodman86aabb22016-03-11 14:44:32412 allocator_->RemoveObserver(&bitrate_observer_1);
413 allocator_->RemoveObserver(&bitrate_observer_2);
414 allocator_->RemoveObserver(&bitrate_observer_3);
stefan@webrtc.org792f1a12015-03-04 12:24:26415}
416
mflodman48a4beb2016-07-01 11:03:59417TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
Erik Språngd1d7b232018-12-06 16:31:25418 const uint32_t kMinBitrateBps = 100000;
419 const uint32_t kMaxBitrateBps = 400000;
420 // Hysteresis adds another 10% or 20kbps to min bitrate.
421 const uint32_t kMinStartBitrateBps =
422 kMinBitrateBps + std::max(20000u, kMinBitrateBps / 10);
423
mflodman48a4beb2016-07-01 11:03:59424 // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
425 // AddObserver is called with |enforce_min_bitrate| = false.
Erik Språngd1d7b232018-12-06 16:31:25426 TestBitrateObserver bitrate_observer;
Sebastian Jansson93b1ea22019-09-18 16:31:52427 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
428 AllocationLimitsEq(0, 0, kMaxBitrateBps)));
Erik Språngd1d7b232018-12-06 16:31:25429 AddObserver(&bitrate_observer, kMinBitrateBps, kMaxBitrateBps, 0, false, "",
Sebastian Jansson24ad7202018-04-19 06:25:12430 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59431 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
432
433 // High BWE.
Sebastian Jansson40de3cc2019-09-19 12:54:43434 allocator_->OnNetworkEstimateChanged(
435 CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59436 EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
437
438 // Add loss and use a part of the bitrate for protection.
Erik Språngd1d7b232018-12-06 16:31:25439 const double kProtectionRatio = 0.4;
Rasmus Brandt681de202019-02-04 14:09:34440 const uint8_t fraction_loss = kProtectionRatio * 256;
Erik Språngd1d7b232018-12-06 16:31:25441 bitrate_observer.SetBitrateProtectionRatio(kProtectionRatio);
Sebastian Jansson40de3cc2019-09-19 12:54:43442 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
443 200000, 0, fraction_loss, kDefaultProbingIntervalMs));
Rasmus Brandt681de202019-02-04 14:09:34444 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 11:03:59445
446 // Above the min threshold, but not enough given the protection used.
Erik Språngd1d7b232018-12-06 16:31:25447 // Limits changed, as we will video is now off and we need to pad up to the
448 // start bitrate.
Erik Språngd1d7b232018-12-06 16:31:25449 // Verify the hysteresis is added for the protection.
450 const uint32_t kMinStartBitrateWithProtectionBps =
451 static_cast<uint32_t>(kMinStartBitrateBps * (1 + kProtectionRatio));
452 EXPECT_CALL(limit_observer_,
Sebastian Jansson93b1ea22019-09-18 16:31:52453 OnAllocationLimitsChanged(AllocationLimitsEq(
454 0, kMinStartBitrateWithProtectionBps, kMaxBitrateBps)));
Sebastian Jansson40de3cc2019-09-19 12:54:43455 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
456 kMinStartBitrateBps + 1000, 0, fraction_loss, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59457 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
458
Sebastian Jansson40de3cc2019-09-19 12:54:43459 allocator_->OnNetworkEstimateChanged(
460 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0,
461 fraction_loss, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59462 EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
463
464 // Just enough to enable video again.
Sebastian Jansson93b1ea22019-09-18 16:31:52465 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
466 AllocationLimitsEq(0, 0, kMaxBitrateBps)));
Sebastian Jansson40de3cc2019-09-19 12:54:43467 allocator_->OnNetworkEstimateChanged(
468 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps, 0,
469 fraction_loss, kDefaultProbingIntervalMs));
Erik Språngd1d7b232018-12-06 16:31:25470 EXPECT_EQ(kMinStartBitrateWithProtectionBps,
471 bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 11:03:59472
473 // Remove all protection and make sure video is not paused as earlier.
474 bitrate_observer.SetBitrateProtectionRatio(0.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43475 allocator_->OnNetworkEstimateChanged(
476 CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0, 0,
477 kDefaultProbingIntervalMs));
Erik Språngd1d7b232018-12-06 16:31:25478 EXPECT_EQ(kMinStartBitrateWithProtectionBps - 1000,
479 bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 11:03:59480
Sebastian Jansson40de3cc2019-09-19 12:54:43481 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
482 kMinStartBitrateBps, 0, 0, kDefaultProbingIntervalMs));
Erik Språngd1d7b232018-12-06 16:31:25483 EXPECT_EQ(kMinStartBitrateBps, bitrate_observer.last_bitrate_bps_);
mflodman48a4beb2016-07-01 11:03:59484
Sebastian Jansson93b1ea22019-09-18 16:31:52485 EXPECT_CALL(limit_observer_,
486 OnAllocationLimitsChanged(AllocationLimitsEq(0, 0, 0)));
mflodman48a4beb2016-07-01 11:03:59487 allocator_->RemoveObserver(&bitrate_observer);
488}
489
Rasmus Brandt681de202019-02-04 14:09:34490TEST_F(BitrateAllocatorTest,
491 TotalAllocationLimitsAreUnaffectedByProtectionRatio) {
492 TestBitrateObserver bitrate_observer;
493
494 const uint32_t kMinBitrateBps = 100000;
495 const uint32_t kMaxBitrateBps = 400000;
496
497 // Register |bitrate_observer| and expect total allocation limits to change.
Sebastian Jansson93b1ea22019-09-18 16:31:52498 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(AllocationLimitsEq(
499 kMinBitrateBps, 0, kMaxBitrateBps)))
Rasmus Brandt681de202019-02-04 14:09:34500 .Times(1);
Sebastian Jansson464a5572019-02-12 12:32:32501 MediaStreamAllocationConfig allocation_config = DefaultConfig();
502 allocation_config.min_bitrate_bps = kMinBitrateBps;
503 allocation_config.max_bitrate_bps = kMaxBitrateBps;
504 allocator_->AddObserver(&bitrate_observer, allocation_config);
Rasmus Brandt681de202019-02-04 14:09:34505
506 // Observer uses 20% of it's allocated bitrate for protection.
507 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
508 // Total allocation limits are unaffected by the protection rate change.
Sebastian Jansson93b1ea22019-09-18 16:31:52509 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
Sebastian Jansson40de3cc2019-09-19 12:54:43510 allocator_->OnNetworkEstimateChanged(
511 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
Rasmus Brandt681de202019-02-04 14:09:34512
513 // Observer uses 0% of it's allocated bitrate for protection.
514 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.0);
515 // Total allocation limits are unaffected by the protection rate change.
Sebastian Jansson93b1ea22019-09-18 16:31:52516 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
Sebastian Jansson40de3cc2019-09-19 12:54:43517 allocator_->OnNetworkEstimateChanged(
518 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
Rasmus Brandt681de202019-02-04 14:09:34519
520 // Observer again uses 20% of it's allocated bitrate for protection.
521 bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
522 // Total allocation limits are unaffected by the protection rate change.
Sebastian Jansson93b1ea22019-09-18 16:31:52523 EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
Sebastian Jansson40de3cc2019-09-19 12:54:43524 allocator_->OnNetworkEstimateChanged(
525 CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
Rasmus Brandt681de202019-02-04 14:09:34526}
527
mflodman48a4beb2016-07-01 11:03:59528TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
529 TestBitrateObserver bitrate_observer_1;
530 TestBitrateObserver bitrate_observer_2;
531
Sebastian Jansson24ad7202018-04-19 06:25:12532 AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
533 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59534 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
Sebastian Jansson24ad7202018-04-19 06:25:12535 AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
536 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59537 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
538 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
539
540 // Enough bitrate for both.
541 bitrate_observer_2.SetBitrateProtectionRatio(0.5);
Sebastian Jansson40de3cc2019-09-19 12:54:43542 allocator_->OnNetworkEstimateChanged(
543 CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59544 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
545 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
546
547 // Above min for observer 2, but too little given the protection used.
Sebastian Jansson40de3cc2019-09-19 12:54:43548 allocator_->OnNetworkEstimateChanged(
549 CreateTargetRateMessage(330000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59550 EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);
551 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
552
Sebastian Jansson40de3cc2019-09-19 12:54:43553 allocator_->OnNetworkEstimateChanged(
554 CreateTargetRateMessage(100000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59555 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
556 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
557
Sebastian Jansson40de3cc2019-09-19 12:54:43558 allocator_->OnNetworkEstimateChanged(
559 CreateTargetRateMessage(99999, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59560 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
561 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
562
Sebastian Jansson40de3cc2019-09-19 12:54:43563 allocator_->OnNetworkEstimateChanged(
564 CreateTargetRateMessage(119000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59565 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
566 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
567
Sebastian Jansson40de3cc2019-09-19 12:54:43568 allocator_->OnNetworkEstimateChanged(
569 CreateTargetRateMessage(120000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59570 EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_);
571 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
572
573 // Verify the protection is accounted for before resuming observer 2.
Sebastian Jansson40de3cc2019-09-19 12:54:43574 allocator_->OnNetworkEstimateChanged(
575 CreateTargetRateMessage(429000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59576 EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);
577 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
578
Sebastian Jansson40de3cc2019-09-19 12:54:43579 allocator_->OnNetworkEstimateChanged(
580 CreateTargetRateMessage(430000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59581 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
582 EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);
583
584 allocator_->RemoveObserver(&bitrate_observer_1);
585 allocator_->RemoveObserver(&bitrate_observer_2);
586}
587
mflodman101f2502016-06-09 15:21:19588TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
stefan@webrtc.org792f1a12015-03-04 12:24:26589 TestBitrateObserver bitrate_observer_1;
590 TestBitrateObserver bitrate_observer_2;
591 TestBitrateObserver bitrate_observer_3;
Stefan Holmere5904162015-03-26 10:11:06592
Jonas Olsson0182a032019-07-09 10:31:20593 AddObserver(&bitrate_observer_1, 100000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12594 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16595 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
596
Jonas Olsson0182a032019-07-09 10:31:20597 AddObserver(&bitrate_observer_2, 200000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12598 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16599 EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 15:21:19600 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
Stefan Holmere5904162015-03-26 10:11:06601
Jonas Olsson0182a032019-07-09 10:31:20602 AddObserver(&bitrate_observer_3, 300000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12603 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59604 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
605 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
606 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
stefan@webrtc.org792f1a12015-03-04 12:24:26607
mflodman48a4beb2016-07-01 11:03:59608 // Low BWE. Verify that all observers still get their respective min
609 // bitrate.
Sebastian Jansson40de3cc2019-09-19 12:54:43610 allocator_->OnNetworkEstimateChanged(
611 CreateTargetRateMessage(1000, 0, 0, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59612 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap.
613 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap.
614 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap.
stefan@webrtc.org792f1a12015-03-04 12:24:26615
mflodman48a4beb2016-07-01 11:03:59616 allocator_->RemoveObserver(&bitrate_observer_1);
617 allocator_->RemoveObserver(&bitrate_observer_2);
618 allocator_->RemoveObserver(&bitrate_observer_3);
stefan@webrtc.org792f1a12015-03-04 12:24:26619}
perkjfea93092016-05-14 07:58:48620
621TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
622 TestBitrateObserver bitrate_observer_1;
Sebastian Jansson93b1ea22019-09-18 16:31:52623 EXPECT_CALL(limit_observer_,
624 OnAllocationLimitsChanged(AllocationLimitsEq(50000, 0)));
perkj57c21f92016-06-17 14:27:16625
Jonas Olsson0182a032019-07-09 10:31:20626 AddObserver(&bitrate_observer_1, 50000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12627 kDefaultBitratePriority);
perkj57c21f92016-06-17 14:27:16628 EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
perkjfea93092016-05-14 07:58:48629
630 // Set network down, ie, no available bitrate.
Sebastian Jansson40de3cc2019-09-19 12:54:43631 allocator_->OnNetworkEstimateChanged(
632 CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
perkjfea93092016-05-14 07:58:48633
mflodman101f2502016-06-09 15:21:19634 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
perkjfea93092016-05-14 07:58:48635
636 TestBitrateObserver bitrate_observer_2;
perkj71ee44c2016-06-15 07:47:53637 // Adding an observer while the network is down should not affect the limits.
Sebastian Jansson93b1ea22019-09-18 16:31:52638 EXPECT_CALL(limit_observer_,
639 OnAllocationLimitsChanged(AllocationLimitsEq(50000 + 50000, 0)));
Jonas Olsson0182a032019-07-09 10:31:20640 AddObserver(&bitrate_observer_2, 50000, 400000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12641 kDefaultBitratePriority);
perkjfea93092016-05-14 07:58:48642
643 // Expect the start_bitrate to be set as if the network was still up but that
644 // the new observer have been notified that the network is down.
perkj57c21f92016-06-17 14:27:16645 EXPECT_EQ(300000 / 2, allocator_->GetStartBitrate(&bitrate_observer_2));
mflodman101f2502016-06-09 15:21:19646 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
647 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
perkjfea93092016-05-14 07:58:48648
649 // Set network back up.
Sebastian Jansson40de3cc2019-09-19 12:54:43650 allocator_->OnNetworkEstimateChanged(
651 CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
mflodman101f2502016-06-09 15:21:19652 EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);
653 EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);
654}
655
656TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
657 TestBitrateObserver enforced_observer;
Jonas Olsson0182a032019-07-09 10:31:20658 AddObserver(&enforced_observer, 6000, 30000, 0, true,
Sebastian Jansson24ad7202018-04-19 06:25:12659 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59660 EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
mflodman101f2502016-06-09 15:21:19661
mflodman48a4beb2016-07-01 11:03:59662 TestBitrateObserver not_enforced_observer;
Jonas Olsson0182a032019-07-09 10:31:20663 AddObserver(&not_enforced_observer, 30000, 2500000, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12664 kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59665 EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
666 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19667
Sebastian Jansson40de3cc2019-09-19 12:54:43668 allocator_->OnNetworkEstimateChanged(
669 CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59670 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
671 EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19672
Sebastian Jansson40de3cc2019-09-19 12:54:43673 allocator_->OnNetworkEstimateChanged(
674 CreateTargetRateMessage(35000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59675 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
676 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19677
Sebastian Jansson40de3cc2019-09-19 12:54:43678 allocator_->OnNetworkEstimateChanged(
679 CreateTargetRateMessage(5000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59680 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
681 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19682
Sebastian Jansson40de3cc2019-09-19 12:54:43683 allocator_->OnNetworkEstimateChanged(
684 CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59685 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
686 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19687
Sebastian Jansson40de3cc2019-09-19 12:54:43688 allocator_->OnNetworkEstimateChanged(
689 CreateTargetRateMessage(55000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59690 EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
691 EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19692
Sebastian Jansson40de3cc2019-09-19 12:54:43693 allocator_->OnNetworkEstimateChanged(
694 CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59695 EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
696 EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19697
Sebastian Jansson40de3cc2019-09-19 12:54:43698 allocator_->OnNetworkEstimateChanged(
699 CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59700 EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);
701 EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19702
mflodman48a4beb2016-07-01 11:03:59703 allocator_->RemoveObserver(&enforced_observer);
704 allocator_->RemoveObserver(&not_enforced_observer);
mflodman101f2502016-06-09 15:21:19705}
706
707TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
708 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 10:31:20709 AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59710 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
mflodman101f2502016-06-09 15:21:19711
Sebastian Jansson40de3cc2019-09-19 12:54:43712 allocator_->OnNetworkEstimateChanged(
713 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59714 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19715
Sebastian Jansson40de3cc2019-09-19 12:54:43716 allocator_->OnNetworkEstimateChanged(
717 CreateTargetRateMessage(20000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59718 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19719
Sebastian Jansson40de3cc2019-09-19 12:54:43720 allocator_->OnNetworkEstimateChanged(
721 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59722 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19723
Sebastian Jansson40de3cc2019-09-19 12:54:43724 allocator_->OnNetworkEstimateChanged(
725 CreateTargetRateMessage(49000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59726 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19727
Sebastian Jansson40de3cc2019-09-19 12:54:43728 allocator_->OnNetworkEstimateChanged(
729 CreateTargetRateMessage(50000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59730 EXPECT_EQ(50000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19731
Sebastian Jansson40de3cc2019-09-19 12:54:43732 allocator_->OnNetworkEstimateChanged(
733 CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59734 EXPECT_EQ(30000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19735
mflodman48a4beb2016-07-01 11:03:59736 allocator_->RemoveObserver(&observer);
mflodman101f2502016-06-09 15:21:19737}
738
739TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
740 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 10:31:20741 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
mflodman48a4beb2016-07-01 11:03:59742 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
mflodman101f2502016-06-09 15:21:19743
Sebastian Jansson40de3cc2019-09-19 12:54:43744 allocator_->OnNetworkEstimateChanged(
745 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59746 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19747
Sebastian Jansson40de3cc2019-09-19 12:54:43748 allocator_->OnNetworkEstimateChanged(
749 CreateTargetRateMessage(200000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59750 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19751
Sebastian Jansson40de3cc2019-09-19 12:54:43752 allocator_->OnNetworkEstimateChanged(
753 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59754 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19755
Sebastian Jansson40de3cc2019-09-19 12:54:43756 allocator_->OnNetworkEstimateChanged(
757 CreateTargetRateMessage(329000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59758 EXPECT_EQ(0u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19759
Sebastian Jansson40de3cc2019-09-19 12:54:43760 allocator_->OnNetworkEstimateChanged(
761 CreateTargetRateMessage(330000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59762 EXPECT_EQ(330000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19763
Sebastian Jansson40de3cc2019-09-19 12:54:43764 allocator_->OnNetworkEstimateChanged(
765 CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
mflodman48a4beb2016-07-01 11:03:59766 EXPECT_EQ(300000u, observer.last_bitrate_bps_);
mflodman101f2502016-06-09 15:21:19767
mflodman48a4beb2016-07-01 11:03:59768 allocator_->RemoveObserver(&observer);
perkjfea93092016-05-14 07:58:48769}
770
minyue78b4d562016-11-30 12:47:39771TEST_F(BitrateAllocatorTest, PassProbingInterval) {
772 TestBitrateObserver observer;
Jonas Olsson0182a032019-07-09 10:31:20773 AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
minyue78b4d562016-11-30 12:47:39774 EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
775
Sebastian Jansson40de3cc2019-09-19 12:54:43776 allocator_->OnNetworkEstimateChanged(
777 CreateTargetRateMessage(300000, 0, 50, 5000));
minyue78b4d562016-11-30 12:47:39778 EXPECT_EQ(5000, observer.last_probing_interval_ms_);
779
780 allocator_->RemoveObserver(&observer);
781}
782
Seth Hampsonfe73d6a2017-11-14 18:49:06783TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
784 TestBitrateObserver observer;
785 const uint32_t kMinSendBitrateBps = 10;
786 const uint32_t kMaxSendBitrateBps = 60;
787 const uint32_t kNetworkBandwidthBps = 30;
788
Jonas Olsson0182a032019-07-09 10:31:20789 AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43790 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
791 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06792
793 EXPECT_EQ(kNetworkBandwidthBps, observer.last_bitrate_bps_);
794
795 allocator_->RemoveObserver(&observer);
796}
797
798// Tests that two observers with the same bitrate priority are allocated
799// their bitrate evenly.
800TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
801 TestBitrateObserver observer_low_1;
802 TestBitrateObserver observer_low_2;
803 const uint32_t kMinSendBitrateBps = 10;
804 const uint32_t kMaxSendBitrateBps = 60;
805 const uint32_t kNetworkBandwidthBps = 60;
Sebastian Jansson24ad7202018-04-19 06:25:12806 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
Jonas Olsson0182a032019-07-09 10:31:20807 2.0);
Sebastian Jansson24ad7202018-04-19 06:25:12808 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
Jonas Olsson0182a032019-07-09 10:31:20809 2.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43810 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
811 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06812
813 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
814 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
815
816 allocator_->RemoveObserver(&observer_low_1);
817 allocator_->RemoveObserver(&observer_low_2);
818}
819
820// Tests that there is no difference in functionality when the min bitrate is
821// enforced.
822TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
823 TestBitrateObserver observer_low_1;
824 TestBitrateObserver observer_low_2;
825 const uint32_t kMinSendBitrateBps = 0;
826 const uint32_t kMaxSendBitrateBps = 60;
827 const uint32_t kNetworkBandwidthBps = 60;
Sebastian Jansson24ad7202018-04-19 06:25:12828 AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 10:31:20829 2.0);
Sebastian Jansson24ad7202018-04-19 06:25:12830 AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 10:31:20831 2.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43832 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
833 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06834
835 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
836 EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
837
838 allocator_->RemoveObserver(&observer_low_1);
839 allocator_->RemoveObserver(&observer_low_2);
840}
841
842// Tests that if the available bandwidth is the sum of the max bitrate
843// of all observers, they will be allocated their max.
844TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
845 TestBitrateObserver observer_low;
846 TestBitrateObserver observer_mid;
847 const uint32_t kMinSendBitrateBps = 0;
848 const uint32_t kMaxSendBitrateBps = 60;
849 const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2;
Sebastian Jansson24ad7202018-04-19 06:25:12850 AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 10:31:20851 2.0);
Sebastian Jansson24ad7202018-04-19 06:25:12852 AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
Jonas Olsson0182a032019-07-09 10:31:20853 4.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43854 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
855 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06856
857 EXPECT_EQ(kMaxSendBitrateBps, observer_low.last_bitrate_bps_);
858 EXPECT_EQ(kMaxSendBitrateBps, observer_mid.last_bitrate_bps_);
859
860 allocator_->RemoveObserver(&observer_low);
861 allocator_->RemoveObserver(&observer_mid);
862}
863
864// Tests that after a higher bitrate priority observer has been allocated its
865// max bitrate the lower priority observer will then be allocated the remaining
866// bitrate.
867TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
868 TestBitrateObserver observer_low;
869 TestBitrateObserver observer_mid;
Jonas Olsson0182a032019-07-09 10:31:20870 AddObserver(&observer_low, 10, 50, 0, false, 2.0);
871 AddObserver(&observer_mid, 10, 50, 0, false, 4.0);
Sebastian Jansson40de3cc2019-09-19 12:54:43872 allocator_->OnNetworkEstimateChanged(
873 CreateTargetRateMessage(90, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06874
875 EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
876 EXPECT_EQ(50u, observer_mid.last_bitrate_bps_);
877
878 allocator_->RemoveObserver(&observer_low);
879 allocator_->RemoveObserver(&observer_mid);
880}
881
882// Tests that three observers with three different bitrate priorities will all
883// be allocated bitrate according to their relative bitrate priority.
884TEST_F(BitrateAllocatorTest,
885 PriorityRateThreeObserversAllocatedRelativeAmounts) {
886 TestBitrateObserver observer_low;
887 TestBitrateObserver observer_mid;
888 TestBitrateObserver observer_high;
889 const uint32_t kMaxBitrate = 100;
890 // Not enough bandwidth to fill any observer's max bitrate.
891 const uint32_t kNetworkBandwidthBps = 70;
892 const double kLowBitratePriority = 2.0;
893 const double kMidBitratePriority = 4.0;
894 const double kHighBitratePriority = 8.0;
895 const double kTotalBitratePriority =
896 kLowBitratePriority + kMidBitratePriority + kHighBitratePriority;
Jonas Olsson0182a032019-07-09 10:31:20897 AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority);
898 AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority);
899 AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority);
Sebastian Jansson40de3cc2019-09-19 12:54:43900 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
901 kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06902
903 const double kLowFractionAllocated =
904 kLowBitratePriority / kTotalBitratePriority;
905 const double kMidFractionAllocated =
906 kMidBitratePriority / kTotalBitratePriority;
907 const double kHighFractionAllocated =
908 kHighBitratePriority / kTotalBitratePriority;
909 EXPECT_EQ(kLowFractionAllocated * kNetworkBandwidthBps,
910 observer_low.last_bitrate_bps_);
911 EXPECT_EQ(kMidFractionAllocated * kNetworkBandwidthBps,
912 observer_mid.last_bitrate_bps_);
913 EXPECT_EQ(kHighFractionAllocated * kNetworkBandwidthBps,
914 observer_high.last_bitrate_bps_);
915
916 allocator_->RemoveObserver(&observer_low);
917 allocator_->RemoveObserver(&observer_mid);
918 allocator_->RemoveObserver(&observer_high);
919}
920
921// Tests that after the high priority observer has been allocated its maximum
922// bitrate, the other two observers are still allocated bitrate according to
923// their relative bitrate priority.
924TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
925 TestBitrateObserver observer_low;
926 const double kLowBitratePriority = 2.0;
927 TestBitrateObserver observer_mid;
928 const double kMidBitratePriority = 4.0;
929 TestBitrateObserver observer_high;
930 const double kHighBitratePriority = 8.0;
931
932 const uint32_t kAvailableBitrate = 90;
933 const uint32_t kMaxBitrate = 40;
934 const uint32_t kMinBitrate = 10;
935 // Remaining bitrate after allocating to all mins and knowing that the high
936 // priority observer will have its max bitrate allocated.
937 const uint32_t kRemainingBitrate =
938 kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate);
939
Jonas Olsson0182a032019-07-09 10:31:20940 AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12941 kLowBitratePriority);
Jonas Olsson0182a032019-07-09 10:31:20942 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12943 kMidBitratePriority);
Jonas Olsson0182a032019-07-09 10:31:20944 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12945 kHighBitratePriority);
Sebastian Jansson40de3cc2019-09-19 12:54:43946 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
947 kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06948
949 const double kLowFractionAllocated =
950 kLowBitratePriority / (kLowBitratePriority + kMidBitratePriority);
951 const double kMidFractionAllocated =
952 kMidBitratePriority / (kLowBitratePriority + kMidBitratePriority);
953 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kLowFractionAllocated),
954 observer_low.last_bitrate_bps_);
955 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
956 observer_mid.last_bitrate_bps_);
957 EXPECT_EQ(40u, observer_high.last_bitrate_bps_);
958
959 allocator_->RemoveObserver(&observer_low);
960 allocator_->RemoveObserver(&observer_mid);
961 allocator_->RemoveObserver(&observer_high);
962}
963
964// Tests that after the low priority observer has been allocated its maximum
965// bitrate, the other two observers are still allocated bitrate according to
966// their relative bitrate priority.
967TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
968 TestBitrateObserver observer_low;
969 const double kLowBitratePriority = 2.0;
970 const uint32_t kLowMaxBitrate = 10;
971 TestBitrateObserver observer_mid;
972 const double kMidBitratePriority = 4.0;
973 TestBitrateObserver observer_high;
974 const double kHighBitratePriority = 8.0;
975
976 const uint32_t kMinBitrate = 0;
977 const uint32_t kMaxBitrate = 60;
978 const uint32_t kAvailableBitrate = 100;
979 // Remaining bitrate knowing that the low priority observer is allocated its
980 // max bitrate. We know this because it is allocated 2.0/14.0 (1/7) of the
981 // available bitrate, so 70 bps would be sufficient network bandwidth.
982 const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate;
983
Jonas Olsson0182a032019-07-09 10:31:20984 AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12985 kLowBitratePriority);
Jonas Olsson0182a032019-07-09 10:31:20986 AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12987 kMidBitratePriority);
Jonas Olsson0182a032019-07-09 10:31:20988 AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
Sebastian Jansson24ad7202018-04-19 06:25:12989 kHighBitratePriority);
Sebastian Jansson40de3cc2019-09-19 12:54:43990 allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
991 kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:06992
993 const double kMidFractionAllocated =
994 kMidBitratePriority / (kMidBitratePriority + kHighBitratePriority);
995 const double kHighFractionAllocated =
996 kHighBitratePriority / (kMidBitratePriority + kHighBitratePriority);
997 EXPECT_EQ(kLowMaxBitrate, observer_low.last_bitrate_bps_);
998 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kMidFractionAllocated),
999 observer_mid.last_bitrate_bps_);
1000 EXPECT_EQ(kMinBitrate + (kRemainingBitrate * kHighFractionAllocated),
1001 observer_high.last_bitrate_bps_);
1002
1003 allocator_->RemoveObserver(&observer_low);
1004 allocator_->RemoveObserver(&observer_mid);
1005 allocator_->RemoveObserver(&observer_high);
1006}
1007
1008// Tests that after two observers are allocated bitrate to their max, the
1009// the remaining observer is allocated what's left appropriately. This test
1010// handles an edge case where the medium and high observer reach their
1011// "relative" max allocation at the same time. The high has 40 to allocate
1012// above its min, and the mid has 20 to allocate above its min, which scaled
1013// by their bitrate priority is the same for each.
1014TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
1015 TestBitrateObserver observer_low;
1016 TestBitrateObserver observer_mid;
1017 TestBitrateObserver observer_high;
Jonas Olsson0182a032019-07-09 10:31:201018 AddObserver(&observer_low, 10, 40, 0, false, 2.0);
Seth Hampsonfe73d6a2017-11-14 18:49:061019 // Scaled allocation above the min allocation is the same for these two,
1020 // meaning they will get allocated their max at the same time.
1021 // Scaled (target allocation) = (max - min) / bitrate priority
Jonas Olsson0182a032019-07-09 10:31:201022 AddObserver(&observer_mid, 10, 30, 0, false, 4.0);
1023 AddObserver(&observer_high, 10, 50, 0, false, 8.0);
Sebastian Jansson40de3cc2019-09-19 12:54:431024 allocator_->OnNetworkEstimateChanged(
1025 CreateTargetRateMessage(110, 0, 0, kDefaultProbingIntervalMs));
Seth Hampsonfe73d6a2017-11-14 18:49:061026
1027 EXPECT_EQ(30u, observer_low.last_bitrate_bps_);
1028 EXPECT_EQ(30u, observer_mid.last_bitrate_bps_);
1029 EXPECT_EQ(50u, observer_high.last_bitrate_bps_);
1030
1031 allocator_->RemoveObserver(&observer_low);
1032 allocator_->RemoveObserver(&observer_mid);
1033 allocator_->RemoveObserver(&observer_high);
1034}
1035
stefan@webrtc.org792f1a12015-03-04 12:24:261036} // namespace webrtc