Propagating TargetRate struct to BitrateAllocator.
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}
diff --git a/audio/audio_send_stream_unittest.cc b/audio/audio_send_stream_unittest.cc
index a61ce22..948fcfe 100644
--- a/audio/audio_send_stream_unittest.cc
+++ b/audio/audio_send_stream_unittest.cc
@@ -141,7 +141,7 @@
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)),
diff --git a/call/BUILD.gn b/call/BUILD.gn
index cf70067..92dedbd 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -202,6 +202,7 @@
"../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",
diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc
index c13848f..5362cee 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -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 @@
} // 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 @@
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 @@
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 @@
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 @@
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 "
diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h
index a4ef032..bad6016 100644
--- a/call/bitrate_allocator.h
+++ b/call/bitrate_allocator.h
@@ -89,18 +89,13 @@
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 @@
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_;
diff --git a/call/bitrate_allocator_unittest.cc b/call/bitrate_allocator_unittest.cc
index 5cdbc38..edb3f7e 100644
--- a/call/bitrate_allocator_unittest.cc
+++ b/call/bitrate_allocator_unittest.cc
@@ -25,6 +25,7 @@
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 @@
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 @@
}
NiceMock<MockLimitObserver> limit_observer_;
- std::unique_ptr<BitrateAllocatorForTest> allocator_;
+ std::unique_ptr<BitrateAllocator> allocator_;
};
TEST_F(BitrateAllocatorTest, RespectsPriorityBitrate) {
@@ -143,23 +146,28 @@
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 @@
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 @@
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 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 @@
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 @@
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 @@
EXPECT_EQ(270000, allocator_->GetStartBitrate(¬_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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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_);
diff --git a/call/call.cc b/call/call.cc
index 90208fc..f816cb5 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -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 @@
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::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) {
diff --git a/modules/congestion_controller/pcc/pcc_network_controller.cc b/modules/congestion_controller/pcc/pcc_network_controller.cc
index 034328e..169b147 100644
--- a/modules/congestion_controller/pcc/pcc_network_controller.cc
+++ b/modules/congestion_controller/pcc/pcc_network_controller.cc
@@ -101,6 +101,7 @@
// 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_;
diff --git a/modules/congestion_controller/rtp/control_handler.cc b/modules/congestion_controller/rtp/control_handler.cc
index 9272d99..ba77aac 100644
--- a/modules/congestion_controller/rtp/control_handler.cc
+++ b/modules/congestion_controller/rtp/control_handler.cc
@@ -38,6 +38,7 @@
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;
}