mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Propagating total_bitrate_bps from BitrateAllocator to ProbeController, part 1.

Browse source 
Added total_bitrate_bps to LimitObserver::OnAllocationLimitsChanged.

Bug: webrtc:8955
Change-Id: Ied9b2d24ab97cff21518ce70d5d35dfd8230ed08
Reviewed-on: https://webrtc-review.googlesource.com/58801
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22233}
This commit is contained in:
philipel 2018-02-28 13:06:28 +01:00 committed by Philip Eliasson
parent 27e8a3e223
commit f69e768032
5 changed files with 61 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
audio/audio_send_stream_unittest.cc
View file

@ -75,9 +75,10 @@ const AudioCodecSpec kCodecSpecs[] = {
class MockLimitObserver : public BitrateAllocator::LimitObserver { class MockLimitObserver : public BitrateAllocator::LimitObserver {
public: public:
MOCK_METHOD2(OnAllocationLimitsChanged, MOCK_METHOD3(OnAllocationLimitsChanged,
void(uint32_t min_send_bitrate_bps, void(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps)); uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps));
}; };
std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock( std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(

5
call/bitrate_allocator.cc
View file

@ -179,6 +179,7 @@ void BitrateAllocator::UpdateAllocationLimits() {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
uint32_t total_requested_padding_bitrate = 0; uint32_t total_requested_padding_bitrate = 0;
uint32_t total_requested_min_bitrate = 0; uint32_t total_requested_min_bitrate = 0;
uint32_t total_requested_bitrate = 0;
for (const auto& config : bitrate_observer_configs_) { for (const auto& config : bitrate_observer_configs_) {
uint32_t stream_padding = config.pad_up_bitrate_bps; uint32_t stream_padding = config.pad_up_bitrate_bps;
@ -189,6 +190,7 @@ void BitrateAllocator::UpdateAllocationLimits() {
std::max(config.MinBitrateWithHysteresis(), stream_padding); std::max(config.MinBitrateWithHysteresis(), stream_padding);
} }
total_requested_padding_bitrate += stream_padding; total_requested_padding_bitrate += stream_padding;
total_requested_bitrate += config.max_bitrate_bps;
} }
if (total_requested_padding_bitrate == total_requested_padding_bitrate_ && if (total_requested_padding_bitrate == total_requested_padding_bitrate_ &&
@ -204,7 +206,8 @@ void BitrateAllocator::UpdateAllocationLimits() {
<< "bps, total_requested_padding_bitrate: " << "bps, total_requested_padding_bitrate: "
<< total_requested_padding_bitrate << "bps"; << total_requested_padding_bitrate << "bps";
limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate, limit_observer_->OnAllocationLimitsChanged(total_requested_min_bitrate,
total_requested_padding_bitrate); total_requested_padding_bitrate,
total_requested_bitrate);
} }
void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) { void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) {

6
call/bitrate_allocator.h
View file

@ -52,9 +52,9 @@ class BitrateAllocator {
// bitrate and max padding bitrate is changed. // bitrate and max padding bitrate is changed.
class LimitObserver { class LimitObserver {
public: public:
virtual void OnAllocationLimitsChanged( virtual void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t min_send_bitrate_bps, uint32_t max_padding_bitrate_bps,
uint32_t max_padding_bitrate_bps) = 0; uint32_t total_bitrate_bps) = 0;
protected: protected:
virtual ~LimitObserver() {} virtual ~LimitObserver() {}

75
call/bitrate_allocator_unittest.cc
View file

@ -24,9 +24,10 @@ namespace webrtc {
class MockLimitObserver : public BitrateAllocator::LimitObserver { class MockLimitObserver : public BitrateAllocator::LimitObserver {
public: public:
MOCK_METHOD2(OnAllocationLimitsChanged, MOCK_METHOD3(OnAllocationLimitsChanged,
void(uint32_t min_send_bitrate_bps, void(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps)); uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps));
}; };
class TestBitrateObserver : public BitrateAllocatorObserver { class TestBitrateObserver : public BitrateAllocatorObserver {
@ -79,10 +80,12 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
TestBitrateObserver bitrate_observer; TestBitrateObserver bitrate_observer;
const uint32_t kMinSendBitrateBps = 100000; const uint32_t kMinSendBitrateBps = 100000;
const uint32_t kPadUpToBitrateBps = 50000; const uint32_t kPadUpToBitrateBps = 50000;
const uint32_t kMaxBitrateBps = 1500000;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, EXPECT_CALL(limit_observer_,
kPadUpToBitrateBps)); OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, kMaxBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kPadUpToBitrateBps, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
@ -96,36 +99,49 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated. // Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
EXPECT_CALL(limit_observer_, EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0)); OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
true, "", kDefaultBitratePriority); true, "", kDefaultBitratePriority);
EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, 0, allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
true, "", kDefaultBitratePriority); 0, true, "", kDefaultBitratePriority);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_); EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(1500000, 0, 0, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_); EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
} }
TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) { TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(100000, 0)); const uint32_t kObs1StartBitrateBps = 100000;
allocator_->AddObserver(&bitrate_observer_1, 100000, 300000, 0, true, "", const uint32_t kObs2StartBitrateBps = 200000;
const uint32_t kObs1MaxBitrateBps = 300000;
const uint32_t kObs2MaxBitrateBps = 300000;
EXPECT_CALL(
limit_observer_,
OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps));
allocator_->AddObserver(&bitrate_observer_1, kObs1StartBitrateBps,
kObs1MaxBitrateBps, 0, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
EXPECT_CALL(limit_observer_, allocator_->GetStartBitrate(&bitrate_observer_1));
OnAllocationLimitsChanged(100000 + 200000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
allocator_->AddObserver(&bitrate_observer_2, 200000, 300000, 0, true, "", kObs1StartBitrateBps + kObs2StartBitrateBps,
0, kObs1MaxBitrateBps + kObs2MaxBitrateBps));
allocator_->AddObserver(&bitrate_observer_2, kObs2StartBitrateBps,
kObs2MaxBitrateBps, 0, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2)); EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
allocator_->GetStartBitrate(&bitrate_observer_2));
// Test too low start bitrate, hence lower than sum of min. Min bitrates // Test too low start bitrate, hence lower than sum of min. Min bitrates
// will // will
// be allocated to all observers. // be allocated to all observers.
allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(kObs2StartBitrateBps, 0, 50,
kDefaultProbingIntervalMs);
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_); EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_); EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
@ -135,7 +151,8 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
// Test a bitrate which should be distributed equally. // Test a bitrate which should be distributed equally.
allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs);
const uint32_t kBitrateToShare = 500000 - 200000 - 100000; const uint32_t kBitrateToShare =
500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
EXPECT_EQ(100000u + kBitrateToShare / 2, EXPECT_EQ(100000u + kBitrateToShare / 2,
bitrate_observer_1.last_bitrate_bps_); bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u + kBitrateToShare / 2, EXPECT_EQ(200000u + kBitrateToShare / 2,
@ -159,13 +176,15 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
TestBitrateObserver bitrate_observer; TestBitrateObserver bitrate_observer;
const uint32_t kMinSendBitrateBps = 100000; const uint32_t kMinSendBitrateBps = 100000;
const uint32_t kPadUpToBitrateBps = 50000; const uint32_t kPadUpToBitrateBps = 50000;
const uint32_t kMaxBitrateBps = 1500000;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(kMinSendBitrateBps, EXPECT_CALL(limit_observer_,
kPadUpToBitrateBps)); OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 1500000, kMaxBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kPadUpToBitrateBps, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer); allocator_->RemoveObserver(&bitrate_observer);
} }
@ -187,7 +206,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
// Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
// AddObserver is called with |enforce_min_bitrate| = false. // AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000, _));
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "", allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
@ -200,7 +219,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs); allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer_1); allocator_->RemoveObserver(&bitrate_observer_1);
} }
@ -272,7 +291,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
TestBitrateObserver bitrate_observer; TestBitrateObserver bitrate_observer;
// Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since // Expect OnAllocationLimitsChanged with |min_send_bitrate_bps| = 0 since
// AddObserver is called with |enforce_min_bitrate| = false. // AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000, _));
allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "", allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "",
kDefaultBitratePriority); kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer)); EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
@ -300,7 +319,7 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_); EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
// Just enough to enable video again. // Just enough to enable video again.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->OnNetworkChanged(168000, 0, fraction_loss, allocator_->OnNetworkChanged(168000, 0, fraction_loss,
kDefaultProbingIntervalMs); kDefaultProbingIntervalMs);
EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_); EXPECT_EQ(168000u, bitrate_observer.last_bitrate_bps_);
@ -402,7 +421,7 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) { TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_1; TestBitrateObserver bitrate_observer_1;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _));
allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "", allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);
@ -415,7 +434,7 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_2; TestBitrateObserver bitrate_observer_2;
// Adding an observer while the network is down should not affect the limits. // Adding an observer while the network is down should not affect the limits.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0)); EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _));
allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "", allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
kDefaultBitratePriority); kDefaultBitratePriority);

6
call/call.cc
View file

@ -233,7 +233,8 @@ class Call : public webrtc::Call,
// Implements BitrateAllocator::LimitObserver. // Implements BitrateAllocator::LimitObserver.
void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, void OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps) override; uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps) override;
private: private:
DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet, DeliveryStatus DeliverRtcp(MediaType media_type, const uint8_t* packet,
@ -1074,7 +1075,8 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
} }
void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps, void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps) { uint32_t max_padding_bitrate_bps,
uint32_t total_bitrate_bps) {
transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps, transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps,
max_padding_bitrate_bps); max_padding_bitrate_bps);
rtc::CritScope lock(&bitrate_crit_); rtc::CritScope lock(&bitrate_crit_);