admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Propagating TargetRate struct to BitrateAllocator.

Browse Source 
Bug: webrtc:9883
Change-Id: I443ac7f1ef0f933e2165fdb2f912d314acc7f2f8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/153345
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29241}
This commit is contained in:
Sebastian Jansson 2019-09-19 14:54:43 +02:00 committed by Commit Bot
parent ac315b283c
commit 40de3cc5ef
8 changed files with 200 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/audio_send_stream_unittest.cc
View File

@ -141,7 +141,7 @@ struct ConfigHelper {
task_queue_factory_(CreateDefaultTaskQueueFactory()),
stream_config_(/*send_transport=*/nullptr, MediaTransportConfig()),
audio_processing_(new rtc::RefCountedObject<MockAudioProcessing>()),
bitrate_allocator_(&clock_, &limit_observer_),
bitrate_allocator_(&limit_observer_),
worker_queue_(task_queue_factory_->CreateTaskQueue(
"ConfigHelper_worker_queue",
TaskQueueFactory::Priority::NORMAL)),

1
call/BUILD.gn
View File

@ -202,6 +202,7 @@ rtc_source_set("bitrate_allocator") {
"../api/units:time_delta",
"../rtc_base:checks",
"../rtc_base:rtc_base_approved",
"../rtc_base:safe_minmax",
"../rtc_base/synchronization:sequence_checker",
"../system_wrappers",
"../system_wrappers:field_trial",

45
call/bitrate_allocator.cc
View File

@ -21,6 +21,7 @@
#include "api/units/time_delta.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/field_trial.h"
#include "system_wrappers/include/metrics.h"
@ -51,7 +52,7 @@ double MediaRatio(uint32_t allocated_bitrate, uint32_t protection_bitrate) {
} // namespace
BitrateAllocator::BitrateAllocator(Clock* clock, LimitObserver* limit_observer)
BitrateAllocator::BitrateAllocator(LimitObserver* limit_observer)
: limit_observer_(limit_observer),
last_target_bps_(0),
last_stable_target_bps_(0),
@ -61,7 +62,6 @@ BitrateAllocator::BitrateAllocator(Clock* clock, LimitObserver* limit_observer)
last_rtt_(0),
last_bwe_period_ms_(1000),
num_pause_events_(0),
clock_(clock),
last_bwe_log_time_(0),
transmission_max_bitrate_multiplier_(
GetTransmissionMaxBitrateMultiplier()) {
@ -92,33 +92,32 @@ uint8_t BitrateAllocator::GetTransmissionMaxBitrateMultiplier() {
return kTransmissionMaxBitrateMultiplier;
}
void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
uint32_t stable_target_bitrate_bps,
uint32_t bandwidth_bps,
uint8_t fraction_loss,
int64_t rtt,
int64_t bwe_period_ms) {
void BitrateAllocator::OnNetworkEstimateChanged(TargetTransferRate msg) {
RTC_DCHECK_RUN_ON(&sequenced_checker_);
last_target_bps_ = target_bitrate_bps;
last_bandwidth_bps_ = bandwidth_bps;
last_stable_target_bps_ = stable_target_bitrate_bps;
last_target_bps_ = msg.target_rate.bps();
last_bandwidth_bps_ = msg.network_estimate.bandwidth.bps();
last_stable_target_bps_ = msg.stable_target_rate.bps();
last_non_zero_bitrate_bps_ =
target_bitrate_bps > 0 ? target_bitrate_bps : last_non_zero_bitrate_bps_;
last_fraction_loss_ = fraction_loss;
last_rtt_ = rtt;
last_bwe_period_ms_ = bwe_period_ms;
last_target_bps_ > 0 ? last_target_bps_ : last_non_zero_bitrate_bps_;
int loss_ratio_255 = msg.network_estimate.loss_rate_ratio * 255;
last_fraction_loss_ =
rtc::dchecked_cast<uint8_t>(rtc::SafeClamp(loss_ratio_255, 0, 255));
last_rtt_ = msg.network_estimate.round_trip_time.ms();
last_bwe_period_ms_ = msg.network_estimate.bwe_period.ms();
// Periodically log the incoming BWE.
int64_t now = clock_->TimeInMilliseconds();
int64_t now = msg.at_time.ms();
if (now > last_bwe_log_time_ + kBweLogIntervalMs) {
RTC_LOG(LS_INFO) << "Current BWE " << target_bitrate_bps;
RTC_LOG(LS_INFO) << "Current BWE " << last_target_bps_;
last_bwe_log_time_ = now;
}
ObserverAllocation allocation = AllocateBitrates(target_bitrate_bps);
ObserverAllocation bandwidth_allocation = AllocateBitrates(bandwidth_bps);
ObserverAllocation allocation = AllocateBitrates(last_target_bps_);
ObserverAllocation bandwidth_allocation =
AllocateBitrates(last_bandwidth_bps_);
ObserverAllocation stable_bitrate_allocation =
AllocateBitrates(stable_target_bitrate_bps);
AllocateBitrates(last_stable_target_bps_);
for (auto& config : allocatable_tracks_) {
uint32_t allocated_bitrate = allocation[config.observer];
@ -135,7 +134,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
uint32_t protection_bitrate = config.observer->OnBitrateUpdated(update);
if (allocated_bitrate == 0 && config.allocated_bitrate_bps > 0) {
if (target_bitrate_bps > 0)
if (last_target_bps_ > 0)
++num_pause_events_;
// The protection bitrate is an estimate based on the ratio between media
// and protection used before this observer was muted.
@ -144,11 +143,11 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps,
RTC_LOG(LS_INFO) << "Pausing observer " << config.observer
<< " with configured min bitrate "
<< config.config.min_bitrate_bps
<< " and current estimate of " << target_bitrate_bps
<< " and current estimate of " << last_target_bps_
<< " and protection bitrate "
<< predicted_protection_bps;
} else if (allocated_bitrate > 0 && config.allocated_bitrate_bps == 0) {
if (target_bitrate_bps > 0)
if (last_target_bps_ > 0)
++num_pause_events_;
RTC_LOG(LS_INFO) << "Resuming observer " << config.observer
<< ", configured min bitrate "

10
call/bitrate_allocator.h
View File

@ -89,18 +89,13 @@ class BitrateAllocator : public BitrateAllocatorInterface {
virtual ~LimitObserver() = default;
};
BitrateAllocator(Clock* clock, LimitObserver* limit_observer);
explicit BitrateAllocator(LimitObserver* limit_observer);
~BitrateAllocator() override;
void UpdateStartRate(uint32_t start_rate_bps);
// Allocate target_bitrate across the registered BitrateAllocatorObservers.
void OnNetworkChanged(uint32_t target_bitrate_bps,
uint32_t stable_target_bitrate_bps,
uint32_t bandwidth_bps,
uint8_t fraction_loss,
int64_t rtt,
int64_t bwe_period_ms);
void OnNetworkEstimateChanged(TargetTransferRate msg);
// Set the configuration used by the bandwidth management.
// |observer| updates bitrates if already in use.
@ -211,7 +206,6 @@ class BitrateAllocator : public BitrateAllocatorInterface {
int64_t last_bwe_period_ms_ RTC_GUARDED_BY(&sequenced_checker_);
// Number of mute events based on too low BWE, not network up/down.
int num_pause_events_ RTC_GUARDED_BY(&sequenced_checker_);
Clock* const clock_ RTC_GUARDED_BY(&sequenced_checker_);
int64_t last_bwe_log_time_ RTC_GUARDED_BY(&sequenced_checker_);
BitrateAllocationLimits current_limits_ RTC_GUARDED_BY(&sequenced_checker_);
const uint8_t transmission_max_bitrate_multiplier_;

273
call/bitrate_allocator_unittest.cc
View File

@ -25,6 +25,7 @@ using ::testing::NiceMock;
namespace webrtc {
namespace {
auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
uint32_t max_padding_rate_bps,
uint32_t max_allocatable_rate_bps) {
@ -77,30 +78,32 @@ class TestBitrateObserver : public BitrateAllocatorObserver {
double protection_ratio_;
};
class BitrateAllocatorForTest : public BitrateAllocator {
public:
using BitrateAllocator::BitrateAllocator;
void OnNetworkChanged(uint32_t target_bitrate_bps,
uint8_t fraction_loss,
int64_t rtt,
int64_t bwe_period_ms) {
BitrateAllocator::OnNetworkChanged(target_bitrate_bps, target_bitrate_bps,
target_bitrate_bps, fraction_loss, rtt,
bwe_period_ms);
}
};
namespace {
constexpr int64_t kDefaultProbingIntervalMs = 3000;
const double kDefaultBitratePriority = 1.0;
TargetTransferRate CreateTargetRateMessage(uint32_t target_bitrate_bps,
uint8_t fraction_loss,
int64_t rtt_ms,
int64_t bwe_period_ms) {
TargetTransferRate msg;
// The timestamp is just for log output, keeping it fixed just means fewer log
// messages in the test.
msg.at_time = Timestamp::seconds(10000);
msg.target_rate = DataRate::bps(target_bitrate_bps);
msg.stable_target_rate = msg.target_rate;
msg.network_estimate.bandwidth = msg.target_rate;
msg.network_estimate.loss_rate_ratio = fraction_loss / 255.0;
msg.network_estimate.round_trip_time = TimeDelta::ms(rtt_ms);
msg.network_estimate.bwe_period = TimeDelta::ms(bwe_period_ms);
return msg;
}
} // namespace
class BitrateAllocatorTest : public ::testing::Test {
protected:
BitrateAllocatorTest()
: allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(),
&limit_observer_)) {
allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
BitrateAllocatorTest() : allocator_(new BitrateAllocator(&limit_observer_)) {
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
}
~BitrateAllocatorTest() {}
void AddObserver(BitrateAllocatorObserver* observer,
@ -126,7 +129,7 @@ class BitrateAllocatorTest : public ::testing::Test {
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocatorForTest> allocator_;
std::unique_ptr<BitrateAllocator> allocator_;
};
TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
@ -143,23 +146,28 @@ TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
config_b.priority_bitrate_bps = 300000;
allocator_->AddObserver(&stream_b, config_b);
allocator_->OnNetworkChanged(100000, 0, 0, 0);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(100000, 0, 0, 0));
EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
allocator_->OnNetworkChanged(200000, 0, 0, 0);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000, 0, 0, 0));
EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
EXPECT_EQ(stream_b.last_bitrate_bps_, 100000u);
allocator_->OnNetworkChanged(300000, 0, 0, 0);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 0, 0));
EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
EXPECT_EQ(stream_b.last_bitrate_bps_, 200000u);
allocator_->OnNetworkChanged(400000, 0, 0, 0);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(400000, 0, 0, 0));
EXPECT_EQ(stream_a.last_bitrate_bps_, 100000u);
EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
allocator_->OnNetworkChanged(800000, 0, 0, 0);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(800000, 0, 0, 0));
EXPECT_EQ(stream_a.last_bitrate_bps_, 500000u);
EXPECT_EQ(stream_b.last_bitrate_bps_, 300000u);
}
@ -176,12 +184,14 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
AddObserver(&bitrate_observer, kMinSendBitrateBps, kMaxBitrateBps,
kPadUpToBitrateBps, true, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
allocator_->OnNetworkChanged(200000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(200000, allocator_->GetStartBitrate(&bitrate_observer));
// TODO(pbos): Expect capping to 1.5M instead of 3M when not boosting the max
// bitrate for FEC/retransmissions (see todo in BitrateAllocator).
allocator_->OnNetworkChanged(4000000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(4000000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
// Expect |max_padding_bitrate_bps| to change to 0 if the observer is updated.
@ -197,7 +207,8 @@ TEST_F(BitrateAllocatorTest, UpdatingBitrateObserver) {
kDefaultBitratePriority);
EXPECT_EQ(3000000, allocator_->GetStartBitrate(&bitrate_observer));
EXPECT_EQ(3000000u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(kMaxBitrateBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(1500000u, bitrate_observer.last_bitrate_bps_);
}
@ -228,8 +239,8 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
// Test too low start bitrate, hence lower than sum of min. Min bitrates
// will
// be allocated to all observers.
allocator_->OnNetworkChanged(kObs2StartBitrateBps, 0, 50,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kObs2StartBitrateBps, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0, bitrate_observer_1.last_fraction_loss_);
EXPECT_EQ(50, bitrate_observer_1.last_rtt_ms_);
@ -238,7 +249,8 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
EXPECT_EQ(50, bitrate_observer_2.last_rtt_ms_);
// Test a bitrate which should be distributed equally.
allocator_->OnNetworkChanged(500000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(500000, 0, 50, kDefaultProbingIntervalMs));
const uint32_t kBitrateToShare =
500000 - kObs2StartBitrateBps - kObs1StartBitrateBps;
EXPECT_EQ(100000u + kBitrateToShare / 2,
@ -248,14 +260,16 @@ TEST_F(BitrateAllocatorTest, TwoBitrateObserversOneRtcpObserver) {
// Limited by 2x max bitrates since we leave room for FEC and
// retransmissions.
allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(600000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(600000u, bitrate_observer_2.last_bitrate_bps_);
// Verify that if the bandwidth estimate is set to zero, the allocated
// rate is
// zero.
allocator_->OnNetworkChanged(0, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(0, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
}
@ -279,9 +293,9 @@ TEST_F(BitrateAllocatorTest, RemoveObserverTriggersLimitObserver) {
class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
protected:
BitrateAllocatorTestNoEnforceMin()
: allocator_(new BitrateAllocatorForTest(Clock::GetRealTimeClock(),
&limit_observer_)) {
allocator_->OnNetworkChanged(300000u, 0, 0, kDefaultProbingIntervalMs);
: allocator_(new BitrateAllocator(&limit_observer_)) {
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000u, 0, 0, kDefaultProbingIntervalMs));
}
~BitrateAllocatorTestNoEnforceMin() {}
void AddObserver(BitrateAllocatorObserver* observer,
@ -296,7 +310,7 @@ class BitrateAllocatorTestNoEnforceMin : public ::testing::Test {
enforce_min_bitrate, bitrate_priority});
}
NiceMock<MockLimitObserver> limit_observer_;
std::unique_ptr<BitrateAllocatorForTest> allocator_;
std::unique_ptr<BitrateAllocator> allocator_;
};
// The following three tests verify enforcing a minimum bitrate works as
@ -314,11 +328,13 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserver) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// High BWE.
allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(150000u, bitrate_observer_1.last_bitrate_bps_);
// Low BWE.
allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_CALL(limit_observer_,
@ -348,7 +364,8 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
// High BWE. 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, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(690000, 0, 0, kDefaultProbingIntervalMs));
// 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.
uint32_t bitrate_to_share = 690000u - 100000u - 200000u - 300000u;
@ -360,27 +377,31 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, ThreeBitrateObservers) {
bitrate_observer_3.last_bitrate_bps_);
// BWE below the sum of observer's min bitrate.
allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min bitrate.
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min bitrate.
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
// Increased BWE, but still below the sum of configured min bitrates for all
// observers and too little for observer 3. 1 and 2 will share the rest.
allocator_->OnNetworkChanged(500000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(500000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(200000u, bitrate_observer_1.last_bitrate_bps_); // Min + split.
EXPECT_EQ(300000u, bitrate_observer_2.last_bitrate_bps_); // Min + split.
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_); // Nothing.
// Below min for all.
allocator_->OnNetworkChanged(10000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(10000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
// Verify that zero estimated bandwidth, means that that all gets zero,
// regardless of set min bitrate.
allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_3.last_bitrate_bps_);
@ -407,15 +428,16 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer));
// High BWE.
allocator_->OnNetworkChanged(150000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(150000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(150000u, bitrate_observer.last_bitrate_bps_);
// Add loss and use a part of the bitrate for protection.
const double kProtectionRatio = 0.4;
const uint8_t fraction_loss = kProtectionRatio * 256;
bitrate_observer.SetBitrateProtectionRatio(kProtectionRatio);
allocator_->OnNetworkChanged(200000, 0, fraction_loss,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
200000, 0, fraction_loss, kDefaultProbingIntervalMs));
EXPECT_EQ(200000u, bitrate_observer.last_bitrate_bps_);
// Above the min threshold, but not enough given the protection used.
@ -427,31 +449,34 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, OneBitrateObserverWithPacketLoss) {
EXPECT_CALL(limit_observer_,
OnAllocationLimitsChanged(AllocationLimitsEq(
0, kMinStartBitrateWithProtectionBps, kMaxBitrateBps)));
allocator_->OnNetworkChanged(kMinStartBitrateBps + 1000, 0, fraction_loss,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kMinStartBitrateBps + 1000, 0, fraction_loss, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0,
fraction_loss, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0,
fraction_loss, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer.last_bitrate_bps_);
// Just enough to enable video again.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(
AllocationLimitsEq(0, 0, kMaxBitrateBps)));
allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps, 0,
fraction_loss, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(kMinStartBitrateWithProtectionBps, 0,
fraction_loss, kDefaultProbingIntervalMs));
EXPECT_EQ(kMinStartBitrateWithProtectionBps,
bitrate_observer.last_bitrate_bps_);
// Remove all protection and make sure video is not paused as earlier.
bitrate_observer.SetBitrateProtectionRatio(0.0);
allocator_->OnNetworkChanged(kMinStartBitrateWithProtectionBps - 1000, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(kMinStartBitrateWithProtectionBps - 1000, 0, 0,
kDefaultProbingIntervalMs));
EXPECT_EQ(kMinStartBitrateWithProtectionBps - 1000,
bitrate_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(kMinStartBitrateBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kMinStartBitrateBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(kMinStartBitrateBps, bitrate_observer.last_bitrate_bps_);
EXPECT_CALL(limit_observer_,
@ -479,19 +504,22 @@ TEST_F(BitrateAllocatorTest,
bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
// Total allocation limits are unaffected by the protection rate change.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
// Observer uses 0% of it's allocated bitrate for protection.
bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.0);
// Total allocation limits are unaffected by the protection rate change.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
// Observer again uses 20% of it's allocated bitrate for protection.
bitrate_observer.SetBitrateProtectionRatio(/*protection_ratio=*/0.2);
// Total allocation limits are unaffected by the protection rate change.
EXPECT_CALL(limit_observer_, OnAllocationLimitsChanged(_)).Times(0);
allocator_->OnNetworkChanged(200000u, 0, 100, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000u, 0, 100, kDefaultProbingIntervalMs));
}
TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
@ -508,37 +536,45 @@ TEST_F(BitrateAllocatorTestNoEnforceMin, TwoBitrateObserverWithPacketLoss) {
// Enough bitrate for both.
bitrate_observer_2.SetBitrateProtectionRatio(0.5);
allocator_->OnNetworkChanged(300000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_);
// Above min for observer 2, but too little given the protection used.
allocator_->OnNetworkChanged(330000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(330000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(330000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
allocator_->OnNetworkChanged(100000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(100000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
allocator_->OnNetworkChanged(99999, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(99999, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
allocator_->OnNetworkChanged(119000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(119000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
allocator_->OnNetworkChanged(120000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(120000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(120000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
// Verify the protection is accounted for before resuming observer 2.
allocator_->OnNetworkChanged(429000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(429000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(400000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
allocator_->OnNetworkChanged(430000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(430000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(330000u, bitrate_observer_2.last_bitrate_bps_);
@ -568,7 +604,8 @@ TEST_F(BitrateAllocatorTest, ThreeBitrateObserversLowBweEnforceMin) {
// Low BWE. Verify that all observers still get their respective min
// bitrate.
allocator_->OnNetworkChanged(1000, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(1000, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(100000u, bitrate_observer_1.last_bitrate_bps_); // Min cap.
EXPECT_EQ(200000u, bitrate_observer_2.last_bitrate_bps_); // Min cap.
EXPECT_EQ(300000u, bitrate_observer_3.last_bitrate_bps_); // Min cap.
@ -588,7 +625,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
EXPECT_EQ(300000, allocator_->GetStartBitrate(&bitrate_observer_1));
// Set network down, ie, no available bitrate.
allocator_->OnNetworkChanged(0, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(0, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, bitrate_observer_1.last_bitrate_bps_);
@ -606,7 +644,8 @@ TEST_F(BitrateAllocatorTest, AddObserverWhileNetworkDown) {
EXPECT_EQ(0u, bitrate_observer_2.last_bitrate_bps_);
// Set network back up.
allocator_->OnNetworkChanged(1500000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(1500000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(750000u, bitrate_observer_1.last_bitrate_bps_);
EXPECT_EQ(750000u, bitrate_observer_2.last_bitrate_bps_);
}
@ -623,31 +662,38 @@ TEST_F(BitrateAllocatorTest, MixedEnforecedConfigs) {
EXPECT_EQ(270000, allocator_->GetStartBitrate(&not_enforced_observer));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(30000u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(35000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(35000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(5000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(5000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(36000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(36000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(55000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(55000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(30000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(0u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(6000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(50000u, not_enforced_observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(56000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(56000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(16000u, enforced_observer.last_bitrate_bps_);
EXPECT_EQ(40000u, not_enforced_observer.last_bitrate_bps_);
@ -660,22 +706,28 @@ TEST_F(BitrateAllocatorTest, AvoidToggleAbsolute) {
AddObserver(&observer, 30000, 300000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(30000u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(20000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(20000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(49000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(49000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(50000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(50000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(50000u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(30000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(30000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(30000u, observer.last_bitrate_bps_);
allocator_->RemoveObserver(&observer);
@ -686,22 +738,28 @@ TEST_F(BitrateAllocatorTest, AvoidTogglePercent) {
AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(300000u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(200000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(200000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(329000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(329000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(0u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(330000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(330000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(330000u, observer.last_bitrate_bps_);
allocator_->OnNetworkChanged(300000, 0, 50, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 50, kDefaultProbingIntervalMs));
EXPECT_EQ(300000u, observer.last_bitrate_bps_);
allocator_->RemoveObserver(&observer);
@ -712,7 +770,8 @@ TEST_F(BitrateAllocatorTest, PassProbingInterval) {
AddObserver(&observer, 300000, 600000, 0, false, kDefaultBitratePriority);
EXPECT_EQ(300000, allocator_->GetStartBitrate(&observer));
allocator_->OnNetworkChanged(300000, 0, 50, 5000);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(300000, 0, 50, 5000));
EXPECT_EQ(5000, observer.last_probing_interval_ms_);
allocator_->RemoveObserver(&observer);
@ -725,8 +784,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateOneObserverBasic) {
const uint32_t kNetworkBandwidthBps = 30;
AddObserver(&observer, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true, 2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(kNetworkBandwidthBps, observer.last_bitrate_bps_);
@ -745,8 +804,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasic) {
2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, false,
2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
@ -767,8 +826,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBasicMinEnforced) {
2.0);
AddObserver(&observer_low_2, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
2.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_1.last_bitrate_bps_);
EXPECT_EQ(kNetworkBandwidthBps / 2, observer_low_2.last_bitrate_bps_);
@ -789,8 +848,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversBothAllocatedMax) {
2.0);
AddObserver(&observer_mid, kMinSendBitrateBps, kMaxSendBitrateBps, 0, true,
4.0);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(kMaxSendBitrateBps, observer_low.last_bitrate_bps_);
EXPECT_EQ(kMaxSendBitrateBps, observer_mid.last_bitrate_bps_);
@ -807,7 +866,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateTwoObserversOneAllocatedToMax) {
TestBitrateObserver observer_mid;
AddObserver(&observer_low, 10, 50, 0, false, 2.0);
AddObserver(&observer_mid, 10, 50, 0, false, 4.0);
allocator_->OnNetworkChanged(90, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(90, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(40u, observer_low.last_bitrate_bps_);
EXPECT_EQ(50u, observer_mid.last_bitrate_bps_);
@ -834,8 +894,8 @@ TEST_F(BitrateAllocatorTest,
AddObserver(&observer_low, 0, kMaxBitrate, 0, false, kLowBitratePriority);
AddObserver(&observer_mid, 0, kMaxBitrate, 0, false, kMidBitratePriority);
AddObserver(&observer_high, 0, kMaxBitrate, 0, false, kHighBitratePriority);
allocator_->OnNetworkChanged(kNetworkBandwidthBps, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kNetworkBandwidthBps, 0, 0, kDefaultProbingIntervalMs));
const double kLowFractionAllocated =
kLowBitratePriority / kTotalBitratePriority;
@ -880,8 +940,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversHighAllocatedToMax) {
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
const double kLowFractionAllocated =
kLowBitratePriority / (kLowBitratePriority + kMidBitratePriority);
@ -924,8 +984,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversLowAllocatedToMax) {
kMidBitratePriority);
AddObserver(&observer_high, kMinBitrate, kMaxBitrate, 0, false,
kHighBitratePriority);
allocator_->OnNetworkChanged(kAvailableBitrate, 0, 0,
kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(CreateTargetRateMessage(
kAvailableBitrate, 0, 0, kDefaultProbingIntervalMs));
const double kMidFractionAllocated =
kMidBitratePriority / (kMidBitratePriority + kHighBitratePriority);
@ -958,7 +1018,8 @@ TEST_F(BitrateAllocatorTest, PriorityRateThreeObserversTwoAllocatedToMax) {
// Scaled (target allocation) = (max - min) / bitrate priority
AddObserver(&observer_mid, 10, 30, 0, false, 4.0);
AddObserver(&observer_high, 10, 50, 0, false, 8.0);
allocator_->OnNetworkChanged(110, 0, 0, kDefaultProbingIntervalMs);
allocator_->OnNetworkEstimateChanged(
CreateTargetRateMessage(110, 0, 0, kDefaultProbingIntervalMs));
EXPECT_EQ(30u, observer_low.last_bitrate_bps_);
EXPECT_EQ(30u, observer_mid.last_bitrate_bps_);

20
call/call.cc
View File

@ -48,7 +48,6 @@
#include "rtc_base/constructor_magic.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/numerics/safe_minmax.h"
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/synchronization/rw_lock_wrapper.h"
#include "rtc_base/synchronization/sequence_checker.h"
@ -442,7 +441,7 @@ Call::Call(Clock* clock,
num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
module_process_thread_(std::move(module_process_thread)),
call_stats_(new CallStats(clock_, module_process_thread_.get())),
bitrate_allocator_(new BitrateAllocator(clock_, this)),
bitrate_allocator_(new BitrateAllocator(this)),
config_(config),
audio_network_state_(kNetworkDown),
video_network_state_(kNetworkDown),
@ -1064,24 +1063,15 @@ void Call::OnStartRateUpdate(DataRate start_rate) {
void Call::OnTargetTransferRate(TargetTransferRate msg) {
RTC_DCHECK(network_queue()->IsCurrent());
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
uint32_t target_bitrate_bps = msg.target_rate.bps();
int loss_ratio_255 = msg.network_estimate.loss_rate_ratio * 255;
uint8_t fraction_loss =
rtc::dchecked_cast<uint8_t>(rtc::SafeClamp(loss_ratio_255, 0, 255));
int64_t rtt_ms = msg.network_estimate.round_trip_time.ms();
int64_t probing_interval_ms = msg.network_estimate.bwe_period.ms();
uint32_t bandwidth_bps = msg.network_estimate.bandwidth.bps();
uint32_t stable_target_rate_bps = msg.stable_target_rate.bps();
{
rtc::CritScope cs(&last_bandwidth_bps_crit_);
last_bandwidth_bps_ = bandwidth_bps;
last_bandwidth_bps_ = msg.network_estimate.bandwidth.bps();
}
uint32_t target_bitrate_bps = msg.target_rate.bps();
// For controlling the rate of feedback messages.
receive_side_cc_.OnBitrateChanged(target_bitrate_bps);
bitrate_allocator_->OnNetworkChanged(
target_bitrate_bps, stable_target_rate_bps, bandwidth_bps, fraction_loss,
rtt_ms, probing_interval_ms);
bitrate_allocator_->OnNetworkEstimateChanged(msg);
// Ignore updates if bitrate is zero (the aggregate network state is down).
if (target_bitrate_bps == 0) {

1
modules/congestion_controller/pcc/pcc_network_controller.cc
View File

@ -101,6 +101,7 @@ NetworkControlUpdate PccNetworkController::CreateRateUpdate(
// Set up target rate to encoder.
TargetTransferRate target_rate_msg;
target_rate_msg.at_time = at_time;
target_rate_msg.network_estimate.at_time = at_time;
target_rate_msg.network_estimate.round_trip_time = rtt_tracker_.GetRtt();
target_rate_msg.network_estimate.bandwidth = bandwidth_estimate_;

1
modules/congestion_controller/rtp/control_handler.cc
View File

@ -38,6 +38,7 @@ CongestionControlHandler::~CongestionControlHandler() {}
void CongestionControlHandler::SetTargetRate(
TargetTransferRate new_target_rate) {
RTC_DCHECK_RUN_ON(&sequenced_checker_);
RTC_CHECK(new_target_rate.at_time.IsFinite());
last_incoming_ = new_target_rate;
}