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

Uses config struct with bitrate allocator.

Browse source 
This makes it easier to refactor the interface in upcoming CLs.

Bug: None
Change-Id: I67d0216e24f087294e95ac96f7278f302bf69832
Reviewed-on: https://webrtc-review.googlesource.com/71041
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22933}
This commit is contained in:
Sebastian Jansson 2018-04-19 08:25:12 +02:00 committed by Commit Bot
parent 629a97339b
commit 24ad720885
5 changed files with 162 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
audio/audio_send_stream.cc
View file

@ -708,9 +708,11 @@ void AudioSendStream::ConfigureBitrateObserver(int min_bitrate_bps,
config_.max_bitrate_bps = max_bitrate_bps;
config_.bitrate_priority = bitrate_priority;
// This either updates the current observer or adds a new observer.
bitrate_allocator_->AddObserver(this, min_bitrate_bps, max_bitrate_bps, 0,
true, config_.track_id, bitrate_priority,
has_packet_feedback);
bitrate_allocator_->AddObserver(
this, MediaStreamAllocationConfig{
static_cast<uint32_t>(min_bitrate_bps),
static_cast<uint32_t>(max_bitrate_bps), 0, true,
config_.track_id, bitrate_priority, has_packet_feedback});
thread_sync_event.Set();
});
thread_sync_event.Wait(rtc::Event::kForever);

27
call/bitrate_allocator.cc
View file

@ -142,29 +142,24 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
}
void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer,
uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority,
bool has_packet_feedback) {
MediaStreamAllocationConfig config) {
RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_);
RTC_DCHECK_GT(bitrate_priority, 0);
RTC_DCHECK(std::isnormal(bitrate_priority));
RTC_DCHECK_GT(config.bitrate_priority, 0);
RTC_DCHECK(std::isnormal(config.bitrate_priority));
auto it = FindObserverConfig(observer);
// Update settings if the observer already exists, create a new one otherwise.
if (it != bitrate_observer_configs_.end()) {
it->min_bitrate_bps = min_bitrate_bps;
it->max_bitrate_bps = max_bitrate_bps;
it->pad_up_bitrate_bps = pad_up_bitrate_bps;
it->enforce_min_bitrate = enforce_min_bitrate;
it->bitrate_priority = bitrate_priority;
it->min_bitrate_bps = config.min_bitrate_bps;
it->max_bitrate_bps = config.max_bitrate_bps;
it->pad_up_bitrate_bps = config.pad_up_bitrate_bps;
it->enforce_min_bitrate = config.enforce_min_bitrate;
it->bitrate_priority = config.bitrate_priority;
} else {
bitrate_observer_configs_.push_back(ObserverConfig(
observer, min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
enforce_min_bitrate, track_id, bitrate_priority, has_packet_feedback));
observer, config.min_bitrate_bps, config.max_bitrate_bps,
config.pad_up_bitrate_bps, config.enforce_min_bitrate, config.track_id,
config.bitrate_priority, config.has_packet_feedback));
}
ObserverAllocation allocation;

48
call/bitrate_allocator.h
View file

@ -43,6 +43,30 @@ class BitrateAllocatorObserver {
virtual ~BitrateAllocatorObserver() {}
};
// Struct describing parameters for how a media stream should get bitrate
// allocated to it. |min_bitrate_bps| = 0 equals no min bitrate.
// |max_bitrate_bps| = 0 equals no max bitrate.
// |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
// this observer, even if the BWE is too low, 'false' will allocate 0 to
// the observer if BWE doesn't allow |min_bitrate_bps|.
// |has_packet_feedback| indicates whether the data produced by the
// corresponding media stream will receive per packet feedback. This is
// tracked here to communicate to limit observers whether packet feedback can
// be expected, which is true if any of the active observers has packet
// feedback enabled. Note that |observer|->OnBitrateUpdated() will be called
// within the scope of this method with the current rtt, fraction_loss and
// available bitrate and that the bitrate in OnBitrateUpdated will be zero if
// the |observer| is currently not allowed to send data.
struct MediaStreamAllocationConfig {
uint32_t min_bitrate_bps;
uint32_t max_bitrate_bps;
uint32_t pad_up_bitrate_bps;
bool enforce_min_bitrate;
std::string track_id;
double bitrate_priority;
bool has_packet_feedback;
};
// Usage: this class will register multiple RtcpBitrateObserver's one at each
// RTCP module. It will aggregate the results and run one bandwidth estimation
// and push the result to the encoders via BitrateAllocatorObserver(s).
@ -71,30 +95,10 @@ class BitrateAllocator {
int64_t bwe_period_ms);
// Set the configuration used by the bandwidth management.
//
// |observer| updates bitrates if already in use.
// |min_bitrate_bps| = 0 equals no min bitrate.
// |max_bitrate_bps| = 0 equals no max bitrate.
// |enforce_min_bitrate| = 'true' will allocate at least |min_bitrate_bps| for
// this observer, even if the BWE is too low, 'false' will allocate 0 to
// the observer if BWE doesn't allow |min_bitrate_bps|.
// |has_packet_feedback| indicates whether the data produced by the
// corresponding media stream will receive per packet feedback. This is
// tracked here to communicate to limit observers whether packet feedback can
// be expected, which is true if any of the active observers has packet
// feedback enabled. Note that |observer|->OnBitrateUpdated() will be called
// within the scope of this method with the current rtt, fraction_loss and
// available bitrate and that the bitrate in OnBitrateUpdated will be zero if
// the |observer| is currently not allowed to send data.
// |config| is the configuration to use for allocation.
void AddObserver(BitrateAllocatorObserver* observer,
uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority,
// TODO(srte): Remove default when callers have been fixed.
bool has_packet_feedback = false);
MediaStreamAllocationConfig config);
// Removes a previously added observer, but will not trigger a new bitrate
// allocation.

