zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moving the pacer and the pacer thread to ChannelGroup.

Browse Source 
This means all channels within the same group will share the same pacing queue and scheduler. It also means padding will be computed and sent by a single pacer. To accomplish this I also introduce a PacketRouter which finds the RTP module which owns the packet to be paced out.

BUG=4323
R=mflodman@webrtc.org, pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/45549004

Cr-Commit-Position: refs/heads/master@{#8864}
This commit is contained in:
Stefan Holmer
2015-03-26 11:11:06 +01:00
parent 5225dd8180
commit e590416722
47 changed files with 928 additions and 687 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
webrtc/modules/bitrate_controller/bitrate_allocator_unittest.cc
View File

@ -36,7 +36,9 @@ class TestBitrateObserver : public BitrateObserver {
class BitrateAllocatorTest : public ::testing::Test {
protected:
BitrateAllocatorTest() : allocator_(new BitrateAllocator()) {}
BitrateAllocatorTest() : allocator_(new BitrateAllocator()) {
allocator_->OnNetworkChanged(300000u, 0, 0);
}
~BitrateAllocatorTest() {}
rtc::scoped_ptr<BitrateAllocator> allocator_;
@ -44,15 +46,22 @@ class BitrateAllocatorTest : public ::testing::Test {
TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
TestBitrateObserver bitrate_observer;
allocator_->AddBitrateObserver(&bitrate_observer, 200000, 100000, 1500000);
int start_bitrate;
allocator_->AddBitrateObserver(&bitrate_observer, 200000, 100000, 1500000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
allocator_->OnNetworkChanged(200000, 0, 0);
EXPECT_EQ(200000u, bitrate_observer.last_bitrate_);
allocator_->AddBitrateObserver(&bitrate_observer, 1500000, 100000, 1500000);
allocator_->AddBitrateObserver(&bitrate_observer, 1500000, 100000, 1500000,
&start_bitrate);
EXPECT_EQ(1500000, start_bitrate);
allocator_->OnNetworkChanged(1500000, 0, 0);
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_);
allocator_->AddBitrateObserver(&bitrate_observer, 500000, 100000, 1500000);
allocator_->AddBitrateObserver(&bitrate_observer, 500000, 100000, 1500000,
&start_bitrate);
EXPECT_EQ(1500000, start_bitrate);
allocator_->OnNetworkChanged(1500000, 0, 0);
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_);
}
@ -60,8 +69,13 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 300000);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 300000);
int start_bitrate;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 300000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 300000,
&start_bitrate);
EXPECT_EQ(200000, start_bitrate);
// Test too low start bitrate, hence lower than sum of min. Min bitrates will
// be allocated to all observers.
@ -79,16 +93,17 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
EXPECT_EQ(100000u + kBitrateToShare / 2, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(200000u + kBitrateToShare / 2, bitrate_observer_2.last_bitrate_);
// Limited by max bitrates.
allocator_->OnNetworkChanged(800000, 0, 50);
EXPECT_EQ(300000u, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_);
// Limited by 2x max bitrates since we leave room for FEC and retransmissions.
allocator_->OnNetworkChanged(1500000, 0, 50);
EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_);
}
class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
protected:
BitrateAllocatorTestNoEnforceMin() : allocator_(new BitrateAllocator()) {
allocator_->EnforceMinBitrate(false);
allocator_->OnNetworkChanged(300000u, 0, 0);
}
~BitrateAllocatorTestNoEnforceMin() {}
@ -99,7 +114,10 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
// as intended.
TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
TestBitrateObserver bitrate_observer_1;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 400000);
int start_bitrate;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 400000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
// High REMB.
allocator_->OnNetworkChanged(150000, 0, 0);
@ -117,21 +135,31 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3;
// Set up the observers with min bitrates at 100000, 200000, and 300000.
// Note: The start bitrate of bitrate_observer_1 (700000) is used as the
// overall start bitrate.
allocator_->AddBitrateObserver(&bitrate_observer_1, 700000, 100000, 400000);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 400000);
allocator_->AddBitrateObserver(&bitrate_observer_3, 200000, 300000, 400000);
int start_bitrate;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 400000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 400000,
&start_bitrate);
EXPECT_EQ(200000, start_bitrate);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_);
allocator_->AddBitrateObserver(&bitrate_observer_3, 200000, 300000, 400000,
&start_bitrate);
EXPECT_EQ(0, start_bitrate);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_);
// High REMB. Make sure the controllers get a fair share of the surplus
// (i.e., what is left after each controller gets its min rate).
allocator_->OnNetworkChanged(690000, 0, 0);
// Verify that each observer gets its min rate (sum of min rates is 600000),
// and that the remaining 90000 is divided equally among the three.
const uint32_t kBitrateToShare = 690000u - 100000u - 200000u - 300000u;
EXPECT_EQ(100000u + kBitrateToShare / 3, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(200000u + kBitrateToShare / 3, bitrate_observer_2.last_bitrate_);
EXPECT_EQ(300000u + kBitrateToShare / 3, bitrate_observer_3.last_bitrate_);
uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
EXPECT_EQ(100000u + bitrate_to_share / 3, bitrate_observer_1.last_bitrate_);
EXPECT_EQ(200000u + bitrate_to_share / 3, bitrate_observer_2.last_bitrate_);
EXPECT_EQ(300000u + bitrate_to_share / 3, bitrate_observer_3.last_bitrate_);
// High REMB, but below the sum of min bitrates.
allocator_->OnNetworkChanged(500000, 0, 0);
@ -153,23 +181,25 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
allocator_->RemoveBitrateObserver(&bitrate_observer_3);
}
TEST_F(BitrateAllocatorTestNoEnforceMin, Honors10KbpsLimit) {
TestBitrateObserver bitrate_observer;
allocator_->AddBitrateObserver(&bitrate_observer, 700000, 30000, 400000);
int min_bitrate = 0;
int max_bitrate = 0;
allocator_->GetMinMaxBitrateSumBps(&min_bitrate, &max_bitrate);
EXPECT_EQ(10000, min_bitrate);
}
TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowRembEnforceMin) {
TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 300000);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 300000);
allocator_->AddBitrateObserver(&bitrate_observer_3, 200000, 300000, 300000);
int start_bitrate;
allocator_->AddBitrateObserver(&bitrate_observer_1, 200000, 100000, 400000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
allocator_->AddBitrateObserver(&bitrate_observer_2, 200000, 200000, 400000,
&start_bitrate);
EXPECT_EQ(200000, start_bitrate);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_);
allocator_->AddBitrateObserver(&bitrate_observer_3, 200000, 300000, 400000,
&start_bitrate);
EXPECT_EQ(300000, start_bitrate);
EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_));
EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_));
// Low REMB. Verify that all observers still get their respective min bitrate.
allocator_->OnNetworkChanged(1000, 0, 0);