stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
| 11 | #include <algorithm> |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame^] | 12 | #include <memory> |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 13 | #include <vector> |
| 14 | |
| 15 | #include "testing/gtest/include/gtest/gtest.h" |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 16 | #include "webrtc/call/bitrate_allocator.h" |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 17 | #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" |
| 18 | |
| 19 | namespace webrtc { |
| 20 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 21 | class TestBitrateObserver : public BitrateAllocatorObserver { |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 22 | public: |
| 23 | TestBitrateObserver() |
| 24 | : last_bitrate_(0), last_fraction_loss_(0), last_rtt_(0) {} |
| 25 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 26 | virtual void OnBitrateUpdated(uint32_t bitrate, |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 27 | uint8_t fraction_loss, |
| 28 | int64_t rtt) { |
| 29 | last_bitrate_ = bitrate; |
| 30 | last_fraction_loss_ = fraction_loss; |
| 31 | last_rtt_ = rtt; |
| 32 | } |
| 33 | uint32_t last_bitrate_; |
| 34 | uint8_t last_fraction_loss_; |
| 35 | int64_t last_rtt_; |
| 36 | }; |
| 37 | |
| 38 | class BitrateAllocatorTest : public ::testing::Test { |
| 39 | protected: |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 40 | BitrateAllocatorTest() : allocator_(new BitrateAllocator()) { |
| 41 | allocator_->OnNetworkChanged(300000u, 0, 0); |
| 42 | } |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 43 | ~BitrateAllocatorTest() {} |
| 44 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame^] | 45 | std::unique_ptr<BitrateAllocator> allocator_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 46 | }; |
| 47 | |
| 48 | TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
| 49 | TestBitrateObserver bitrate_observer; |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 50 | int start_bitrate = |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 51 | allocator_->AddObserver(&bitrate_observer, 100000, 1500000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 52 | EXPECT_EQ(300000, start_bitrate); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 53 | allocator_->OnNetworkChanged(200000, 0, 0); |
| 54 | EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); |
| 55 | |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 56 | // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max |
mflodman | 0e7e259 | 2015-11-12 21:02:42 -0800 | [diff] [blame] | 57 | // bitrate for FEC/retransmissions (see todo in BitrateAllocator). |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 58 | allocator_->OnNetworkChanged(4000000, 0, 0); |
| 59 | EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 60 | start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 4000000); |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 61 | EXPECT_EQ(4000000, start_bitrate); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 62 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 63 | start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 1500000); |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 64 | EXPECT_EQ(3000000, start_bitrate); |
| 65 | EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 66 | allocator_->OnNetworkChanged(1500000, 0, 0); |
| 67 | EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_); |
| 68 | } |
| 69 | |
| 70 | TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
| 71 | TestBitrateObserver bitrate_observer_1; |
| 72 | TestBitrateObserver bitrate_observer_2; |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 73 | int start_bitrate = |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 74 | allocator_->AddObserver(&bitrate_observer_1, 100000, 300000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 75 | EXPECT_EQ(300000, start_bitrate); |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 76 | start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 300000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 77 | EXPECT_EQ(200000, start_bitrate); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 78 | |
| 79 | // Test too low start bitrate, hence lower than sum of min. Min bitrates will |
| 80 | // be allocated to all observers. |
| 81 | allocator_->OnNetworkChanged(200000, 0, 50); |
| 82 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
| 83 | EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); |
| 84 | EXPECT_EQ(50, bitrate_observer_1.last_rtt_); |
| 85 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
| 86 | EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
| 87 | EXPECT_EQ(50, bitrate_observer_2.last_rtt_); |
| 88 | |
| 89 | // Test a bitrate which should be distributed equally. |
| 90 | allocator_->OnNetworkChanged(500000, 0, 50); |
| 91 | const uint32_t kBitrateToShare = 500000 - 200000 - 100000; |
| 92 | EXPECT_EQ(100000u + kBitrateToShare / 2, bitrate_observer_1.last_bitrate_); |
| 93 | EXPECT_EQ(200000u + kBitrateToShare / 2, bitrate_observer_2.last_bitrate_); |
| 94 | |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 95 | // Limited by 2x max bitrates since we leave room for FEC and retransmissions. |
| 96 | allocator_->OnNetworkChanged(1500000, 0, 50); |
| 97 | EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_); |
| 98 | EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 99 | } |
| 100 | |
| 101 | class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
| 102 | protected: |
| 103 | BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) { |
| 104 | allocator_->EnforceMinBitrate(false); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 105 | allocator_->OnNetworkChanged(300000u, 0, 0); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 106 | } |
| 107 | ~BitrateAllocatorTestNoEnforceMin() {} |
| 108 | |
kwiberg | b25345e | 2016-03-12 06:10:44 -0800 | [diff] [blame^] | 109 | std::unique_ptr<BitrateAllocator> allocator_; |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 110 | }; |
| 111 | |
| 112 | // The following three tests verify that the EnforceMinBitrate() method works |
| 113 | // as intended. |
| 114 | TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
| 115 | TestBitrateObserver bitrate_observer_1; |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 116 | int start_bitrate = |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 117 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 118 | EXPECT_EQ(300000, start_bitrate); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 119 | |
| 120 | // High REMB. |
| 121 | allocator_->OnNetworkChanged(150000, 0, 0); |
| 122 | EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_); |
| 123 | |
| 124 | // Low REMB. |
| 125 | allocator_->OnNetworkChanged(10000, 0, 0); |
| 126 | EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); |
| 127 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 128 | allocator_->RemoveObserver(&bitrate_observer_1); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
| 132 | TestBitrateObserver bitrate_observer_1; |
| 133 | TestBitrateObserver bitrate_observer_2; |
| 134 | TestBitrateObserver bitrate_observer_3; |
| 135 | // Set up the observers with min bitrates at 100000, 200000, and 300000. |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 136 | int start_bitrate = |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 137 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 138 | EXPECT_EQ(300000, start_bitrate); |
| 139 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 140 | start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 141 | EXPECT_EQ(200000, start_bitrate); |
| 142 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
| 143 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 144 | start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 145 | EXPECT_EQ(0, start_bitrate); |
| 146 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
| 147 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 148 | |
| 149 | // High REMB. Make sure the controllers get a fair share of the surplus |
| 150 | // (i.e., what is left after each controller gets its min rate). |
| 151 | allocator_->OnNetworkChanged(690000, 0, 0); |
| 152 | // Verify that each observer gets its min rate (sum of min rates is 600000), |
| 153 | // and that the remaining 90000 is divided equally among the three. |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 154 | uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; |
| 155 | EXPECT_EQ(100000u + bitrate_to_share / 3, bitrate_observer_1.last_bitrate_); |
| 156 | EXPECT_EQ(200000u + bitrate_to_share / 3, bitrate_observer_2.last_bitrate_); |
| 157 | EXPECT_EQ(300000u + bitrate_to_share / 3, bitrate_observer_3.last_bitrate_); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 158 | |
| 159 | // High REMB, but below the sum of min bitrates. |
| 160 | allocator_->OnNetworkChanged(500000, 0, 0); |
| 161 | // Verify that the first and second observers get their min bitrates, and the |
| 162 | // third gets the remainder. |
| 163 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min bitrate. |
| 164 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min bitrate. |
| 165 | EXPECT_EQ(200000u, bitrate_observer_3.last_bitrate_); // Remainder. |
| 166 | |
| 167 | // Low REMB. |
| 168 | allocator_->OnNetworkChanged(10000, 0, 0); |
| 169 | // Verify that the first observer gets all the rate, and the rest get zero. |
| 170 | EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); |
| 171 | EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
| 172 | EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_); |
| 173 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 174 | allocator_->RemoveObserver(&bitrate_observer_1); |
| 175 | allocator_->RemoveObserver(&bitrate_observer_2); |
| 176 | allocator_->RemoveObserver(&bitrate_observer_3); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 177 | } |
| 178 | |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 179 | TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { |
| 180 | TestBitrateObserver bitrate_observer_1; |
| 181 | TestBitrateObserver bitrate_observer_2; |
| 182 | TestBitrateObserver bitrate_observer_3; |
Peter Boström | 8e4e8b0 | 2015-09-15 15:08:03 +0200 | [diff] [blame] | 183 | int start_bitrate = |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 184 | allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 185 | EXPECT_EQ(300000, start_bitrate); |
| 186 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 187 | start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 188 | EXPECT_EQ(200000, start_bitrate); |
| 189 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
| 190 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 191 | start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 192 | EXPECT_EQ(300000, start_bitrate); |
| 193 | EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_)); |
| 194 | EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_)); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 195 | |
| 196 | // Low REMB. Verify that all observers still get their respective min bitrate. |
| 197 | allocator_->OnNetworkChanged(1000, 0, 0); |
| 198 | EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min cap. |
| 199 | EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. |
| 200 | EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. |
| 201 | |
mflodman | 86aabb2 | 2016-03-11 15:44:32 +0100 | [diff] [blame] | 202 | allocator_->RemoveObserver(&bitrate_observer_1); |
| 203 | allocator_->RemoveObserver(&bitrate_observer_2); |
| 204 | allocator_->RemoveObserver(&bitrate_observer_3); |
stefan@webrtc.org | 792f1a1 | 2015-03-04 12:24:26 +0000 | [diff] [blame] | 205 | } |
| 206 | } // namespace webrtc |