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 "testing/gtest/include/gtest/gtest.h"
12
13 #include <algorithm>
14 #include <vector>
15
16 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
17 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
18
19 using webrtc::RtcpBandwidthObserver;
20 using webrtc::BitrateObserver;
21 using webrtc::BitrateController;
22
WeightedLoss(int num_packets1,uint8_t fraction_loss1,int num_packets2,uint8_t fraction_loss2)23 uint8_t WeightedLoss(int num_packets1, uint8_t fraction_loss1,
24 int num_packets2, uint8_t fraction_loss2) {
25 int weighted_sum = num_packets1 * fraction_loss1 +
26 num_packets2 * fraction_loss2;
27 int total_num_packets = num_packets1 + num_packets2;
28 return (weighted_sum + total_num_packets / 2) / total_num_packets;
29 }
30
CreateReportBlock(uint32_t remote_ssrc,uint32_t source_ssrc,uint8_t fraction_lost,uint32_t extended_high_sequence_number)31 webrtc::RTCPReportBlock CreateReportBlock(
32 uint32_t remote_ssrc, uint32_t source_ssrc,
33 uint8_t fraction_lost, uint32_t extended_high_sequence_number) {
34 return webrtc::RTCPReportBlock(remote_ssrc, source_ssrc, fraction_lost, 0,
35 extended_high_sequence_number, 0, 0, 0);
36 }
37
38 class TestBitrateObserver: public BitrateObserver {
39 public:
TestBitrateObserver()40 TestBitrateObserver()
41 : last_bitrate_(0),
42 last_fraction_loss_(0),
43 last_rtt_(0) {
44 }
45
OnNetworkChanged(uint32_t bitrate,uint8_t fraction_loss,int64_t rtt)46 virtual void OnNetworkChanged(uint32_t bitrate,
47 uint8_t fraction_loss,
48 int64_t rtt) {
49 last_bitrate_ = static_cast<int>(bitrate);
50 last_fraction_loss_ = fraction_loss;
51 last_rtt_ = rtt;
52 }
53 int last_bitrate_;
54 uint8_t last_fraction_loss_;
55 int64_t last_rtt_;
56 };
57
58 class BitrateControllerTest : public ::testing::Test {
59 protected:
BitrateControllerTest()60 BitrateControllerTest() : clock_(0) {}
~BitrateControllerTest()61 ~BitrateControllerTest() {}
62
SetUp()63 virtual void SetUp() {
64 controller_ =
65 BitrateController::CreateBitrateController(&clock_, &bitrate_observer_);
66 controller_->SetStartBitrate(kStartBitrateBps);
67 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
68 controller_->SetMinMaxBitrate(kMinBitrateBps, kMaxBitrateBps);
69 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
70 bandwidth_observer_ = controller_->CreateRtcpBandwidthObserver();
71 }
72
TearDown()73 virtual void TearDown() {
74 delete bandwidth_observer_;
75 delete controller_;
76 }
77
78 const int kMinBitrateBps = 100000;
79 const int kStartBitrateBps = 200000;
80 const int kMaxBitrateBps = 300000;
81
82 const int kDefaultMinBitrateBps = 10000;
83 const int kDefaultMaxBitrateBps = 1000000000;
84
85 webrtc::SimulatedClock clock_;
86 TestBitrateObserver bitrate_observer_;
87 BitrateController* controller_;
88 RtcpBandwidthObserver* bandwidth_observer_;
89 };
90
TEST_F(BitrateControllerTest,DefaultMinMaxBitrate)91 TEST_F(BitrateControllerTest, DefaultMinMaxBitrate) {
92 // Receive successively lower REMBs, verify the reserved bitrate is deducted.
93 controller_->SetMinMaxBitrate(0, 0);
94 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
95 bandwidth_observer_->OnReceivedEstimatedBitrate(kDefaultMinBitrateBps / 2);
96 EXPECT_EQ(kDefaultMinBitrateBps, bitrate_observer_.last_bitrate_);
97 bandwidth_observer_->OnReceivedEstimatedBitrate(2 * kDefaultMaxBitrateBps);
98 clock_.AdvanceTimeMilliseconds(1000);
99 controller_->Process();
100 EXPECT_EQ(kDefaultMaxBitrateBps, bitrate_observer_.last_bitrate_);
101 }
102
TEST_F(BitrateControllerTest,OneBitrateObserverOneRtcpObserver)103 TEST_F(BitrateControllerTest, OneBitrateObserverOneRtcpObserver) {
104 // First REMB applies immediately.
105 int64_t time_ms = 1001;
106 webrtc::ReportBlockList report_blocks;
107 report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
108 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
109 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
110 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
111 EXPECT_EQ(0, bitrate_observer_.last_rtt_);
112 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
113 report_blocks.clear();
114 time_ms += 2000;
115
116 // Receive a high remb, test bitrate inc.
117 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
118
119 // Test bitrate increase 8% per second.
120 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
121 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
122 EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
123 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
124 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
125 time_ms += 1000;
126
127 report_blocks.clear();
128 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
129 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
130 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
131 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
132 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
133 time_ms += 1000;
134
135 report_blocks.clear();
136 report_blocks.push_back(CreateReportBlock(1, 2, 0, 61));
137 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
138 EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
139 time_ms += 1000;
140
141 report_blocks.clear();
142 report_blocks.push_back(CreateReportBlock(1, 2, 0, 81));
143 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
144 EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
145 time_ms += 1000;
146
147 report_blocks.clear();
148 report_blocks.push_back(CreateReportBlock(1, 2, 0, 801));
149 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
150 EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
151 time_ms += 1000;
152
153 // Reach max cap.
154 report_blocks.clear();
155 report_blocks.push_back(CreateReportBlock(1, 2, 0, 101));
156 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
157 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
158 time_ms += 1000;
159
160 report_blocks.clear();
161 report_blocks.push_back(CreateReportBlock(1, 2, 0, 141));
162 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
163 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
164
165 // Test that a low REMB trigger immediately.
166 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
167 EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
168 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
169 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
170
171 bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
172 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_); // Min cap.
173 }
174
TEST_F(BitrateControllerTest,OneBitrateObserverTwoRtcpObservers)175 TEST_F(BitrateControllerTest, OneBitrateObserverTwoRtcpObservers) {
176 // REMBs during the first 2 seconds apply immediately.
177 int64_t time_ms = 1;
178 webrtc::ReportBlockList report_blocks;
179 report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
180 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
181 report_blocks.clear();
182 time_ms += 500;
183
184 RtcpBandwidthObserver* second_bandwidth_observer =
185 controller_->CreateRtcpBandwidthObserver();
186
187 // Test start bitrate.
188 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
189 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
190 report_blocks, 100, 1);
191 EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
192 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
193 EXPECT_EQ(100, bitrate_observer_.last_rtt_);
194 time_ms += 500;
195
196 // Test bitrate increase 8% per second.
197 report_blocks.clear();
198 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
199 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
200 time_ms += 500;
201 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
202 report_blocks, 100, time_ms);
203 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
204 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
205 EXPECT_EQ(100, bitrate_observer_.last_rtt_);
206 time_ms += 500;
207
208 // Extra report should not change estimate.
209 report_blocks.clear();
210 report_blocks.push_back(CreateReportBlock(1, 2, 0, 31));
211 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
212 report_blocks, 100, time_ms);
213 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
214 time_ms += 500;
215
216 report_blocks.clear();
217 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
218 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
219 EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
220
221 // Second report should not change estimate.
222 report_blocks.clear();
223 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
224 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
225 report_blocks, 100, time_ms);
226 EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
227 time_ms += 1000;
228
229 // Reports from only one bandwidth observer is ok.
230 report_blocks.clear();
231 report_blocks.push_back(CreateReportBlock(1, 2, 0, 61));
232 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
233 report_blocks, 50, time_ms);
234 EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
235 time_ms += 1000;
236
237 report_blocks.clear();
238 report_blocks.push_back(CreateReportBlock(1, 2, 0, 81));
239 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
240 report_blocks, 50, time_ms);
241 EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
242 time_ms += 1000;
243
244 // Reach max cap.
245 report_blocks.clear();
246 report_blocks.push_back(CreateReportBlock(1, 2, 0, 121));
247 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
248 report_blocks, 50, time_ms);
249 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
250 time_ms += 1000;
251
252 report_blocks.clear();
253 report_blocks.push_back(CreateReportBlock(1, 2, 0, 141));
254 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
255 report_blocks, 50, time_ms);
256 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
257
258 // Test that a low REMB trigger immediately.
259 // We don't care which bandwidth observer that delivers the REMB.
260 second_bandwidth_observer->OnReceivedEstimatedBitrate(250000);
261 EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
262 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
263 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
264
265 // Min cap.
266 bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
267 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
268 delete second_bandwidth_observer;
269 }
270
TEST_F(BitrateControllerTest,OneBitrateObserverMultipleReportBlocks)271 TEST_F(BitrateControllerTest, OneBitrateObserverMultipleReportBlocks) {
272 uint32_t sequence_number[2] = {0, 0xFF00};
273 const int kStartBitrate = 200000;
274 const int kMinBitrate = 100000;
275 const int kMaxBitrate = 300000;
276 controller_->SetStartBitrate(kStartBitrate);
277 controller_->SetMinMaxBitrate(kMinBitrate, kMaxBitrate);
278
279 // REMBs during the first 2 seconds apply immediately.
280 int64_t time_ms = 1001;
281 webrtc::ReportBlockList report_blocks;
282 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
283 bandwidth_observer_->OnReceivedEstimatedBitrate(kStartBitrate);
284 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
285 report_blocks.clear();
286 time_ms += 2000;
287
288 // Receive a high REMB, test bitrate increase.
289 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
290
291 int last_bitrate = 0;
292 // Ramp up to max bitrate.
293 for (int i = 0; i < 6; ++i) {
294 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
295 report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
296 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50,
297 time_ms);
298 EXPECT_GT(bitrate_observer_.last_bitrate_, last_bitrate);
299 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
300 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
301 last_bitrate = bitrate_observer_.last_bitrate_;
302 time_ms += 1000;
303 sequence_number[0] += 20;
304 sequence_number[1] += 1;
305 report_blocks.clear();
306 }
307
308 EXPECT_EQ(kMaxBitrate, bitrate_observer_.last_bitrate_);
309
310 // Packet loss on the first stream. Verify that bitrate decreases.
311 report_blocks.push_back(CreateReportBlock(1, 2, 50, sequence_number[0]));
312 report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
313 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
314 EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
315 EXPECT_EQ(WeightedLoss(20, 50, 1, 0), bitrate_observer_.last_fraction_loss_);
316 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
317 last_bitrate = bitrate_observer_.last_bitrate_;
318 sequence_number[0] += 20;
319 sequence_number[1] += 20;
320 time_ms += 1000;
321 report_blocks.clear();
322
323 // Packet loss on the second stream. Verify that bitrate decreases.
324 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
325 report_blocks.push_back(CreateReportBlock(1, 3, 75, sequence_number[1]));
326 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
327 EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
328 EXPECT_EQ(WeightedLoss(20, 0, 20, 75), bitrate_observer_.last_fraction_loss_);
329 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
330 last_bitrate = bitrate_observer_.last_bitrate_;
331 sequence_number[0] += 20;
332 sequence_number[1] += 1;
333 time_ms += 1000;
334 report_blocks.clear();
335
336 // All packets lost on stream with few packets, no back-off.
337 report_blocks.push_back(CreateReportBlock(1, 2, 1, sequence_number[0]));
338 report_blocks.push_back(CreateReportBlock(1, 3, 255, sequence_number[1]));
339 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
340 EXPECT_EQ(bitrate_observer_.last_bitrate_, last_bitrate);
341 EXPECT_EQ(WeightedLoss(20, 1, 1, 255), bitrate_observer_.last_fraction_loss_);
342 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
343 last_bitrate = bitrate_observer_.last_bitrate_;
344 sequence_number[0] += 20;
345 sequence_number[1] += 1;
346 report_blocks.clear();
347 }
348
TEST_F(BitrateControllerTest,SetReservedBitrate)349 TEST_F(BitrateControllerTest, SetReservedBitrate) {
350 // Receive successively lower REMBs, verify the reserved bitrate is deducted.
351 controller_->SetReservedBitrate(0);
352 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
353 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
354 controller_->SetReservedBitrate(50000);
355 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
356 EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
357
358 controller_->SetReservedBitrate(0);
359 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
360 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
361 controller_->SetReservedBitrate(50000);
362 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
363 EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
364
365 controller_->SetReservedBitrate(0);
366 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
367 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
368 controller_->SetReservedBitrate(30000);
369 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
370 EXPECT_EQ(170000, bitrate_observer_.last_bitrate_);
371
372 controller_->SetReservedBitrate(0);
373 bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
374 EXPECT_EQ(160000, bitrate_observer_.last_bitrate_);
375 controller_->SetReservedBitrate(30000);
376 bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
377 EXPECT_EQ(130000, bitrate_observer_.last_bitrate_);
378
379 controller_->SetReservedBitrate(0);
380 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
381 EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
382 controller_->SetReservedBitrate(10000);
383 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
384 EXPECT_EQ(110000, bitrate_observer_.last_bitrate_);
385
386 controller_->SetReservedBitrate(0);
387 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
388 EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
389 controller_->SetReservedBitrate(50000);
390 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
391 // Limited by min bitrate.
392 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
393
394 controller_->SetReservedBitrate(10000);
395 bandwidth_observer_->OnReceivedEstimatedBitrate(1);
396 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
397 }
398