diff --git a/modules/bitrate_controller/bitrate_controller_impl.cc b/modules/bitrate_controller/bitrate_controller_impl.cc index 86b016c18a..57c85f6f6f 100644 --- a/modules/bitrate_controller/bitrate_controller_impl.cc +++ b/modules/bitrate_controller/bitrate_controller_impl.cc @@ -153,14 +153,12 @@ void BitrateControllerImpl::OnDelayBasedBweResult( rtc::CritScope cs(&critsect_); if (result.probe) { bandwidth_estimation_.SetSendBitrate( - DataRate::bps(result.target_bitrate_bps), - Timestamp::ms(clock_->TimeInMilliseconds())); + result.target_bitrate, Timestamp::ms(clock_->TimeInMilliseconds())); } // Since SetSendBitrate now resets the delay-based estimate, we have to call // UpdateDelayBasedEstimate after SetSendBitrate. bandwidth_estimation_.UpdateDelayBasedEstimate( - Timestamp::ms(clock_->TimeInMilliseconds()), - DataRate::bps(result.target_bitrate_bps)); + Timestamp::ms(clock_->TimeInMilliseconds()), result.target_bitrate); } MaybeTriggerOnNetworkChanged(); } diff --git a/modules/bitrate_controller/bitrate_controller_unittest.cc b/modules/bitrate_controller/bitrate_controller_unittest.cc index 96f8a1ef26..cf281214aa 100644 --- a/modules/bitrate_controller/bitrate_controller_unittest.cc +++ b/modules/bitrate_controller/bitrate_controller_unittest.cc @@ -169,7 +169,7 @@ TEST_F(BitrateControllerTest, OneBitrateObserverOneRtcpObserver) { EXPECT_EQ(300000, bitrate_observer_.last_bitrate_); // Test that a low delay-based estimate limits the combined estimate. - webrtc::DelayBasedBwe::Result result(false, 280000); + webrtc::DelayBasedBwe::Result result(false, webrtc::DataRate::kbps(280)); controller_->OnDelayBasedBweResult(result); EXPECT_EQ(280000, bitrate_observer_.last_bitrate_); diff --git a/modules/bitrate_controller/send_side_bandwidth_estimation.cc b/modules/bitrate_controller/send_side_bandwidth_estimation.cc index 0833dd2262..4694aa622d 100644 --- a/modules/bitrate_controller/send_side_bandwidth_estimation.cc +++ b/modules/bitrate_controller/send_side_bandwidth_estimation.cc @@ -275,13 +275,12 @@ void SendSideBandwidthEstimation::UpdateDelayBasedEstimate(Timestamp at_time, void SendSideBandwidthEstimation::IncomingPacketFeedbackVector( const TransportPacketsFeedback& report, - absl::optional acked_bitrate_bps) { + absl::optional acked_bitrate) { if (!loss_based_bandwidth_estimation_.Enabled()) return; - if (acked_bitrate_bps) { - DataRate acked_bitrate = DataRate::bps(*acked_bitrate_bps); + if (acked_bitrate) { loss_based_bandwidth_estimation_.UpdateAcknowledgedBitrate( - acked_bitrate, report.feedback_time); + *acked_bitrate, report.feedback_time); } loss_based_bandwidth_estimation_.UpdateLossStatistics(report.packet_feedbacks, report.feedback_time); diff --git a/modules/bitrate_controller/send_side_bandwidth_estimation.h b/modules/bitrate_controller/send_side_bandwidth_estimation.h index 40105e152b..ab43c5277c 100644 --- a/modules/bitrate_controller/send_side_bandwidth_estimation.h +++ b/modules/bitrate_controller/send_side_bandwidth_estimation.h @@ -91,7 +91,7 @@ class SendSideBandwidthEstimation { void SetMinMaxBitrate(DataRate min_bitrate, DataRate max_bitrate); int GetMinBitrate() const; void IncomingPacketFeedbackVector(const TransportPacketsFeedback& report, - absl::optional acked_bitrate_bps); + absl::optional acked_bitrate); private: enum UmaState { kNoUpdate, kFirstDone, kDone }; diff --git a/modules/congestion_controller/goog_cc/BUILD.gn b/modules/congestion_controller/goog_cc/BUILD.gn index ba71686bdd..394f3c378b 100644 --- a/modules/congestion_controller/goog_cc/BUILD.gn +++ b/modules/congestion_controller/goog_cc/BUILD.gn @@ -97,6 +97,7 @@ rtc_source_set("estimators") { ] deps = [ + "../../../api/units:data_rate", "../../../logging:rtc_event_bwe", "../../../logging:rtc_event_log_api", "../../../rtc_base:checks", diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc index f29fee92f4..939da4cc33 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.cc @@ -72,6 +72,18 @@ absl::optional AcknowledgedBitrateEstimator::PeekBps() const { return bitrate_estimator_->PeekBps(); } +absl::optional AcknowledgedBitrateEstimator::bitrate() const { + if (bitrate_bps()) + return DataRate::bps(*bitrate_bps()); + return absl::nullopt; +} + +absl::optional AcknowledgedBitrateEstimator::PeekRate() const { + if (PeekBps()) + return DataRate::bps(*PeekBps()); + return absl::nullopt; +} + void AcknowledgedBitrateEstimator::SetAlrEndedTimeMs( int64_t alr_ended_time_ms) { alr_ended_time_ms_.emplace(alr_ended_time_ms); diff --git a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h index 15ee370395..645c0b913a 100644 --- a/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h +++ b/modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator.h @@ -17,6 +17,8 @@ #include "absl/types/optional.h" #include "modules/congestion_controller/goog_cc/bitrate_estimator.h" +#include "api/units/data_rate.h" + namespace webrtc { struct PacketFeedback; @@ -33,6 +35,8 @@ class AcknowledgedBitrateEstimator { const std::vector& packet_feedback_vector); absl::optional bitrate_bps() const; absl::optional PeekBps() const; + absl::optional bitrate() const; + absl::optional PeekRate() const; void SetAlrEndedTimeMs(int64_t alr_ended_time_ms); void SetAllocatedBitrateWithoutFeedback(uint32_t bitrate_bps); diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe.cc b/modules/congestion_controller/goog_cc/delay_based_bwe.cc index 04be4c9e32..60f52a17f4 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe.cc @@ -27,8 +27,9 @@ #include "system_wrappers/include/field_trial.h" #include "system_wrappers/include/metrics.h" +namespace webrtc { namespace { -static const int64_t kStreamTimeOutMs = 2000; +constexpr TimeDelta kStreamTimeOut = TimeDelta::Seconds<2>(); constexpr int kTimestampGroupLengthMs = 5; constexpr int kAbsSendTimeFraction = 18; constexpr int kAbsSendTimeInterArrivalUpshift = 8; @@ -67,18 +68,16 @@ size_t ReadTrendlineFilterWindowSize() { } } // namespace -namespace webrtc { - DelayBasedBwe::Result::Result() : updated(false), probe(false), - target_bitrate_bps(0), + target_bitrate(DataRate::Zero()), recovered_from_overuse(false) {} -DelayBasedBwe::Result::Result(bool probe, uint32_t target_bitrate_bps) +DelayBasedBwe::Result::Result(bool probe, DataRate target_bitrate) : updated(true), probe(probe), - target_bitrate_bps(target_bitrate_bps), + target_bitrate(target_bitrate), recovered_from_overuse(false) {} DelayBasedBwe::Result::~Result() {} @@ -87,7 +86,7 @@ DelayBasedBwe::DelayBasedBwe(RtcEventLog* event_log) : event_log_(event_log), inter_arrival_(), delay_detector_(), - last_seen_packet_ms_(-1), + last_seen_packet_(Timestamp::MinusInfinity()), uma_recorded_(false), probe_bitrate_estimator_(event_log), trendline_window_size_( @@ -97,7 +96,7 @@ DelayBasedBwe::DelayBasedBwe(RtcEventLog* event_log) trendline_smoothing_coeff_(kDefaultTrendlineSmoothingCoeff), trendline_threshold_gain_(kDefaultTrendlineThresholdGain), consecutive_delayed_feedbacks_(0), - prev_bitrate_(0), + prev_bitrate_(DataRate::Zero()), prev_state_(BandwidthUsage::kBwNormal) { RTC_LOG(LS_INFO) << "Using Trendline filter for delay change estimation with window size " @@ -111,8 +110,8 @@ DelayBasedBwe::~DelayBasedBwe() {} DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector( const std::vector& packet_feedback_vector, - absl::optional acked_bitrate_bps, - int64_t at_time_ms) { + absl::optional acked_bitrate, + Timestamp at_time) { RTC_DCHECK(std::is_sorted(packet_feedback_vector.begin(), packet_feedback_vector.end(), PacketFeedbackComparator())); @@ -139,7 +138,7 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector( if (packet_feedback.send_time_ms < 0) continue; delayed_feedback = false; - IncomingPacketFeedback(packet_feedback, at_time_ms); + IncomingPacketFeedback(packet_feedback, at_time); if (prev_detector_state == BandwidthUsage::kBwUnderusing && delay_detector_->State() == BandwidthUsage::kBwNormal) { recovered_from_overuse = true; @@ -148,50 +147,51 @@ DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector( } if (delayed_feedback) { - return OnDelayedFeedback(packet_feedback_vector.back().arrival_time_ms); + Timestamp arrival_time = Timestamp::PlusInfinity(); + if (packet_feedback_vector.back().arrival_time_ms > 0) + arrival_time = + Timestamp::ms(packet_feedback_vector.back().arrival_time_ms); + return OnDelayedFeedback(arrival_time); } else { consecutive_delayed_feedbacks_ = 0; - return MaybeUpdateEstimate(acked_bitrate_bps, recovered_from_overuse, - at_time_ms); + return MaybeUpdateEstimate(acked_bitrate, recovered_from_overuse, at_time); } return Result(); } -DelayBasedBwe::Result DelayBasedBwe::OnDelayedFeedback( - int64_t receive_time_ms) { +DelayBasedBwe::Result DelayBasedBwe::OnDelayedFeedback(Timestamp receive_time) { ++consecutive_delayed_feedbacks_; if (consecutive_delayed_feedbacks_ >= kMaxConsecutiveFailedLookups) { consecutive_delayed_feedbacks_ = 0; - return OnLongFeedbackDelay(receive_time_ms); + return OnLongFeedbackDelay(receive_time); } return Result(); } DelayBasedBwe::Result DelayBasedBwe::OnLongFeedbackDelay( - int64_t arrival_time_ms) { + Timestamp arrival_time) { // Estimate should always be valid since a start bitrate always is set in the // Call constructor. An alternative would be to return an empty Result here, // or to estimate the throughput based on the feedback we received. RTC_DCHECK(rate_control_.ValidEstimate()); rate_control_.SetEstimate(rate_control_.LatestEstimate() / 2, - arrival_time_ms); + arrival_time.ms()); Result result; result.updated = true; result.probe = false; - result.target_bitrate_bps = rate_control_.LatestEstimate(); + result.target_bitrate = DataRate::bps(rate_control_.LatestEstimate()); RTC_LOG(LS_WARNING) << "Long feedback delay detected, reducing BWE to " - << result.target_bitrate_bps; + << ToString(result.target_bitrate); return result; } void DelayBasedBwe::IncomingPacketFeedback( const PacketFeedback& packet_feedback, - int64_t at_time_ms) { - int64_t now_ms = at_time_ms; + Timestamp at_time) { // Reset if the stream has timed out. - if (last_seen_packet_ms_ == -1 || - now_ms - last_seen_packet_ms_ > kStreamTimeOutMs) { + if (last_seen_packet_.IsInfinite() || + at_time - last_seen_packet_ > kStreamTimeOut) { inter_arrival_.reset( new InterArrival((kTimestampGroupLengthMs << kInterArrivalShift) / 1000, kTimestampToMs, true)); @@ -199,7 +199,7 @@ void DelayBasedBwe::IncomingPacketFeedback( trendline_smoothing_coeff_, trendline_threshold_gain_)); } - last_seen_packet_ms_ = now_ms; + last_seen_packet_ = at_time; uint32_t send_time_24bits = static_cast( @@ -216,7 +216,7 @@ void DelayBasedBwe::IncomingPacketFeedback( int64_t t_delta = 0; int size_delta = 0; if (inter_arrival_->ComputeDeltas(timestamp, packet_feedback.arrival_time_ms, - now_ms, packet_feedback.payload_size, + at_time.ms(), packet_feedback.payload_size, &ts_delta, &t_delta, &size_delta)) { double ts_delta_ms = (1000.0 * ts_delta) / (1 << kInterArrivalShift); delay_detector_->Update(t_delta, ts_delta_ms, @@ -229,102 +229,105 @@ void DelayBasedBwe::IncomingPacketFeedback( } DelayBasedBwe::Result DelayBasedBwe::MaybeUpdateEstimate( - absl::optional acked_bitrate_bps, + absl::optional acked_bitrate, bool recovered_from_overuse, - int64_t at_time_ms) { + Timestamp at_time) { Result result; - int64_t now_ms = at_time_ms; - absl::optional probe_bitrate_bps = - probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrateBps(); + absl::optional probe_bitrate = + probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrate(); // Currently overusing the bandwidth. if (delay_detector_->State() == BandwidthUsage::kBwOverusing) { - if (acked_bitrate_bps && - rate_control_.TimeToReduceFurther(now_ms, *acked_bitrate_bps)) { + if (acked_bitrate && + rate_control_.TimeToReduceFurther(at_time.ms(), acked_bitrate->bps())) { result.updated = - UpdateEstimate(now_ms, acked_bitrate_bps, &result.target_bitrate_bps); - } else if (!acked_bitrate_bps && rate_control_.ValidEstimate() && - rate_control_.InitialTimeToReduceFurther(now_ms)) { + UpdateEstimate(at_time, acked_bitrate, &result.target_bitrate); + } else if (!acked_bitrate && rate_control_.ValidEstimate() && + rate_control_.InitialTimeToReduceFurther(at_time.ms())) { // Overusing before we have a measured acknowledged bitrate. Reduce send // rate by 50% every 200 ms. // TODO(tschumim): Improve this and/or the acknowledged bitrate estimator // so that we (almost) always have a bitrate estimate. - rate_control_.SetEstimate(rate_control_.LatestEstimate() / 2, now_ms); + rate_control_.SetEstimate(rate_control_.LatestEstimate() / 2, + at_time.ms()); result.updated = true; result.probe = false; - result.target_bitrate_bps = rate_control_.LatestEstimate(); + result.target_bitrate = DataRate::bps(rate_control_.LatestEstimate()); } } else { - if (probe_bitrate_bps) { + if (probe_bitrate) { result.probe = true; result.updated = true; - result.target_bitrate_bps = *probe_bitrate_bps; - rate_control_.SetEstimate(*probe_bitrate_bps, now_ms); + result.target_bitrate = *probe_bitrate; + rate_control_.SetEstimate(probe_bitrate->bps(), at_time.ms()); } else { result.updated = - UpdateEstimate(now_ms, acked_bitrate_bps, &result.target_bitrate_bps); + UpdateEstimate(at_time, acked_bitrate, &result.target_bitrate); result.recovered_from_overuse = recovered_from_overuse; } } BandwidthUsage detector_state = delay_detector_->State(); - if ((result.updated && prev_bitrate_ != result.target_bitrate_bps) || + if ((result.updated && prev_bitrate_ != result.target_bitrate) || detector_state != prev_state_) { - uint32_t bitrate_bps = - result.updated ? result.target_bitrate_bps : prev_bitrate_; + DataRate bitrate = result.updated ? result.target_bitrate : prev_bitrate_; - BWE_TEST_LOGGING_PLOT(1, "target_bitrate_bps", now_ms, bitrate_bps); + BWE_TEST_LOGGING_PLOT(1, "target_bitrate_bps", at_time.ms(), bitrate.bps()); if (event_log_) { event_log_->Log(absl::make_unique( - bitrate_bps, detector_state)); + bitrate.bps(), detector_state)); } - prev_bitrate_ = bitrate_bps; + prev_bitrate_ = bitrate; prev_state_ = detector_state; } return result; } -bool DelayBasedBwe::UpdateEstimate(int64_t now_ms, - absl::optional acked_bitrate_bps, - uint32_t* target_bitrate_bps) { +bool DelayBasedBwe::UpdateEstimate(Timestamp at_time, + absl::optional acked_bitrate, + DataRate* target_rate) { + absl::optional acked_bitrate_bps; + if (acked_bitrate) + acked_bitrate_bps = acked_bitrate->bps(); const RateControlInput input(delay_detector_->State(), acked_bitrate_bps); - *target_bitrate_bps = rate_control_.Update(&input, now_ms); + *target_rate = DataRate::bps(rate_control_.Update(&input, at_time.ms())); return rate_control_.ValidEstimate(); } -void DelayBasedBwe::OnRttUpdate(int64_t avg_rtt_ms) { - rate_control_.SetRtt(avg_rtt_ms); +void DelayBasedBwe::OnRttUpdate(TimeDelta avg_rtt) { + rate_control_.SetRtt(avg_rtt.ms()); } bool DelayBasedBwe::LatestEstimate(std::vector* ssrcs, - uint32_t* bitrate_bps) const { + DataRate* bitrate) const { // Currently accessed from both the process thread (see // ModuleRtpRtcpImpl::Process()) and the configuration thread (see // Call::GetStats()). Should in the future only be accessed from a single // thread. RTC_DCHECK(ssrcs); - RTC_DCHECK(bitrate_bps); + RTC_DCHECK(bitrate); if (!rate_control_.ValidEstimate()) return false; *ssrcs = {kFixedSsrc}; - *bitrate_bps = rate_control_.LatestEstimate(); + *bitrate = DataRate::bps(rate_control_.LatestEstimate()); return true; } -void DelayBasedBwe::SetStartBitrate(int start_bitrate_bps) { - RTC_LOG(LS_INFO) << "BWE Setting start bitrate to: " << start_bitrate_bps; - rate_control_.SetStartBitrate(start_bitrate_bps); +void DelayBasedBwe::SetStartBitrate(DataRate start_bitrate) { + RTC_LOG(LS_INFO) << "BWE Setting start bitrate to: " + << ToString(start_bitrate); + rate_control_.SetStartBitrate(start_bitrate.bps()); } -void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) { +void DelayBasedBwe::SetMinBitrate(DataRate min_bitrate) { // Called from both the configuration thread and the network thread. Shouldn't // be called from the network thread in the future. - rate_control_.SetMinBitrate(min_bitrate_bps); + rate_control_.SetMinBitrate(min_bitrate.bps()); } -int64_t DelayBasedBwe::GetExpectedBwePeriodMs() const { - return rate_control_.GetExpectedBandwidthPeriodMs(); +TimeDelta DelayBasedBwe::GetExpectedBwePeriod() const { + return TimeDelta::ms(rate_control_.GetExpectedBandwidthPeriodMs()); } } // namespace webrtc diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe.h b/modules/congestion_controller/goog_cc/delay_based_bwe.h index f61399c02b..f7c1964573 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe.h +++ b/modules/congestion_controller/goog_cc/delay_based_bwe.h @@ -33,11 +33,11 @@ class DelayBasedBwe { public: struct Result { Result(); - Result(bool probe, uint32_t target_bitrate_bps); + Result(bool probe, DataRate target_bitrate); ~Result(); bool updated; bool probe; - uint32_t target_bitrate_bps; + DataRate target_bitrate = DataRate::Zero(); bool recovered_from_overuse; }; @@ -46,35 +46,34 @@ class DelayBasedBwe { Result IncomingPacketFeedbackVector( const std::vector& packet_feedback_vector, - absl::optional acked_bitrate_bps, - int64_t at_time_ms); - Result OnDelayedFeedback(int64_t receive_time_ms); - void OnRttUpdate(int64_t avg_rtt_ms); - bool LatestEstimate(std::vector* ssrcs, - uint32_t* bitrate_bps) const; - void SetStartBitrate(int start_bitrate_bps); - void SetMinBitrate(int min_bitrate_bps); - int64_t GetExpectedBwePeriodMs() const; + absl::optional acked_bitrate, + Timestamp at_time); + Result OnDelayedFeedback(Timestamp receive_time); + void OnRttUpdate(TimeDelta avg_rtt); + bool LatestEstimate(std::vector* ssrcs, DataRate* bitrate) const; + void SetStartBitrate(DataRate start_bitrate); + void SetMinBitrate(DataRate min_bitrate); + TimeDelta GetExpectedBwePeriod() const; private: friend class GoogCcStatePrinter; void IncomingPacketFeedback(const PacketFeedback& packet_feedback, - int64_t at_time_ms); - Result OnLongFeedbackDelay(int64_t arrival_time_ms); - Result MaybeUpdateEstimate(absl::optional acked_bitrate_bps, + Timestamp at_time); + Result OnLongFeedbackDelay(Timestamp arrival_time); + Result MaybeUpdateEstimate(absl::optional acked_bitrate, bool request_probe, - int64_t at_time_ms); + Timestamp at_time); // Updates the current remote rate estimate and returns true if a valid // estimate exists. - bool UpdateEstimate(int64_t now_ms, - absl::optional acked_bitrate_bps, - uint32_t* target_bitrate_bps); + bool UpdateEstimate(Timestamp now, + absl::optional acked_bitrate, + DataRate* target_bitrate); rtc::RaceChecker network_race_; RtcEventLog* const event_log_; std::unique_ptr inter_arrival_; std::unique_ptr delay_detector_; - int64_t last_seen_packet_ms_; + Timestamp last_seen_packet_; bool uma_recorded_; AimdRateControl rate_control_; ProbeBitrateEstimator probe_bitrate_estimator_; @@ -82,7 +81,7 @@ class DelayBasedBwe { double trendline_smoothing_coeff_; double trendline_threshold_gain_; int consecutive_delayed_feedbacks_; - uint32_t prev_bitrate_; + DataRate prev_bitrate_; BandwidthUsage prev_state_; RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(DelayBasedBwe); diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc index b2add3e6e9..0b2f799864 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest.cc @@ -25,7 +25,7 @@ constexpr int kNumProbesCluster1 = 8; const PacedPacketInfo kPacingInfo0(0, kNumProbesCluster0, 2000); const PacedPacketInfo kPacingInfo1(1, kNumProbesCluster1, 4000); constexpr float kTargetUtilizationFraction = 0.95f; -constexpr int64_t kDummyTimestamp = 1000; +constexpr Timestamp kDummyTimestamp = Timestamp::Seconds<1000>(); } // namespace TEST_F(DelayBasedBweTest, NoCrashEmptyFeedback) { @@ -144,12 +144,12 @@ TEST_F(DelayBasedBweTest, ProbeDetectionSlowerArrivalHighBitrate) { } TEST_F(DelayBasedBweTest, GetExpectedBwePeriodMs) { - int64_t default_interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs(); - EXPECT_GT(default_interval_ms, 0); + auto default_interval = bitrate_estimator_->GetExpectedBwePeriod(); + EXPECT_GT(default_interval.ms(), 0); CapacityDropTestHelper(1, true, 333, 0); - int64_t interval_ms = bitrate_estimator_->GetExpectedBwePeriodMs(); - EXPECT_GT(interval_ms, 0); - EXPECT_NE(interval_ms, default_interval_ms); + auto interval = bitrate_estimator_->GetExpectedBwePeriod(); + EXPECT_GT(interval.ms(), 0); + EXPECT_NE(interval.ms(), default_interval.ms()); } TEST_F(DelayBasedBweTest, InitialBehavior) { @@ -199,20 +199,20 @@ TEST_F(DelayBasedBweTest, TestLongTimeoutAndWrap) { } TEST_F(DelayBasedBweTest, TestInitialOveruse) { - const uint32_t kStartBitrate = 300e3; - const uint32_t kInitialCapacityBps = 200e3; + const DataRate kStartBitrate = DataRate::kbps(300); + const DataRate kInitialCapacity = DataRate::kbps(200); const uint32_t kDummySsrc = 0; // High FPS to ensure that we send a lot of packets in a short time. const int kFps = 90; - stream_generator_->AddStream(new test::RtpStream(kFps, kStartBitrate)); - stream_generator_->set_capacity_bps(kInitialCapacityBps); + stream_generator_->AddStream(new test::RtpStream(kFps, kStartBitrate.bps())); + stream_generator_->set_capacity_bps(kInitialCapacity.bps()); // Needed to initialize the AimdRateControl. bitrate_estimator_->SetStartBitrate(kStartBitrate); // Produce 30 frames (in 1/3 second) and give them to the estimator. - uint32_t bitrate_bps = kStartBitrate; + int64_t bitrate_bps = kStartBitrate.bps(); bool seen_overuse = false; for (int i = 0; i < 30; ++i) { bool overuse = GenerateAndProcessFrame(kDummySsrc, bitrate_bps); @@ -222,7 +222,8 @@ TEST_F(DelayBasedBweTest, TestInitialOveruse) { EXPECT_FALSE(acknowledged_bitrate_estimator_->bitrate_bps().has_value()); if (overuse) { EXPECT_TRUE(bitrate_observer_.updated()); - EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate / 2, 15000); + EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate.bps() / 2, + 15000); bitrate_bps = bitrate_observer_.latest_bitrate(); seen_overuse = true; break; @@ -232,7 +233,8 @@ TEST_F(DelayBasedBweTest, TestInitialOveruse) { } } EXPECT_TRUE(seen_overuse); - EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate / 2, 15000); + EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate.bps() / 2, + 15000); } class DelayBasedBweTestWithBackoffTimeoutExperiment : public DelayBasedBweTest { @@ -243,20 +245,20 @@ class DelayBasedBweTestWithBackoffTimeoutExperiment : public DelayBasedBweTest { // This test subsumes and improves DelayBasedBweTest.TestInitialOveruse above. TEST_F(DelayBasedBweTestWithBackoffTimeoutExperiment, TestInitialOveruse) { - const uint32_t kStartBitrate = 300e3; - const uint32_t kInitialCapacityBps = 200e3; + const DataRate kStartBitrate = DataRate::kbps(300); + const DataRate kInitialCapacity = DataRate::kbps(200); const uint32_t kDummySsrc = 0; // High FPS to ensure that we send a lot of packets in a short time. const int kFps = 90; - stream_generator_->AddStream(new test::RtpStream(kFps, kStartBitrate)); - stream_generator_->set_capacity_bps(kInitialCapacityBps); + stream_generator_->AddStream(new test::RtpStream(kFps, kStartBitrate.bps())); + stream_generator_->set_capacity_bps(kInitialCapacity.bps()); // Needed to initialize the AimdRateControl. bitrate_estimator_->SetStartBitrate(kStartBitrate); // Produce 30 frames (in 1/3 second) and give them to the estimator. - uint32_t bitrate_bps = kStartBitrate; + int64_t bitrate_bps = kStartBitrate.bps(); bool seen_overuse = false; for (int frames = 0; frames < 30 && !seen_overuse; ++frames) { bool overuse = GenerateAndProcessFrame(kDummySsrc, bitrate_bps); @@ -266,7 +268,8 @@ TEST_F(DelayBasedBweTestWithBackoffTimeoutExperiment, TestInitialOveruse) { EXPECT_FALSE(acknowledged_bitrate_estimator_->bitrate_bps().has_value()); if (overuse) { EXPECT_TRUE(bitrate_observer_.updated()); - EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate / 2, 15000); + EXPECT_NEAR(bitrate_observer_.latest_bitrate(), kStartBitrate.bps() / 2, + 15000); bitrate_bps = bitrate_observer_.latest_bitrate(); seen_overuse = true; } else if (bitrate_observer_.updated()) { @@ -282,8 +285,8 @@ TEST_F(DelayBasedBweTestWithBackoffTimeoutExperiment, TestInitialOveruse) { EXPECT_FALSE(overuse); if (bitrate_observer_.updated()) { bitrate_bps = bitrate_observer_.latest_bitrate(); - EXPECT_GE(bitrate_bps, kStartBitrate / 2 - 15000); - EXPECT_LE(bitrate_bps, kInitialCapacityBps + 15000); + EXPECT_GE(bitrate_bps, kStartBitrate.bps() / 2 - 15000); + EXPECT_LE(bitrate_bps, kInitialCapacity.bps() + 15000); bitrate_observer_.Reset(); } } diff --git a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc index 2a00801eb1..583ce25e85 100644 --- a/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc +++ b/modules/congestion_controller/goog_cc/delay_based_bwe_unittest_helper.cc @@ -201,12 +201,12 @@ void DelayBasedBweTest::IncomingFeedback(int64_t arrival_time_ms, acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector(packets); DelayBasedBwe::Result result = bitrate_estimator_->IncomingPacketFeedbackVector( - packets, acknowledged_bitrate_estimator_->bitrate_bps(), - clock_.TimeInMilliseconds()); + packets, acknowledged_bitrate_estimator_->bitrate(), + Timestamp::ms(clock_.TimeInMilliseconds())); const uint32_t kDummySsrc = 0; if (result.updated) { bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, - result.target_bitrate_bps); + result.target_bitrate.bps()); } } @@ -237,13 +237,13 @@ bool DelayBasedBweTest::GenerateAndProcessFrame(uint32_t ssrc, acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector(packets); DelayBasedBwe::Result result = bitrate_estimator_->IncomingPacketFeedbackVector( - packets, acknowledged_bitrate_estimator_->bitrate_bps(), - clock_.TimeInMilliseconds()); + packets, acknowledged_bitrate_estimator_->bitrate(), + Timestamp::ms(clock_.TimeInMilliseconds())); const uint32_t kDummySsrc = 0; if (result.updated) { bitrate_observer_.OnReceiveBitrateChanged({kDummySsrc}, - result.target_bitrate_bps); - if (!first_update_ && result.target_bitrate_bps < bitrate_bps) + result.target_bitrate.bps()); + if (!first_update_ && result.target_bitrate.bps() < bitrate_bps) overuse = true; first_update_ = false; } @@ -289,14 +289,14 @@ void DelayBasedBweTest::InitialBehaviorTestHelper( const int kFramerate = 50; // 50 fps to avoid rounding errors. const int kFrameIntervalMs = 1000 / kFramerate; const PacedPacketInfo kPacingInfo(0, 5, 5000); - uint32_t bitrate_bps = 0; + DataRate bitrate = DataRate::Zero(); int64_t send_time_ms = 0; uint16_t sequence_number = 0; std::vector ssrcs; - EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); + EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate)); EXPECT_EQ(0u, ssrcs.size()); clock_.AdvanceTimeMilliseconds(1000); - EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); + EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate)); EXPECT_FALSE(bitrate_observer_.updated()); bitrate_observer_.Reset(); clock_.AdvanceTimeMilliseconds(1000); @@ -308,7 +308,7 @@ void DelayBasedBweTest::InitialBehaviorTestHelper( i < kInitialProbingPackets ? kPacingInfo : PacedPacketInfo(); if (i == kNumInitialPackets) { - EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); + EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate)); EXPECT_EQ(0u, ssrcs.size()); EXPECT_FALSE(bitrate_observer_.updated()); bitrate_observer_.Reset(); @@ -318,13 +318,14 @@ void DelayBasedBweTest::InitialBehaviorTestHelper( clock_.AdvanceTimeMilliseconds(1000 / kFramerate); send_time_ms += kFrameIntervalMs; } - EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps)); + EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate)); ASSERT_EQ(1u, ssrcs.size()); EXPECT_EQ(kDefaultSsrc, ssrcs.front()); - EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps); + EXPECT_NEAR(expected_converge_bitrate, bitrate.bps(), + kAcceptedBitrateErrorBps); EXPECT_TRUE(bitrate_observer_.updated()); bitrate_observer_.Reset(); - EXPECT_EQ(bitrate_observer_.latest_bitrate(), bitrate_bps); + EXPECT_EQ(bitrate_observer_.latest_bitrate(), bitrate.bps()); } void DelayBasedBweTest::RateIncreaseReorderingTestHelper( @@ -509,7 +510,7 @@ void DelayBasedBweTest::TestWrappingHelper(int silence_time_s) { clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); send_time_ms += kFrameIntervalMs; } - uint32_t bitrate_before = 0; + DataRate bitrate_before = DataRate::Zero(); std::vector ssrcs; bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_before); @@ -522,7 +523,7 @@ void DelayBasedBweTest::TestWrappingHelper(int silence_time_s) { clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); send_time_ms += kFrameIntervalMs; } - uint32_t bitrate_after = 0; + DataRate bitrate_after = DataRate::Zero(); bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_after); EXPECT_LT(bitrate_after, bitrate_before); } diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc index 8d8b9c180a..945a9c2eb4 100644 --- a/modules/congestion_controller/goog_cc/goog_cc_network_control.cc +++ b/modules/congestion_controller/goog_cc/goog_cc_network_control.cc @@ -159,7 +159,7 @@ GoogCcNetworkController::GoogCcNetworkController(RtcEventLog* event_log, {&safe_reset_on_route_change_, &safe_reset_acknowledged_rate_}, field_trial::FindFullName("WebRTC-Bwe-SafeResetOnRouteChange")); - delay_based_bwe_->SetMinBitrate(congestion_controller::GetMinBitrateBps()); + delay_based_bwe_->SetMinBitrate(congestion_controller::GetMinBitrate()); if (in_cwnd_experiment_ && !ReadCwndExperimentParameter(&accepted_queue_ms_)) { RTC_LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment " @@ -203,16 +203,16 @@ NetworkControlUpdate GoogCcNetworkController::OnNetworkRouteChange( if (estimated_bitrate_bps && (!msg.constraints.starting_rate || estimated_bitrate_bps < start_bitrate_bps)) { start_bitrate_bps = *estimated_bitrate_bps; - if (msg.constraints.starting_rate) { - msg.constraints.starting_rate = DataRate::bps(start_bitrate_bps); - } + msg.constraints.starting_rate = DataRate::bps(start_bitrate_bps); } } acknowledged_bitrate_estimator_.reset(new AcknowledgedBitrateEstimator()); delay_based_bwe_.reset(new DelayBasedBwe(event_log_)); - delay_based_bwe_->SetStartBitrate(start_bitrate_bps); - delay_based_bwe_->SetMinBitrate(min_bitrate_bps); + if (msg.constraints.starting_rate) + delay_based_bwe_->SetStartBitrate(*msg.constraints.starting_rate); + // TODO(srte): Use original values instead of converted. + delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps)); bandwidth_estimation_->OnRouteChange(); bandwidth_estimation_->SetBitrates( msg.constraints.starting_rate, DataRate::bps(min_bitrate_bps), @@ -282,7 +282,7 @@ NetworkControlUpdate GoogCcNetworkController::OnRoundTripTimeUpdate( if (packet_feedback_only_) return NetworkControlUpdate(); if (msg.smoothed) { - delay_based_bwe_->OnRttUpdate(msg.round_trip_time.ms()); + delay_based_bwe_->OnRttUpdate(msg.round_trip_time); } else { bandwidth_estimation_->UpdateRtt(msg.round_trip_time, msg.receive_time); } @@ -370,9 +370,9 @@ GoogCcNetworkController::UpdateBitrateConstraints( starting_rate, DataRate::bps(min_bitrate_bps), constraints.max_data_rate.value_or(DataRate::Infinity()), constraints.at_time); - if (start_bitrate_bps > 0) - delay_based_bwe_->SetStartBitrate(start_bitrate_bps); - delay_based_bwe_->SetMinBitrate(min_bitrate_bps); + if (starting_rate) + delay_based_bwe_->SetStartBitrate(*starting_rate); + delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps)); return probes; } @@ -391,11 +391,11 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( TransportPacketsFeedback report) { if (report.packet_feedbacks.empty()) { DelayBasedBwe::Result result = delay_based_bwe_->OnDelayedFeedback( - report.sendless_arrival_times.back().ms()); + report.sendless_arrival_times.back()); NetworkControlUpdate update; if (result.updated) { - bandwidth_estimation_->UpdateDelayBasedEstimate( - report.feedback_time, DataRate::bps(result.target_bitrate_bps)); + bandwidth_estimation_->UpdateDelayBasedEstimate(report.feedback_time, + result.target_bitrate); MaybeTriggerOnNetworkChanged(&update, report.feedback_time); } return update; @@ -436,7 +436,7 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( int64_t sum_rtt_ms = std::accumulate(feedback_max_rtts_.begin(), feedback_max_rtts_.end(), 0); int64_t mean_rtt_ms = sum_rtt_ms / feedback_max_rtts_.size(); - delay_based_bwe_->OnRttUpdate(mean_rtt_ms); + delay_based_bwe_->OnRttUpdate(TimeDelta::ms(mean_rtt_ms)); } TimeDelta feedback_min_rtt = TimeDelta::PlusInfinity(); @@ -481,25 +481,24 @@ NetworkControlUpdate GoogCcNetworkController::OnTransportPacketsFeedback( previously_in_alr = alr_start_time.has_value(); acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector( received_feedback_vector); - auto acknowledged_bitrate = acknowledged_bitrate_estimator_->bitrate_bps(); + auto acknowledged_bitrate = acknowledged_bitrate_estimator_->bitrate(); bandwidth_estimation_->IncomingPacketFeedbackVector(report, acknowledged_bitrate); DelayBasedBwe::Result result; result = delay_based_bwe_->IncomingPacketFeedbackVector( - received_feedback_vector, acknowledged_bitrate, - report.feedback_time.ms()); + received_feedback_vector, acknowledged_bitrate, report.feedback_time); NetworkControlUpdate update; if (result.updated) { if (result.probe) { - bandwidth_estimation_->SetSendBitrate( - DataRate::bps(result.target_bitrate_bps), report.feedback_time); + bandwidth_estimation_->SetSendBitrate(result.target_bitrate, + report.feedback_time); } // Since SetSendBitrate now resets the delay-based estimate, we have to call // UpdateDelayBasedEstimate after SetSendBitrate. - bandwidth_estimation_->UpdateDelayBasedEstimate( - report.feedback_time, DataRate::bps(result.target_bitrate_bps)); + bandwidth_estimation_->UpdateDelayBasedEstimate(report.feedback_time, + result.target_bitrate); // Update the estimate in the ProbeController, in case we want to probe. MaybeTriggerOnNetworkChanged(&update, report.feedback_time); } @@ -550,7 +549,7 @@ NetworkControlUpdate GoogCcNetworkController::GetNetworkState( last_estimated_fraction_loss_ / 255.0; update.target_rate->network_estimate.round_trip_time = rtt; update.target_rate->network_estimate.bwe_period = - TimeDelta::ms(delay_based_bwe_->GetExpectedBwePeriodMs()); + delay_based_bwe_->GetExpectedBwePeriod(); update.target_rate->at_time = at_time; update.target_rate->target_rate = bandwidth; update.pacer_config = GetPacingRates(at_time); @@ -589,8 +588,7 @@ void GoogCcNetworkController::MaybeTriggerOnNetworkChanged( DataRate bandwidth = DataRate::bps(estimated_bitrate_bps); last_bandwidth_ = bandwidth; - TimeDelta bwe_period = - TimeDelta::ms(delay_based_bwe_->GetExpectedBwePeriodMs()); + TimeDelta bwe_period = delay_based_bwe_->GetExpectedBwePeriod(); // Set the target rate to the full estimated bandwidth since the estimation // for legacy reasons includes target rate constraints. diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc index 0f0d17ea48..7ba2fb5a13 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.cc @@ -170,11 +170,13 @@ int ProbeBitrateEstimator::HandleProbeAndEstimateBitrate( return *estimated_bitrate_bps_; } -absl::optional -ProbeBitrateEstimator::FetchAndResetLastEstimatedBitrateBps() { +absl::optional +ProbeBitrateEstimator::FetchAndResetLastEstimatedBitrate() { absl::optional estimated_bitrate_bps = estimated_bitrate_bps_; estimated_bitrate_bps_.reset(); - return estimated_bitrate_bps; + if (estimated_bitrate_bps) + return DataRate::bps(*estimated_bitrate_bps); + return absl::nullopt; } void ProbeBitrateEstimator::EraseOldClusters(int64_t timestamp_ms) { diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h index ed9252137f..ae83ed380f 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator.h @@ -28,7 +28,7 @@ class ProbeBitrateEstimator { // Returns the estimated bitrate if the probe completes a valid cluster. int HandleProbeAndEstimateBitrate(const PacketFeedback& packet_feedback); - absl::optional FetchAndResetLastEstimatedBitrateBps(); + absl::optional FetchAndResetLastEstimatedBitrate(); private: struct AggregatedCluster { diff --git a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc index f8a40f839f..fcf5559245 100644 --- a/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc +++ b/modules/congestion_controller/goog_cc/probe_bitrate_estimator_unittest.cc @@ -202,7 +202,7 @@ TEST_F(TestProbeBitrateEstimator, IgnoreSizeFirstReceivePacket) { } TEST_F(TestProbeBitrateEstimator, NoLastEstimatedBitrateBps) { - EXPECT_FALSE(probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrateBps()); + EXPECT_FALSE(probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrate()); } TEST_F(TestProbeBitrateEstimator, FetchLastEstimatedBitrateBps) { @@ -211,11 +211,11 @@ TEST_F(TestProbeBitrateEstimator, FetchLastEstimatedBitrateBps) { AddPacketFeedback(0, 1000, 20, 30); AddPacketFeedback(0, 1000, 30, 40); - auto estimated_bitrate_bps = - probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrateBps(); - EXPECT_TRUE(estimated_bitrate_bps); - EXPECT_NEAR(*estimated_bitrate_bps, 800000, 10); - EXPECT_FALSE(probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrateBps()); + auto estimated_bitrate = + probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrate(); + EXPECT_TRUE(estimated_bitrate); + EXPECT_NEAR(estimated_bitrate->bps(), 800000, 10); + EXPECT_FALSE(probe_bitrate_estimator_.FetchAndResetLastEstimatedBitrate()); } } // namespace webrtc diff --git a/modules/congestion_controller/send_side_congestion_controller.cc b/modules/congestion_controller/send_side_congestion_controller.cc index cf03baa2ab..36e11dcbc1 100644 --- a/modules/congestion_controller/send_side_congestion_controller.cc +++ b/modules/congestion_controller/send_side_congestion_controller.cc @@ -153,7 +153,7 @@ SendSideCongestionController::SendSideCongestionController( pacer_pushback_experiment_(IsPacerPushbackExperimentEnabled()), congestion_window_pushback_controller_( MaybeCreateCongestionWindowPushbackController()) { - delay_based_bwe_->SetMinBitrate(min_bitrate_bps_); + delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps_)); if (in_cwnd_experiment_ && !ReadCwndExperimentParameter(&accepted_queue_ms_)) { RTC_LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment " @@ -221,9 +221,9 @@ void SendSideCongestionController::SetBweBitrates(int min_bitrate_bps, { rtc::CritScope cs(&bwe_lock_); if (start_bitrate_bps > 0) - delay_based_bwe_->SetStartBitrate(start_bitrate_bps); + delay_based_bwe_->SetStartBitrate(DataRate::bps(start_bitrate_bps)); min_bitrate_bps_ = min_bitrate_bps; - delay_based_bwe_->SetMinBitrate(min_bitrate_bps_); + delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps_)); } MaybeTriggerOnNetworkChanged(); } @@ -260,8 +260,10 @@ void SendSideCongestionController::OnNetworkRouteChanged( min_bitrate_bps_ = min_bitrate_bps; delay_based_bwe_.reset(new DelayBasedBwe(event_log_)); acknowledged_bitrate_estimator_.reset(new AcknowledgedBitrateEstimator()); - delay_based_bwe_->SetStartBitrate(bitrate_bps); - delay_based_bwe_->SetMinBitrate(min_bitrate_bps); + if (bitrate_bps > 0) { + delay_based_bwe_->SetStartBitrate(DataRate::bps(bitrate_bps)); + } + delay_based_bwe_->SetMinBitrate(DataRate::bps(min_bitrate_bps)); } { rtc::CritScope cs(&probe_lock_); @@ -338,7 +340,7 @@ void SendSideCongestionController::OnSentPacket( void SendSideCongestionController::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { rtc::CritScope cs(&bwe_lock_); - delay_based_bwe_->OnRttUpdate(avg_rtt_ms); + delay_based_bwe_->OnRttUpdate(TimeDelta::ms(avg_rtt_ms)); } int64_t SendSideCongestionController::TimeUntilNextProcess() { @@ -415,8 +417,8 @@ void SendSideCongestionController::OnTransportFeedback( { rtc::CritScope cs(&bwe_lock_); result = delay_based_bwe_->IncomingPacketFeedbackVector( - feedback_vector, acknowledged_bitrate_estimator_->bitrate_bps(), - clock_->TimeInMilliseconds()); + feedback_vector, acknowledged_bitrate_estimator_->bitrate(), + Timestamp::ms(clock_->TimeInMilliseconds())); } if (result.updated) { bitrate_controller_->OnDelayBasedBweResult(result); @@ -518,7 +520,7 @@ void SendSideCongestionController::MaybeTriggerOnNetworkChanged() { int64_t probing_interval_ms; { rtc::CritScope cs(&bwe_lock_); - probing_interval_ms = delay_based_bwe_->GetExpectedBwePeriodMs(); + probing_interval_ms = delay_based_bwe_->GetExpectedBwePeriod().ms(); } { rtc::CritScope cs(&observer_lock_); diff --git a/modules/remote_bitrate_estimator/test/estimators/send_side.cc b/modules/remote_bitrate_estimator/test/estimators/send_side.cc index a444437580..2907563947 100644 --- a/modules/remote_bitrate_estimator/test/estimators/send_side.cc +++ b/modules/remote_bitrate_estimator/test/estimators/send_side.cc @@ -44,7 +44,7 @@ SendSideBweSender::SendSideBweSender(int kbps, bitrate_controller_->SetStartBitrate(1000 * kbps); bitrate_controller_->SetMinMaxBitrate(1000 * kMinBitrateKbps, 1000 * kMaxBitrateKbps); - bwe_->SetMinBitrate(1000 * kMinBitrateKbps); + bwe_->SetMinBitrate(DataRate::kbps(kMinBitrateKbps)); } SendSideBweSender::~SendSideBweSender() {} @@ -72,7 +72,7 @@ void SendSideBweSender::GiveFeedback(const FeedbackPacket& feedback) { int64_t rtt_ms = clock_->TimeInMilliseconds() - feedback.latest_send_time_ms(); - bwe_->OnRttUpdate(rtt_ms); + bwe_->OnRttUpdate(TimeDelta::ms(rtt_ms)); BWE_TEST_LOGGING_PLOT(1, "RTT", clock_->TimeInMilliseconds(), rtt_ms); std::sort(packet_feedback_vector.begin(), packet_feedback_vector.end(), @@ -80,8 +80,8 @@ void SendSideBweSender::GiveFeedback(const FeedbackPacket& feedback) { acknowledged_bitrate_estimator_->IncomingPacketFeedbackVector( packet_feedback_vector); DelayBasedBwe::Result result = bwe_->IncomingPacketFeedbackVector( - packet_feedback_vector, acknowledged_bitrate_estimator_->bitrate_bps(), - clock_->TimeInMilliseconds()); + packet_feedback_vector, acknowledged_bitrate_estimator_->bitrate(), + Timestamp::ms(clock_->TimeInMilliseconds())); if (result.updated) bitrate_controller_->OnDelayBasedBweResult(result);