blob: 66ca5b9558d5ec17c31f5755cd645232464690bd [file] [log] [blame]
pwestin@webrtc.org1cd11622012-04-19 12:13:521/*
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
pwestin@webrtc.org1cd11622012-04-19 12:13:5211#include <algorithm>
12#include <vector>
13
Mirko Bonadei92ea95e2017-09-15 04:47:3114#include "logging/rtc_event_log/mock/mock_rtc_event_log.h"
15#include "modules/bitrate_controller/include/bitrate_controller.h"
16#include "modules/pacing/mock/mock_paced_sender.h"
17#include "modules/remote_bitrate_estimator/include/bwe_defines.h"
18#include "test/field_trial.h"
19#include "test/gtest.h"
pwestin@webrtc.org1cd11622012-04-19 12:13:5220
perkjec81bcd2016-05-11 13:01:1321using ::testing::Exactly;
22using ::testing::Return;
23
perkje30c2722016-05-09 11:57:1124using webrtc::BitrateController;
perkjec81bcd2016-05-11 13:01:1325using webrtc::BitrateObserver;
26using webrtc::PacedSender;
27using webrtc::RtcpBandwidthObserver;
pwestin@webrtc.org1cd11622012-04-19 12:13:5228
stefan@webrtc.org28a331e2013-09-17 07:49:5629uint8_t WeightedLoss(int num_packets1, uint8_t fraction_loss1,
30 int num_packets2, uint8_t fraction_loss2) {
31 int weighted_sum = num_packets1 * fraction_loss1 +
32 num_packets2 * fraction_loss2;
33 int total_num_packets = num_packets1 + num_packets2;
34 return (weighted_sum + total_num_packets / 2) / total_num_packets;
35}
36
37webrtc::RTCPReportBlock CreateReportBlock(
38 uint32_t remote_ssrc, uint32_t source_ssrc,
39 uint8_t fraction_lost, uint32_t extended_high_sequence_number) {
40 return webrtc::RTCPReportBlock(remote_ssrc, source_ssrc, fraction_lost, 0,
41 extended_high_sequence_number, 0, 0, 0);
42}
43
pwestin@webrtc.org1cd11622012-04-19 12:13:5244class TestBitrateObserver: public BitrateObserver {
45 public:
46 TestBitrateObserver()
kjellander@webrtc.org2e84c112012-05-31 13:55:0147 : last_bitrate_(0),
48 last_fraction_loss_(0),
49 last_rtt_(0) {
pwestin@webrtc.org1cd11622012-04-19 12:13:5250 }
51
stefan@webrtc.orgedeea912014-12-08 19:46:2352 virtual void OnNetworkChanged(uint32_t bitrate,
53 uint8_t fraction_loss,
pkasting@chromium.org16825b12015-01-12 21:51:2154 int64_t rtt) {
Stefan Holmere5904162015-03-26 10:11:0655 last_bitrate_ = static_cast<int>(bitrate);
kjellander@webrtc.org2e84c112012-05-31 13:55:0156 last_fraction_loss_ = fraction_loss;
57 last_rtt_ = rtt;
pwestin@webrtc.org1cd11622012-04-19 12:13:5258 }
Stefan Holmere5904162015-03-26 10:11:0659 int last_bitrate_;
kjellander@webrtc.org2e84c112012-05-31 13:55:0160 uint8_t last_fraction_loss_;
pkasting@chromium.org16825b12015-01-12 21:51:2161 int64_t last_rtt_;
pwestin@webrtc.org1cd11622012-04-19 12:13:5262};
63
64class BitrateControllerTest : public ::testing::Test {
65 protected:
stefan@webrtc.org792f1a12015-03-04 12:24:2666 BitrateControllerTest() : clock_(0) {}
pwestin@webrtc.org1cd11622012-04-19 12:13:5267 ~BitrateControllerTest() {}
68
69 virtual void SetUp() {
Stefan Holmer52200d02016-09-20 12:14:2370 controller_.reset(BitrateController::CreateBitrateController(
71 &clock_, &bitrate_observer_, &event_log_));
Stefan Holmere5904162015-03-26 10:11:0672 controller_->SetStartBitrate(kStartBitrateBps);
73 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
74 controller_->SetMinMaxBitrate(kMinBitrateBps, kMaxBitrateBps);
75 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
Sebastian Jansson8d9c5402017-11-15 16:22:1676 bandwidth_observer_ = controller_.get();
pwestin@webrtc.org1cd11622012-04-19 12:13:5277 }
78
79 virtual void TearDown() {
pwestin@webrtc.org1cd11622012-04-19 12:13:5280 }
andresp@webrtc.org44caf012014-03-26 21:00:2181
Stefan Holmere5904162015-03-26 10:11:0682 const int kMinBitrateBps = 100000;
83 const int kStartBitrateBps = 200000;
84 const int kMaxBitrateBps = 300000;
85
86 const int kDefaultMinBitrateBps = 10000;
87 const int kDefaultMaxBitrateBps = 1000000000;
88
andresp@webrtc.org44caf012014-03-26 21:00:2189 webrtc::SimulatedClock clock_;
stefan@webrtc.org792f1a12015-03-04 12:24:2690 TestBitrateObserver bitrate_observer_;
Stefan Holmer52200d02016-09-20 12:14:2391 std::unique_ptr<BitrateController> controller_;
Sebastian Jansson8d9c5402017-11-15 16:22:1692 RtcpBandwidthObserver* bandwidth_observer_;
Ivo Creusenfa1d5682016-07-06 07:12:0693 testing::NiceMock<webrtc::MockRtcEventLog> event_log_;
pwestin@webrtc.org1cd11622012-04-19 12:13:5294};
95
Stefan Holmere5904162015-03-26 10:11:0696TEST_F(BitrateControllerTest, DefaultMinMaxBitrate) {
97 // Receive successively lower REMBs, verify the reserved bitrate is deducted.
98 controller_->SetMinMaxBitrate(0, 0);
99 EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
100 bandwidth_observer_->OnReceivedEstimatedBitrate(kDefaultMinBitrateBps / 2);
michaeltf082c2aa2016-11-07 12:17:14101 EXPECT_EQ(webrtc::congestion_controller::GetMinBitrateBps(),
102 bitrate_observer_.last_bitrate_);
Stefan Holmere5904162015-03-26 10:11:06103 bandwidth_observer_->OnReceivedEstimatedBitrate(2 * kDefaultMaxBitrateBps);
104 clock_.AdvanceTimeMilliseconds(1000);
105 controller_->Process();
106 EXPECT_EQ(kDefaultMaxBitrateBps, bitrate_observer_.last_bitrate_);
107}
108
pwestin@webrtc.org1cd11622012-04-19 12:13:52109TEST_F(BitrateControllerTest, OneBitrateObserverOneRtcpObserver) {
stefan@webrtc.org82462aa2014-10-23 11:57:05110 // First REMB applies immediately.
111 int64_t time_ms = 1001;
112 webrtc::ReportBlockList report_blocks;
113 report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
114 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
Stefan Holmere5904162015-03-26 10:11:06115 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26116 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
117 EXPECT_EQ(0, bitrate_observer_.last_rtt_);
stefan@webrtc.org82462aa2014-10-23 11:57:05118 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
119 report_blocks.clear();
120 time_ms += 2000;
121
122 // Receive a high remb, test bitrate inc.
123 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
pwestin@webrtc.org1cd11622012-04-19 12:13:52124
andresp@webrtc.org44caf012014-03-26 21:00:21125 // Test bitrate increase 8% per second.
stefan@webrtc.org82462aa2014-10-23 11:57:05126 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
127 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06128 EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26129 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
130 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
stefan@webrtc.org82462aa2014-10-23 11:57:05131 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52132
stefan@webrtc.org28a331e2013-09-17 07:49:56133 report_blocks.clear();
134 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
stefan@webrtc.org82462aa2014-10-23 11:57:05135 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06136 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26137 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
138 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
stefan@webrtc.org82462aa2014-10-23 11:57:05139 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52140
stefan@webrtc.org28a331e2013-09-17 07:49:56141 report_blocks.clear();
142 report_blocks.push_back(CreateReportBlock(1, 2, 0, 61));
stefan@webrtc.org82462aa2014-10-23 11:57:05143 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06144 EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05145 time_ms += 1000;
146
147 report_blocks.clear();
148 report_blocks.push_back(CreateReportBlock(1, 2, 0, 81));
149 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06150 EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05151 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52152
stefan@webrtc.org28a331e2013-09-17 07:49:56153 report_blocks.clear();
stefand48717b2016-08-22 15:50:31154 report_blocks.push_back(CreateReportBlock(1, 2, 0, 101));
stefan@webrtc.org82462aa2014-10-23 11:57:05155 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06156 EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05157 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52158
andresp@webrtc.org44caf012014-03-26 21:00:21159 // Reach max cap.
stefan@webrtc.org28a331e2013-09-17 07:49:56160 report_blocks.clear();
stefand48717b2016-08-22 15:50:31161 report_blocks.push_back(CreateReportBlock(1, 2, 0, 121));
stefan@webrtc.org82462aa2014-10-23 11:57:05162 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06163 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05164 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52165
stefan@webrtc.org28a331e2013-09-17 07:49:56166 report_blocks.clear();
167 report_blocks.push_back(CreateReportBlock(1, 2, 0, 141));
stefan@webrtc.org82462aa2014-10-23 11:57:05168 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06169 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52170
stefan32f81542016-01-20 15:13:58171 // Test that a low delay-based estimate limits the combined estimate.
Stefan Holmer280de9e2016-09-30 08:06:51172 webrtc::DelayBasedBwe::Result result(false, 280000);
173 controller_->OnDelayBasedBweResult(result);
stefan32f81542016-01-20 15:13:58174 EXPECT_EQ(280000, bitrate_observer_.last_bitrate_);
175
176 // Test that a low REMB limits the combined estimate.
pwestin@webrtc.org1cd11622012-04-19 12:13:52177 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
Stefan Holmere5904162015-03-26 10:11:06178 EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26179 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
180 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52181
182 bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
stefan32f81542016-01-20 15:13:58183 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52184}
185
186TEST_F(BitrateControllerTest, OneBitrateObserverTwoRtcpObservers) {
Danil Chapovalov7f8369a2017-06-08 15:22:51187 const uint32_t kSenderSsrc1 = 1;
188 const uint32_t kSenderSsrc2 = 2;
189 const uint32_t kMediaSsrc1 = 3;
190 const uint32_t kMediaSsrc2 = 4;
191
stefan@webrtc.org82462aa2014-10-23 11:57:05192 int64_t time_ms = 1;
193 webrtc::ReportBlockList report_blocks;
Danil Chapovalov7f8369a2017-06-08 15:22:51194 report_blocks = {CreateReportBlock(kSenderSsrc1, kMediaSsrc1, 0, 1)};
stefan@webrtc.org82462aa2014-10-23 11:57:05195 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
stefan@webrtc.org82462aa2014-10-23 11:57:05196 time_ms += 500;
197
Sebastian Jansson8d9c5402017-11-15 16:22:16198 RtcpBandwidthObserver* second_bandwidth_observer = controller_.get();
Danil Chapovalov7f8369a2017-06-08 15:22:51199 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 21)};
200 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
201 report_blocks, 100, time_ms);
pwestin@webrtc.org1cd11622012-04-19 12:13:52202
pwestin@webrtc.org1cd11622012-04-19 12:13:52203 // Test start bitrate.
Stefan Holmer52200d02016-09-20 12:14:23204 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26205 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
206 EXPECT_EQ(100, bitrate_observer_.last_rtt_);
stefan@webrtc.org82462aa2014-10-23 11:57:05207 time_ms += 500;
pwestin@webrtc.org1cd11622012-04-19 12:13:52208
209 // Test bitrate increase 8% per second.
Danil Chapovalov7f8369a2017-06-08 15:22:51210 report_blocks = {CreateReportBlock(kSenderSsrc1, kMediaSsrc1, 0, 21)};
stefan@webrtc.org82462aa2014-10-23 11:57:05211 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
212 time_ms += 500;
Danil Chapovalov7f8369a2017-06-08 15:22:51213
214 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 21)};
stefan@webrtc.org82462aa2014-10-23 11:57:05215 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
216 report_blocks, 100, time_ms);
Stefan Holmer52200d02016-09-20 12:14:23217 EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26218 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
219 EXPECT_EQ(100, bitrate_observer_.last_rtt_);
stefan@webrtc.org82462aa2014-10-23 11:57:05220 time_ms += 500;
pwestin@webrtc.org1cd11622012-04-19 12:13:52221
222 // Extra report should not change estimate.
Danil Chapovalov7f8369a2017-06-08 15:22:51223 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 31)};
stefan@webrtc.org82462aa2014-10-23 11:57:05224 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
225 report_blocks, 100, time_ms);
Stefan Holmer52200d02016-09-20 12:14:23226 EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05227 time_ms += 500;
pwestin@webrtc.org1cd11622012-04-19 12:13:52228
Danil Chapovalov7f8369a2017-06-08 15:22:51229 report_blocks = {CreateReportBlock(kSenderSsrc1, kMediaSsrc1, 0, 41)};
stefan@webrtc.org82462aa2014-10-23 11:57:05230 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
Stefan Holmer52200d02016-09-20 12:14:23231 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
pwestin@webrtc.orga2cd7322012-04-23 08:32:47232
pwestin@webrtc.org1cd11622012-04-19 12:13:52233 // Second report should not change estimate.
Danil Chapovalov7f8369a2017-06-08 15:22:51234 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 41)};
stefan@webrtc.org82462aa2014-10-23 11:57:05235 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
236 report_blocks, 100, time_ms);
Stefan Holmer52200d02016-09-20 12:14:23237 EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05238 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52239
240 // Reports from only one bandwidth observer is ok.
Danil Chapovalov7f8369a2017-06-08 15:22:51241 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 61)};
Stefan Holmer52200d02016-09-20 12:14:23242 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
243 report_blocks, 50, time_ms);
244 EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
245 time_ms += 1000;
246
Danil Chapovalov7f8369a2017-06-08 15:22:51247 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 81)};
stefan@webrtc.org82462aa2014-10-23 11:57:05248 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
249 report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06250 EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05251 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52252
Danil Chapovalov7f8369a2017-06-08 15:22:51253 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 121)};
stefan@webrtc.org82462aa2014-10-23 11:57:05254 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
255 report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06256 EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
stefan@webrtc.org82462aa2014-10-23 11:57:05257 time_ms += 1000;
pwestin@webrtc.org1cd11622012-04-19 12:13:52258
andresp@webrtc.org44caf012014-03-26 21:00:21259 // Reach max cap.
Danil Chapovalov7f8369a2017-06-08 15:22:51260 report_blocks = {CreateReportBlock(kSenderSsrc2, kMediaSsrc2, 0, 141)};
andresp@webrtc.org44caf012014-03-26 21:00:21261 second_bandwidth_observer->OnReceivedRtcpReceiverReport(
stefan@webrtc.org82462aa2014-10-23 11:57:05262 report_blocks, 50, time_ms);
Stefan Holmere5904162015-03-26 10:11:06263 EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52264
265 // Test that a low REMB trigger immediately.
266 // We don't care which bandwidth observer that delivers the REMB.
267 second_bandwidth_observer->OnReceivedEstimatedBitrate(250000);
Stefan Holmere5904162015-03-26 10:11:06268 EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
stefan@webrtc.org792f1a12015-03-04 12:24:26269 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
270 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52271
andresp@webrtc.org44caf012014-03-26 21:00:21272 // Min cap.
pwestin@webrtc.org1cd11622012-04-19 12:13:52273 bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
Stefan Holmere5904162015-03-26 10:11:06274 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
pwestin@webrtc.org1cd11622012-04-19 12:13:52275}
276
stefan@webrtc.org28a331e2013-09-17 07:49:56277TEST_F(BitrateControllerTest, OneBitrateObserverMultipleReportBlocks) {
stefan@webrtc.org28a331e2013-09-17 07:49:56278 uint32_t sequence_number[2] = {0, 0xFF00};
Stefan Holmere5904162015-03-26 10:11:06279 const int kStartBitrate = 200000;
280 const int kMinBitrate = 100000;
281 const int kMaxBitrate = 300000;
stefan@webrtc.org792f1a12015-03-04 12:24:26282 controller_->SetStartBitrate(kStartBitrate);
283 controller_->SetMinMaxBitrate(kMinBitrate, kMaxBitrate);
stefan@webrtc.org28a331e2013-09-17 07:49:56284
stefan@webrtc.org82462aa2014-10-23 11:57:05285 // REMBs during the first 2 seconds apply immediately.
286 int64_t time_ms = 1001;
287 webrtc::ReportBlockList report_blocks;
288 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
289 bandwidth_observer_->OnReceivedEstimatedBitrate(kStartBitrate);
290 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
291 report_blocks.clear();
292 time_ms += 2000;
293
stefan@webrtc.org28a331e2013-09-17 07:49:56294 // Receive a high REMB, test bitrate increase.
295 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
296
Stefan Holmere5904162015-03-26 10:11:06297 int last_bitrate = 0;
stefan@webrtc.org28a331e2013-09-17 07:49:56298 // Ramp up to max bitrate.
Stefan Holmer52200d02016-09-20 12:14:23299 for (int i = 0; i < 7; ++i) {
stefan@webrtc.org28a331e2013-09-17 07:49:56300 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
301 report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
302 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50,
303 time_ms);
stefan@webrtc.org792f1a12015-03-04 12:24:26304 EXPECT_GT(bitrate_observer_.last_bitrate_, last_bitrate);
305 EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
306 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
307 last_bitrate = bitrate_observer_.last_bitrate_;
stefan@webrtc.org28a331e2013-09-17 07:49:56308 time_ms += 1000;
309 sequence_number[0] += 20;
310 sequence_number[1] += 1;
311 report_blocks.clear();
312 }
313
stefan@webrtc.org792f1a12015-03-04 12:24:26314 EXPECT_EQ(kMaxBitrate, bitrate_observer_.last_bitrate_);
stefan@webrtc.org28a331e2013-09-17 07:49:56315
316 // Packet loss on the first stream. Verify that bitrate decreases.
317 report_blocks.push_back(CreateReportBlock(1, 2, 50, sequence_number[0]));
318 report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
319 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
stefan@webrtc.org792f1a12015-03-04 12:24:26320 EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
321 EXPECT_EQ(WeightedLoss(20, 50, 1, 0), bitrate_observer_.last_fraction_loss_);
322 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
323 last_bitrate = bitrate_observer_.last_bitrate_;
stefan@webrtc.org28a331e2013-09-17 07:49:56324 sequence_number[0] += 20;
325 sequence_number[1] += 20;
326 time_ms += 1000;
327 report_blocks.clear();
328
329 // Packet loss on the second stream. Verify that bitrate decreases.
330 report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
331 report_blocks.push_back(CreateReportBlock(1, 3, 75, sequence_number[1]));
332 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
stefan@webrtc.org792f1a12015-03-04 12:24:26333 EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
334 EXPECT_EQ(WeightedLoss(20, 0, 20, 75), bitrate_observer_.last_fraction_loss_);
335 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
336 last_bitrate = bitrate_observer_.last_bitrate_;
stefan@webrtc.org28a331e2013-09-17 07:49:56337 sequence_number[0] += 20;
338 sequence_number[1] += 1;
339 time_ms += 1000;
340 report_blocks.clear();
341
342 // All packets lost on stream with few packets, no back-off.
Sebastian Jansson5a503b02018-02-02 16:55:07343 report_blocks.push_back(CreateReportBlock(1, 2, 1, sequence_number[0]));
stefan@webrtc.org28a331e2013-09-17 07:49:56344 report_blocks.push_back(CreateReportBlock(1, 3, 255, sequence_number[1]));
345 bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
stefan@webrtc.org792f1a12015-03-04 12:24:26346 EXPECT_EQ(bitrate_observer_.last_bitrate_, last_bitrate);
Sebastian Jansson5a503b02018-02-02 16:55:07347 EXPECT_EQ(WeightedLoss(20, 1, 1, 255), bitrate_observer_.last_fraction_loss_);
stefan@webrtc.org792f1a12015-03-04 12:24:26348 EXPECT_EQ(50, bitrate_observer_.last_rtt_);
349 last_bitrate = bitrate_observer_.last_bitrate_;
stefan@webrtc.org28a331e2013-09-17 07:49:56350 sequence_number[0] += 20;
351 sequence_number[1] += 1;
352 report_blocks.clear();
353}
354
solenberg@webrtc.org4e656022014-03-26 14:32:47355TEST_F(BitrateControllerTest, SetReservedBitrate) {
solenberg@webrtc.org4e656022014-03-26 14:32:47356 // Receive successively lower REMBs, verify the reserved bitrate is deducted.
solenberg@webrtc.org4e656022014-03-26 14:32:47357 controller_->SetReservedBitrate(0);
358 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
Stefan Holmere5904162015-03-26 10:11:06359 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47360 controller_->SetReservedBitrate(50000);
361 bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
Stefan Holmere5904162015-03-26 10:11:06362 EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47363
364 controller_->SetReservedBitrate(0);
365 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
Stefan Holmere5904162015-03-26 10:11:06366 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47367 controller_->SetReservedBitrate(50000);
368 bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
Stefan Holmere5904162015-03-26 10:11:06369 EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47370
371 controller_->SetReservedBitrate(0);
372 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
Stefan Holmere5904162015-03-26 10:11:06373 EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47374 controller_->SetReservedBitrate(30000);
375 bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
Stefan Holmere5904162015-03-26 10:11:06376 EXPECT_EQ(170000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47377
378 controller_->SetReservedBitrate(0);
379 bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
Stefan Holmere5904162015-03-26 10:11:06380 EXPECT_EQ(160000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47381 controller_->SetReservedBitrate(30000);
382 bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
Stefan Holmere5904162015-03-26 10:11:06383 EXPECT_EQ(130000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47384
385 controller_->SetReservedBitrate(0);
386 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
Stefan Holmere5904162015-03-26 10:11:06387 EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47388 controller_->SetReservedBitrate(10000);
389 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
Stefan Holmere5904162015-03-26 10:11:06390 EXPECT_EQ(110000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47391
392 controller_->SetReservedBitrate(0);
393 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
Stefan Holmere5904162015-03-26 10:11:06394 EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47395 controller_->SetReservedBitrate(50000);
396 bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
stefan@webrtc.org792f1a12015-03-04 12:24:26397 // Limited by min bitrate.
Stefan Holmere5904162015-03-26 10:11:06398 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
solenberg@webrtc.org4e656022014-03-26 14:32:47399
400 controller_->SetReservedBitrate(10000);
stefan@webrtc.org792f1a12015-03-04 12:24:26401 bandwidth_observer_->OnReceivedEstimatedBitrate(1);
Stefan Holmere5904162015-03-26 10:11:06402 EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
henrik.lundin@webrtc.org29dd0de2013-10-21 14:00:01403}
Stefan Holmer52200d02016-09-20 12:14:23404
405TEST_F(BitrateControllerTest, TimeoutsWithoutFeedback) {
406 {
407 webrtc::test::ScopedFieldTrials override_field_trials(
Stefan Holmerdb158f92016-10-13 00:11:51408 "WebRTC-FeedbackTimeout/Enabled/");
Stefan Holmer52200d02016-09-20 12:14:23409 SetUp();
410 int expected_bitrate_bps = 300000;
411 controller_->SetBitrates(300000, kDefaultMinBitrateBps,
412 kDefaultMaxBitrateBps);
413
414 webrtc::ReportBlockList report_blocks;
415 report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
416 bandwidth_observer_->OnReceivedRtcpReceiverReport(
417 report_blocks, 50, clock_.TimeInMilliseconds());
418 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
419 clock_.AdvanceTimeMilliseconds(500);
420
421 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
422 bandwidth_observer_->OnReceivedRtcpReceiverReport(
423 report_blocks, 50, clock_.TimeInMilliseconds());
424 report_blocks.clear();
425 expected_bitrate_bps = expected_bitrate_bps * 1.08 + 1000;
426 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
427 clock_.AdvanceTimeMilliseconds(1500);
428
429 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
430 bandwidth_observer_->OnReceivedRtcpReceiverReport(
431 report_blocks, 50, clock_.TimeInMilliseconds());
432 expected_bitrate_bps = expected_bitrate_bps * 1.08 + 1000;
433 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
stefan5cb19822017-06-16 14:47:00434 clock_.AdvanceTimeMilliseconds(4000);
Stefan Holmer52200d02016-09-20 12:14:23435
stefan5cb19822017-06-16 14:47:00436 // 4 seconds since feedback, expect increase.
Stefan Holmer52200d02016-09-20 12:14:23437 controller_->Process();
438 expected_bitrate_bps = expected_bitrate_bps * 1.08 + 1000;
439 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
stefan5cb19822017-06-16 14:47:00440 clock_.AdvanceTimeMilliseconds(2000);
Stefan Holmer52200d02016-09-20 12:14:23441
stefan5cb19822017-06-16 14:47:00442 // 6 seconds since feedback, expect no increase.
Stefan Holmer52200d02016-09-20 12:14:23443 controller_->Process();
444 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
stefan5cb19822017-06-16 14:47:00445 clock_.AdvanceTimeMilliseconds(9001);
Stefan Holmer52200d02016-09-20 12:14:23446
stefan5cb19822017-06-16 14:47:00447 // More than 15 seconds since feedback, expect decrease.
Stefan Holmer52200d02016-09-20 12:14:23448 controller_->Process();
449 expected_bitrate_bps *= 0.8;
450 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
451 clock_.AdvanceTimeMilliseconds(500);
452
453 // Only one timeout every second.
454 controller_->Process();
455 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
456 clock_.AdvanceTimeMilliseconds(501);
457
458 // New timeout allowed.
459 controller_->Process();
460 expected_bitrate_bps *= 0.8;
461 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
462 }
463}
464
465TEST_F(BitrateControllerTest, StopIncreaseWithoutPacketReports) {
466 int expected_bitrate_bps = 300000;
467 controller_->SetBitrates(300000, kDefaultMinBitrateBps,
468 kDefaultMaxBitrateBps);
469
470 webrtc::ReportBlockList report_blocks;
471 report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
472 bandwidth_observer_->OnReceivedRtcpReceiverReport(
473 report_blocks, 50, clock_.TimeInMilliseconds());
474 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
475 clock_.AdvanceTimeMilliseconds(500);
476
477 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
478 bandwidth_observer_->OnReceivedRtcpReceiverReport(
479 report_blocks, 50, clock_.TimeInMilliseconds());
480 report_blocks.clear();
481 expected_bitrate_bps = expected_bitrate_bps * 1.08 + 1000;
482 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
483 clock_.AdvanceTimeMilliseconds(1500);
484
485 // 1.2 seconds without packets reported as received, no increase.
486 report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
487 bandwidth_observer_->OnReceivedRtcpReceiverReport(
488 report_blocks, 50, clock_.TimeInMilliseconds());
489 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
490 clock_.AdvanceTimeMilliseconds(1000);
491
492 // 5 packets reported as received since last, too few, no increase.
493 report_blocks.push_back(CreateReportBlock(1, 2, 0, 26));
494 bandwidth_observer_->OnReceivedRtcpReceiverReport(
495 report_blocks, 50, clock_.TimeInMilliseconds());
496 report_blocks.clear();
497 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
498 clock_.AdvanceTimeMilliseconds(100);
499
500 // 15 packets reported as received since last, enough to increase.
501 report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
502 bandwidth_observer_->OnReceivedRtcpReceiverReport(
503 report_blocks, 50, clock_.TimeInMilliseconds());
504 expected_bitrate_bps = expected_bitrate_bps * 1.08 + 1000;
505 EXPECT_EQ(expected_bitrate_bps, bitrate_observer_.last_bitrate_);
506 clock_.AdvanceTimeMilliseconds(1000);
507}