e30c272051
Revert due to crbug/609816. Investigation is ongoing. This reverts commit 28a44564c93b12839618dc0da2e2541ec6a0db23. (https://codereview.webrtc.org/1947873002/) TBR=stefan@webrtc.org, ivoc@webrtc.org, BUG=609816, webrtc:5687 Review-Url: https://codereview.webrtc.org/1958053002 Cr-Commit-Position: refs/heads/master@{#12663}
402 lines
16 KiB
C++
402 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
|
|
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
|
|
|
|
using webrtc::RtcpBandwidthObserver;
|
|
using webrtc::BitrateObserver;
|
|
using webrtc::BitrateController;
|
|
|
|
uint8_t WeightedLoss(int num_packets1, uint8_t fraction_loss1,
|
|
int num_packets2, uint8_t fraction_loss2) {
|
|
int weighted_sum = num_packets1 * fraction_loss1 +
|
|
num_packets2 * fraction_loss2;
|
|
int total_num_packets = num_packets1 + num_packets2;
|
|
return (weighted_sum + total_num_packets / 2) / total_num_packets;
|
|
}
|
|
|
|
webrtc::RTCPReportBlock CreateReportBlock(
|
|
uint32_t remote_ssrc, uint32_t source_ssrc,
|
|
uint8_t fraction_lost, uint32_t extended_high_sequence_number) {
|
|
return webrtc::RTCPReportBlock(remote_ssrc, source_ssrc, fraction_lost, 0,
|
|
extended_high_sequence_number, 0, 0, 0);
|
|
}
|
|
|
|
class TestBitrateObserver: public BitrateObserver {
|
|
public:
|
|
TestBitrateObserver()
|
|
: last_bitrate_(0),
|
|
last_fraction_loss_(0),
|
|
last_rtt_(0) {
|
|
}
|
|
|
|
virtual void OnNetworkChanged(uint32_t bitrate,
|
|
uint8_t fraction_loss,
|
|
int64_t rtt) {
|
|
last_bitrate_ = static_cast<int>(bitrate);
|
|
last_fraction_loss_ = fraction_loss;
|
|
last_rtt_ = rtt;
|
|
}
|
|
int last_bitrate_;
|
|
uint8_t last_fraction_loss_;
|
|
int64_t last_rtt_;
|
|
};
|
|
|
|
class BitrateControllerTest : public ::testing::Test {
|
|
protected:
|
|
BitrateControllerTest() : clock_(0) {}
|
|
~BitrateControllerTest() {}
|
|
|
|
virtual void SetUp() {
|
|
controller_ =
|
|
BitrateController::CreateBitrateController(&clock_, &bitrate_observer_);
|
|
controller_->SetStartBitrate(kStartBitrateBps);
|
|
EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
|
|
controller_->SetMinMaxBitrate(kMinBitrateBps, kMaxBitrateBps);
|
|
EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
|
|
bandwidth_observer_ = controller_->CreateRtcpBandwidthObserver();
|
|
}
|
|
|
|
virtual void TearDown() {
|
|
delete bandwidth_observer_;
|
|
delete controller_;
|
|
}
|
|
|
|
const int kMinBitrateBps = 100000;
|
|
const int kStartBitrateBps = 200000;
|
|
const int kMaxBitrateBps = 300000;
|
|
|
|
const int kDefaultMinBitrateBps = 10000;
|
|
const int kDefaultMaxBitrateBps = 1000000000;
|
|
|
|
webrtc::SimulatedClock clock_;
|
|
TestBitrateObserver bitrate_observer_;
|
|
BitrateController* controller_;
|
|
RtcpBandwidthObserver* bandwidth_observer_;
|
|
};
|
|
|
|
TEST_F(BitrateControllerTest, DefaultMinMaxBitrate) {
|
|
// Receive successively lower REMBs, verify the reserved bitrate is deducted.
|
|
controller_->SetMinMaxBitrate(0, 0);
|
|
EXPECT_EQ(kStartBitrateBps, bitrate_observer_.last_bitrate_);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(kDefaultMinBitrateBps / 2);
|
|
EXPECT_EQ(kDefaultMinBitrateBps, bitrate_observer_.last_bitrate_);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(2 * kDefaultMaxBitrateBps);
|
|
clock_.AdvanceTimeMilliseconds(1000);
|
|
controller_->Process();
|
|
EXPECT_EQ(kDefaultMaxBitrateBps, bitrate_observer_.last_bitrate_);
|
|
}
|
|
|
|
TEST_F(BitrateControllerTest, OneBitrateObserverOneRtcpObserver) {
|
|
// First REMB applies immediately.
|
|
int64_t time_ms = 1001;
|
|
webrtc::ReportBlockList report_blocks;
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
|
|
EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_rtt_);
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
report_blocks.clear();
|
|
time_ms += 2000;
|
|
|
|
// Receive a high remb, test bitrate inc.
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
|
|
|
|
// Test bitrate increase 8% per second.
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 61));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 81));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 801));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
// Reach max cap.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 101));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 141));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
|
|
|
|
// Test that a low delay-based estimate limits the combined estimate.
|
|
controller_->UpdateDelayBasedEstimate(280000);
|
|
EXPECT_EQ(280000, bitrate_observer_.last_bitrate_);
|
|
|
|
// Test that a low REMB limits the combined estimate.
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
|
|
EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
|
|
EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
|
|
}
|
|
|
|
TEST_F(BitrateControllerTest, OneBitrateObserverTwoRtcpObservers) {
|
|
// REMBs during the first 2 seconds apply immediately.
|
|
int64_t time_ms = 1;
|
|
webrtc::ReportBlockList report_blocks;
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 1));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
report_blocks.clear();
|
|
time_ms += 500;
|
|
|
|
RtcpBandwidthObserver* second_bandwidth_observer =
|
|
controller_->CreateRtcpBandwidthObserver();
|
|
|
|
// Test start bitrate.
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 100, 1);
|
|
EXPECT_EQ(217000, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(100, bitrate_observer_.last_rtt_);
|
|
time_ms += 500;
|
|
|
|
// Test bitrate increase 8% per second.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 21));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
time_ms += 500;
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 100, time_ms);
|
|
EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(100, bitrate_observer_.last_rtt_);
|
|
time_ms += 500;
|
|
|
|
// Extra report should not change estimate.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 31));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 100, time_ms);
|
|
EXPECT_EQ(235360, bitrate_observer_.last_bitrate_);
|
|
time_ms += 500;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
|
|
|
|
// Second report should not change estimate.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 41));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 100, time_ms);
|
|
EXPECT_EQ(255189, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
// Reports from only one bandwidth observer is ok.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 61));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 50, time_ms);
|
|
EXPECT_EQ(276604, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 81));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 50, time_ms);
|
|
EXPECT_EQ(299732, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
// Reach max cap.
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 121));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 50, time_ms);
|
|
EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
|
|
time_ms += 1000;
|
|
|
|
report_blocks.clear();
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, 141));
|
|
second_bandwidth_observer->OnReceivedRtcpReceiverReport(
|
|
report_blocks, 50, time_ms);
|
|
EXPECT_EQ(300000, bitrate_observer_.last_bitrate_);
|
|
|
|
// Test that a low REMB trigger immediately.
|
|
// We don't care which bandwidth observer that delivers the REMB.
|
|
second_bandwidth_observer->OnReceivedEstimatedBitrate(250000);
|
|
EXPECT_EQ(250000, bitrate_observer_.last_bitrate_);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
|
|
// Min cap.
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(1000);
|
|
EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
|
|
delete second_bandwidth_observer;
|
|
}
|
|
|
|
TEST_F(BitrateControllerTest, OneBitrateObserverMultipleReportBlocks) {
|
|
uint32_t sequence_number[2] = {0, 0xFF00};
|
|
const int kStartBitrate = 200000;
|
|
const int kMinBitrate = 100000;
|
|
const int kMaxBitrate = 300000;
|
|
controller_->SetStartBitrate(kStartBitrate);
|
|
controller_->SetMinMaxBitrate(kMinBitrate, kMaxBitrate);
|
|
|
|
// REMBs during the first 2 seconds apply immediately.
|
|
int64_t time_ms = 1001;
|
|
webrtc::ReportBlockList report_blocks;
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(kStartBitrate);
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
report_blocks.clear();
|
|
time_ms += 2000;
|
|
|
|
// Receive a high REMB, test bitrate increase.
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
|
|
|
|
int last_bitrate = 0;
|
|
// Ramp up to max bitrate.
|
|
for (int i = 0; i < 6; ++i) {
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
|
|
report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50,
|
|
time_ms);
|
|
EXPECT_GT(bitrate_observer_.last_bitrate_, last_bitrate);
|
|
EXPECT_EQ(0, bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
last_bitrate = bitrate_observer_.last_bitrate_;
|
|
time_ms += 1000;
|
|
sequence_number[0] += 20;
|
|
sequence_number[1] += 1;
|
|
report_blocks.clear();
|
|
}
|
|
|
|
EXPECT_EQ(kMaxBitrate, bitrate_observer_.last_bitrate_);
|
|
|
|
// Packet loss on the first stream. Verify that bitrate decreases.
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 50, sequence_number[0]));
|
|
report_blocks.push_back(CreateReportBlock(1, 3, 0, sequence_number[1]));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
|
|
EXPECT_EQ(WeightedLoss(20, 50, 1, 0), bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
last_bitrate = bitrate_observer_.last_bitrate_;
|
|
sequence_number[0] += 20;
|
|
sequence_number[1] += 20;
|
|
time_ms += 1000;
|
|
report_blocks.clear();
|
|
|
|
// Packet loss on the second stream. Verify that bitrate decreases.
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 0, sequence_number[0]));
|
|
report_blocks.push_back(CreateReportBlock(1, 3, 75, sequence_number[1]));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_LT(bitrate_observer_.last_bitrate_, last_bitrate);
|
|
EXPECT_EQ(WeightedLoss(20, 0, 20, 75), bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
last_bitrate = bitrate_observer_.last_bitrate_;
|
|
sequence_number[0] += 20;
|
|
sequence_number[1] += 1;
|
|
time_ms += 1000;
|
|
report_blocks.clear();
|
|
|
|
// All packets lost on stream with few packets, no back-off.
|
|
report_blocks.push_back(CreateReportBlock(1, 2, 1, sequence_number[0]));
|
|
report_blocks.push_back(CreateReportBlock(1, 3, 255, sequence_number[1]));
|
|
bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, 50, time_ms);
|
|
EXPECT_EQ(bitrate_observer_.last_bitrate_, last_bitrate);
|
|
EXPECT_EQ(WeightedLoss(20, 1, 1, 255), bitrate_observer_.last_fraction_loss_);
|
|
EXPECT_EQ(50, bitrate_observer_.last_rtt_);
|
|
last_bitrate = bitrate_observer_.last_bitrate_;
|
|
sequence_number[0] += 20;
|
|
sequence_number[1] += 1;
|
|
report_blocks.clear();
|
|
}
|
|
|
|
TEST_F(BitrateControllerTest, SetReservedBitrate) {
|
|
// Receive successively lower REMBs, verify the reserved bitrate is deducted.
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
|
|
EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(50000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(400000);
|
|
EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
|
|
EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(50000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(250000);
|
|
EXPECT_EQ(150000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
|
|
EXPECT_EQ(200000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(30000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(200000);
|
|
EXPECT_EQ(170000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
|
|
EXPECT_EQ(160000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(30000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(160000);
|
|
EXPECT_EQ(130000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
|
|
EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(10000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
|
|
EXPECT_EQ(110000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(0);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
|
|
EXPECT_EQ(120000, bitrate_observer_.last_bitrate_);
|
|
controller_->SetReservedBitrate(50000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(120000);
|
|
// Limited by min bitrate.
|
|
EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
|
|
|
|
controller_->SetReservedBitrate(10000);
|
|
bandwidth_observer_->OnReceivedEstimatedBitrate(1);
|
|
EXPECT_EQ(100000, bitrate_observer_.last_bitrate_);
|
|
}
|