190
call/bitrate_allocator_unittest.cc
View file

@ -86,6 +86,17 @@ class BitrateAllocatorTest : public ::testing::Test {
allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
}
~BitrateAllocatorTest() {}
void AddObserver(BitrateAllocatorObserver* observer,
uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
enforce_min_bitrate, track_id, bitrate_priority, false});
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocator> allocator_;
@ -100,9 +111,8 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
kMaxBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
@ -115,14 +125,14 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0,
true, "", kDefaultBitratePriority);
AddObserver(&bitrate_observer, kMinSendBitrateBps, 4000000, 0, true, "",
kDefaultBitratePriority);
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, 0, _));
EXPECT_EQ(4000000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
0, true, "", kDefaultBitratePriority);
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps, 0, true,
"", kDefaultBitratePriority);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
@ -140,17 +150,15 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
EXPECT_CALL(
limit_observer_,
OnAllocationLimitsChanged(kObs1StartBitrateBps, 0, kObs1MaxBitrateBps));
allocator_->AddObserver(&bitrate_observer_1, kObs1StartBitrateBps,
kObs1MaxBitrateBps, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, kObs1StartBitrateBps, kObs1MaxBitrateBps, 0,
true, "", kDefaultBitratePriority);
EXPECT_EQ(static_cast<int>(kObs1MaxBitrateBps),
allocator_->GetStartBitrate(&bitrate_observer_1));
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
kObs1StartBitrateBps + kObs2StartBitrateBps,
0, kObs1MaxBitrateBps + kObs2MaxBitrateBps));
allocator_->AddObserver(&bitrate_observer_2, kObs2StartBitrateBps,
kObs2MaxBitrateBps, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_2, kObs2StartBitrateBps, kObs2MaxBitrateBps, 0,
true, "", kDefaultBitratePriority);
EXPECT_EQ(static_cast<int>(kObs2StartBitrateBps),
allocator_->GetStartBitrate(&bitrate_observer_2));
@ -198,9 +206,8 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(kMinSendBitrateBps, kPadUpToBitrateBps,
kMaxBitrateBps));
allocator_->AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, "", kDefaultBitratePriority);
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
allocator_->RemoveObserver(&bitrate_observer);
}
@ -212,7 +219,17 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
}
~BitrateAllocatorTestNoEnforceMin() {}
void AddObserver(BitrateAllocatorObserver* observer,
uint32_t min_bitrate_bps,
uint32_t max_bitrate_bps,
uint32_t pad_up_bitrate_bps,
bool enforce_min_bitrate,
std::string track_id,
double bitrate_priority) {
allocator_->AddObserver(
observer, {min_bitrate_bps, max_bitrate_bps, pad_up_bitrate_bps,
enforce_min_bitrate, track_id, bitrate_priority, false});
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocator> allocator_;
};
@ -225,8 +242,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
// AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 120000, _));
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// High BWE.
@ -246,17 +263,17 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3;
// Set up the observers with min bitrates at 100000, 200000, and 300000.
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_3, 300000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(0, allocator_->GetStartBitrate(&bitrate_observer_3));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
@ -311,8 +328,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
// AddObserver is called with |enforce_min_bitrate| = false.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 0, _));
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(0, 168000, _));
allocator_->AddObserver(&bitrate_observer, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
// High BWE.
@ -359,11 +376,11 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
TestBitrateObserver bitrate_observer_1;
TestBitrateObserver bitrate_observer_2;
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, 100000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_2, 200000, 400000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
@ -412,17 +429,17 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
TestBitrateObserver bitrate_observer_2;
TestBitrateObserver bitrate_observer_3;
allocator_->AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, 100000, 400000, 0, true, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
allocator_->AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_2, 200000, 400000, 0, true, "",
kDefaultBitratePriority);
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer_2));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
allocator_->AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_3, 300000, 400000, 0, true, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_3));
EXPECT_EQ(100000, static_cast<int>(bitrate_observer_1.last_bitrate_bps_));
EXPECT_EQ(200000, static_cast<int>(bitrate_observer_2.last_bitrate_bps_));
@ -443,8 +460,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_1;
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000, 0, _));
allocator_->AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_1, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// Set network down, ie, no available bitrate.
@ -455,8 +472,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TestBitrateObserver bitrate_observer_2;
// Adding an observer while the network is down should not affect the limits.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(50000 + 50000, 0, _));
allocator_->AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&bitrate_observer_2, 50000, 400000, 0, true, "",
kDefaultBitratePriority);
// Expect the start_bitrate to be set as if the network was still up but that
// the new observer have been notified that the network is down.
@ -472,13 +489,13 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TestBitrateObserver enforced_observer;
allocator_->AddObserver(&enforced_observer, 6000, 30000, 0, true, "",
kDefaultBitratePriority);
AddObserver(&enforced_observer, 6000, 30000, 0, true, "",
kDefaultBitratePriority);
EXPECT_EQ(60000, allocator_->GetStartBitrate(&enforced_observer));
TestBitrateObserver not_enforced_observer;
allocator_->AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&not_enforced_observer, 30000, 2500000, 0, false, "",
kDefaultBitratePriority);
EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
@ -516,8 +533,7 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TestBitrateObserver observer;
allocator_->AddObserver(&observer, 30000, 300000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&observer, 30000, 300000, 0, false, "", kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
@ -543,8 +559,7 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TestBitrateObserver observer;
allocator_->AddObserver(&observer, 300000, 600000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
@ -570,8 +585,7 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
TEST_F(BitrateAllocatorTest, PassProbingInterval) {
TestBitrateObserver observer;
allocator_->AddObserver(&observer, 300000, 600000, 0, false, "",
kDefaultBitratePriority);
AddObserver(&observer, 300000, 600000, 0, false, "", kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, 5000);
@ -586,8 +600,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 30;
allocator_->AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0,
true, "", 2.0);
AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, "",
2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -604,10 +618,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
const uint32_t kMinSendBitrateBps = 10;
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 60;
allocator_->AddObserver(&observer_low_1, kMinSendBitrateBps,
kMaxSendBitrateBps, 0, false, "low1", 2.0);
allocator_->AddObserver(&observer_low_2, kMinSendBitrateBps,
kMaxSendBitrateBps, 0, false, "low2", 2.0);
AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
"low1", 2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
"low2", 2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -626,10 +640,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
const uint32_t kMinSendBitrateBps = 0;
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = 60;
allocator_->AddObserver(&observer_low_1, kMinSendBitrateBps,
kMaxSendBitrateBps, 0, true, "low1", 2.0);
allocator_->AddObserver(&observer_low_2, kMinSendBitrateBps,
kMaxSendBitrateBps, 0, true, "low2", 2.0);
AddObserver(&observer_low_1, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low1", 2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low2", 2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -648,10 +662,10 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
const uint32_t kMinSendBitrateBps = 0;
const uint32_t kMaxSendBitrateBps = 60;
const uint32_t kNetworkBandwidthBps = kMaxSendBitrateBps * 2;
allocator_->AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps,
0, true, "low", 2.0);
allocator_->AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps,
0, true, "mid", 4.0);
AddObserver(&observer_low, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"low", 2.0);
AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
"mid", 4.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -668,8 +682,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
TestBitrateObserver observer_low;
TestBitrateObserver observer_mid;
allocator_->AddObserver(&observer_low, 10, 50, 0, false, "low", 2.0);
allocator_->AddObserver(&observer_mid, 10, 50, 0, false, "mid", 4.0);
AddObserver(&observer_low, 10, 50, 0, false, "low", 2.0);
AddObserver(&observer_mid, 10, 50, 0, false, "mid", 4.0);
allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
@ -694,12 +708,12 @@ TEST_F(BitrateAllocatorTest,
const double kHighBitratePriority = 8.0;
const double kTotalBitratePriority =
kLowBitratePriority + kMidBitratePriority + kHighBitratePriority;
allocator_->AddObserver(&observer_low, 0, kMaxBitrate, 0, false, "low",
kLowBitratePriority);
allocator_->AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, "mid",
kMidBitratePriority);
allocator_->AddObserver(&observer_high, 0, kMaxBitrate, 0, false, "high",
kHighBitratePriority);
AddObserver(&observer_low, 0, kMaxBitrate, 0, false, "low",
kLowBitratePriority);
AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, "mid",
kMidBitratePriority);
AddObserver(&observer_high, 0, kMaxBitrate, 0, false, "high",
kHighBitratePriority);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
@ -740,12 +754,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
const uint32_t kRemainingBitrate =
kAvailableBitrate - kMaxBitrate - (2 * kMinBitrate);
allocator_->AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false,
"low", kLowBitratePriority);
allocator_->AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
"mid", kMidBitratePriority);
allocator_->AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
"high", kHighBitratePriority);
AddObserver(&observer_low, kMinBitrate, kMaxBitrate, 0, false, "low",
kLowBitratePriority);
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid",
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high",
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
@ -784,12 +798,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
// available bitrate, so 70 bps would be sufficient network bandwidth.
const uint32_t kRemainingBitrate = kAvailableBitrate - kLowMaxBitrate;
allocator_->AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false,
"low", kLowBitratePriority);
allocator_->AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false,
"mid", kMidBitratePriority);
allocator_->AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
"high", kHighBitratePriority);
AddObserver(&observer_low, kMinBitrate, kLowMaxBitrate, 0, false, "low",
kLowBitratePriority);
AddObserver(&observer_mid, kMinBitrate, kMaxBitrate, 0, false, "mid",
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false, "high",
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
@ -818,12 +832,12 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
TestBitrateObserver observer_low;
TestBitrateObserver observer_mid;
TestBitrateObserver observer_high;
allocator_->AddObserver(&observer_low, 10, 40, 0, false, "low", 2.0);
AddObserver(&observer_low, 10, 40, 0, false, "low", 2.0);
// Scaled allocation above the min allocation is the same for these two,
// meaning they will get allocated their max at the same time.
// Scaled (target allocation) = (max - min) / bitrate priority
allocator_->AddObserver(&observer_mid, 10, 30, 0, false, "mid", 4.0);
allocator_->AddObserver(&observer_high, 10, 50, 0, false, "high", 8.0);
AddObserver(&observer_mid, 10, 30, 0, false, "mid", 4.0);
AddObserver(&observer_high, 10, 50, 0, false, "high", 8.0);
allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs);
EXPECT_EQ(30u, observer_low.last_bitrate_bps_);

