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