OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 30 matching lines...) Expand all Loading... |
41 allocator_->OnNetworkChanged(300000u, 0, 0); | 41 allocator_->OnNetworkChanged(300000u, 0, 0); |
42 } | 42 } |
43 ~BitrateAllocatorTest() {} | 43 ~BitrateAllocatorTest() {} |
44 | 44 |
45 std::unique_ptr<BitrateAllocator> allocator_; | 45 std::unique_ptr<BitrateAllocator> allocator_; |
46 }; | 46 }; |
47 | 47 |
48 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { | 48 TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) { |
49 TestBitrateObserver bitrate_observer; | 49 TestBitrateObserver bitrate_observer; |
50 int start_bitrate = | 50 int start_bitrate = |
51 allocator_->AddObserver(&bitrate_observer, 100000, 1500000); | 51 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
52 EXPECT_EQ(300000, start_bitrate); | 52 EXPECT_EQ(300000, start_bitrate); |
53 allocator_->OnNetworkChanged(200000, 0, 0); | 53 allocator_->OnNetworkChanged(200000, 0, 0); |
54 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); | 54 EXPECT_EQ(200000u, bitrate_observer.last_bitrate_); |
55 | 55 |
56 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max | 56 // TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max |
57 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). | 57 // bitrate for FEC/retransmissions (see todo in BitrateAllocator). |
58 allocator_->OnNetworkChanged(4000000, 0, 0); | 58 allocator_->OnNetworkChanged(4000000, 0, 0); |
59 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); | 59 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
60 start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 4000000); | 60 start_bitrate = |
| 61 allocator_->AddObserver(&bitrate_observer, 100000, 4000000, true); |
61 EXPECT_EQ(4000000, start_bitrate); | 62 EXPECT_EQ(4000000, start_bitrate); |
62 | 63 |
63 start_bitrate = allocator_->AddObserver(&bitrate_observer, 100000, 1500000); | 64 start_bitrate = |
| 65 allocator_->AddObserver(&bitrate_observer, 100000, 1500000, true); |
64 EXPECT_EQ(3000000, start_bitrate); | 66 EXPECT_EQ(3000000, start_bitrate); |
65 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); | 67 EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_); |
66 allocator_->OnNetworkChanged(1500000, 0, 0); | 68 allocator_->OnNetworkChanged(1500000, 0, 0); |
67 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_); | 69 EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_); |
68 } | 70 } |
69 | 71 |
70 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { | 72 TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { |
71 TestBitrateObserver bitrate_observer_1; | 73 TestBitrateObserver bitrate_observer_1; |
72 TestBitrateObserver bitrate_observer_2; | 74 TestBitrateObserver bitrate_observer_2; |
73 int start_bitrate = | 75 int start_bitrate = |
74 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000); | 76 allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, true); |
75 EXPECT_EQ(300000, start_bitrate); | 77 EXPECT_EQ(300000, start_bitrate); |
76 start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 300000); | 78 start_bitrate = |
| 79 allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, true); |
77 EXPECT_EQ(200000, start_bitrate); | 80 EXPECT_EQ(200000, start_bitrate); |
78 | 81 |
79 // Test too low start bitrate, hence lower than sum of min. Min bitrates will | 82 // Test too low start bitrate, hence lower than sum of min. Min bitrates will |
80 // be allocated to all observers. | 83 // be allocated to all observers. |
81 allocator_->OnNetworkChanged(200000, 0, 50); | 84 allocator_->OnNetworkChanged(200000, 0, 50); |
82 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 85 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
83 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); | 86 EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); |
84 EXPECT_EQ(50, bitrate_observer_1.last_rtt_); | 87 EXPECT_EQ(50, bitrate_observer_1.last_rtt_); |
85 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); | 88 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
86 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); | 89 EXPECT_EQ(0, bitrate_observer_2.last_fraction_loss_); |
(...skipping 13 matching lines...) Expand all Loading... |
100 // Verify that if the bandwidth estimate is set to zero, the allocated rate is | 103 // Verify that if the bandwidth estimate is set to zero, the allocated rate is |
101 // zero. | 104 // zero. |
102 allocator_->OnNetworkChanged(0, 0, 50); | 105 allocator_->OnNetworkChanged(0, 0, 50); |
103 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); | 106 EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_); |
104 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); | 107 EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_); |
105 } | 108 } |
106 | 109 |
107 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { | 110 class BitrateAllocatorTestNoEnforceMin : public ::testing::Test { |
108 protected: | 111 protected: |
109 BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) { | 112 BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) { |
110 allocator_->EnforceMinBitrate(false); | |
111 allocator_->OnNetworkChanged(300000u, 0, 0); | 113 allocator_->OnNetworkChanged(300000u, 0, 0); |
112 } | 114 } |
113 ~BitrateAllocatorTestNoEnforceMin() {} | 115 ~BitrateAllocatorTestNoEnforceMin() {} |
114 | 116 |
115 std::unique_ptr<BitrateAllocator> allocator_; | 117 std::unique_ptr<BitrateAllocator> allocator_; |
116 }; | 118 }; |
117 | 119 |
118 // The following three tests verify that the EnforceMinBitrate() method works | 120 // The following three tests verify that the EnforceMinBitrate() method works |
119 // as intended. | 121 // as intended. |
120 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { | 122 TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) { |
121 TestBitrateObserver bitrate_observer_1; | 123 TestBitrateObserver bitrate_observer_1; |
122 int start_bitrate = | 124 int start_bitrate = |
123 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); | 125 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); |
124 EXPECT_EQ(300000, start_bitrate); | 126 EXPECT_EQ(300000, start_bitrate); |
125 | 127 |
126 // High REMB. | 128 // High REMB. |
127 allocator_->OnNetworkChanged(150000, 0, 0); | 129 allocator_->OnNetworkChanged(150000, 0, 0); |
128 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_); | 130 EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_); |
129 | 131 |
130 // Low REMB. | 132 // Low REMB. |
131 allocator_->OnNetworkChanged(10000, 0, 0); | 133 allocator_->OnNetworkChanged(10000, 0, 0); |
132 EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); | 134 EXPECT_EQ(10000u, bitrate_observer_1.last_bitrate_); |
133 | 135 |
134 allocator_->RemoveObserver(&bitrate_observer_1); | 136 allocator_->RemoveObserver(&bitrate_observer_1); |
135 } | 137 } |
136 | 138 |
137 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { | 139 TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) { |
138 TestBitrateObserver bitrate_observer_1; | 140 TestBitrateObserver bitrate_observer_1; |
139 TestBitrateObserver bitrate_observer_2; | 141 TestBitrateObserver bitrate_observer_2; |
140 TestBitrateObserver bitrate_observer_3; | 142 TestBitrateObserver bitrate_observer_3; |
141 // Set up the observers with min bitrates at 100000, 200000, and 300000. | 143 // Set up the observers with min bitrates at 100000, 200000, and 300000. |
142 int start_bitrate = | 144 int start_bitrate = |
143 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); | 145 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, false); |
144 EXPECT_EQ(300000, start_bitrate); | 146 EXPECT_EQ(300000, start_bitrate); |
145 | 147 |
146 start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); | 148 start_bitrate = |
| 149 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, false); |
147 EXPECT_EQ(200000, start_bitrate); | 150 EXPECT_EQ(200000, start_bitrate); |
148 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 151 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
149 | 152 |
150 start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); | 153 start_bitrate = |
| 154 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, false); |
151 EXPECT_EQ(0, start_bitrate); | 155 EXPECT_EQ(0, start_bitrate); |
152 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 156 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
153 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); | 157 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); |
154 | 158 |
155 // High REMB. Make sure the controllers get a fair share of the surplus | 159 // High REMB. Make sure the controllers get a fair share of the surplus |
156 // (i.e., what is left after each controller gets its min rate). | 160 // (i.e., what is left after each controller gets its min rate). |
157 allocator_->OnNetworkChanged(690000, 0, 0); | 161 allocator_->OnNetworkChanged(690000, 0, 0); |
158 // Verify that each observer gets its min rate (sum of min rates is 600000), | 162 // Verify that each observer gets its min rate (sum of min rates is 600000), |
159 // and that the remaining 90000 is divided equally among the three. | 163 // and that the remaining 90000 is divided equally among the three. |
160 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; | 164 uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u; |
(...skipping 26 matching lines...) Expand all Loading... |
187 allocator_->RemoveObserver(&bitrate_observer_1); | 191 allocator_->RemoveObserver(&bitrate_observer_1); |
188 allocator_->RemoveObserver(&bitrate_observer_2); | 192 allocator_->RemoveObserver(&bitrate_observer_2); |
189 allocator_->RemoveObserver(&bitrate_observer_3); | 193 allocator_->RemoveObserver(&bitrate_observer_3); |
190 } | 194 } |
191 | 195 |
192 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { | 196 TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) { |
193 TestBitrateObserver bitrate_observer_1; | 197 TestBitrateObserver bitrate_observer_1; |
194 TestBitrateObserver bitrate_observer_2; | 198 TestBitrateObserver bitrate_observer_2; |
195 TestBitrateObserver bitrate_observer_3; | 199 TestBitrateObserver bitrate_observer_3; |
196 int start_bitrate = | 200 int start_bitrate = |
197 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000); | 201 allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, true); |
198 EXPECT_EQ(300000, start_bitrate); | 202 EXPECT_EQ(300000, start_bitrate); |
199 | 203 |
200 start_bitrate = allocator_->AddObserver(&bitrate_observer_2, 200000, 400000); | 204 start_bitrate = |
| 205 allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, true); |
201 EXPECT_EQ(200000, start_bitrate); | 206 EXPECT_EQ(200000, start_bitrate); |
202 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); | 207 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); |
203 | 208 |
204 start_bitrate = allocator_->AddObserver(&bitrate_observer_3, 300000, 400000); | 209 start_bitrate = |
| 210 allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, true); |
205 EXPECT_EQ(300000, start_bitrate); | 211 EXPECT_EQ(300000, start_bitrate); |
206 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_)); | 212 EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_)); |
207 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_)); | 213 EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_)); |
208 | 214 |
209 // Low REMB. Verify that all observers still get their respective min bitrate. | 215 // Low REMB. Verify that all observers still get their respective min bitrate. |
210 allocator_->OnNetworkChanged(1000, 0, 0); | 216 allocator_->OnNetworkChanged(1000, 0, 0); |
211 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min cap. | 217 EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_); // Min cap. |
212 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. | 218 EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_); // Min cap. |
213 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. | 219 EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_); // Min cap. |
214 | 220 |
215 allocator_->RemoveObserver(&bitrate_observer_1); | 221 allocator_->RemoveObserver(&bitrate_observer_1); |
216 allocator_->RemoveObserver(&bitrate_observer_2); | 222 allocator_->RemoveObserver(&bitrate_observer_2); |
217 allocator_->RemoveObserver(&bitrate_observer_3); | 223 allocator_->RemoveObserver(&bitrate_observer_3); |
218 } | 224 } |
219 } // namespace webrtc | 225 } // namespace webrtc |
OLD | NEW |