27
video/video_send_stream_impl.cc
View file

@ -531,9 +531,12 @@ void VideoSendStreamImpl::Start() {
void VideoSendStreamImpl::StartupVideoSendStream() {
RTC_DCHECK_RUN_ON(worker_queue_);
bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id, encoder_bitrate_priority_, has_packet_feedback_);
this,
MediaStreamAllocationConfig{
static_cast<uint32_t>(encoder_min_bitrate_bps_),
encoder_max_bitrate_bps_, static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
// Start monitoring encoder activity.
{
rtc::CritScope lock(&encoder_activity_crit_sect_);
@ -588,9 +591,12 @@ void VideoSendStreamImpl::SignalEncoderActive() {
RTC_DCHECK_RUN_ON(worker_queue_);
RTC_LOG(LS_INFO) << "SignalEncoderActive, Encoder is active.";
bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id, encoder_bitrate_priority_, has_packet_feedback_);
this,
MediaStreamAllocationConfig{
static_cast<uint32_t>(encoder_min_bitrate_bps_),
encoder_max_bitrate_bps_, static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
}
void VideoSendStreamImpl::OnEncoderConfigurationChanged(
@ -645,9 +651,12 @@ void VideoSendStreamImpl::OnEncoderConfigurationChanged(
// The send stream is started already. Update the allocator with new bitrate
// limits.
bitrate_allocator_->AddObserver(
this, encoder_min_bitrate_bps_, encoder_max_bitrate_bps_,
max_padding_bitrate_, !config_->suspend_below_min_bitrate,
config_->track_id, encoder_bitrate_priority_, has_packet_feedback_);
this, MediaStreamAllocationConfig{
static_cast<uint32_t>(encoder_min_bitrate_bps_),
encoder_max_bitrate_bps_,
static_cast<uint32_t>(max_padding_bitrate_),
!config_->suspend_below_min_bitrate, config_->track_id,
encoder_bitrate_priority_, has_packet_feedback_});
}
}