pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/bitrate_controller/send_side_bandwidth_estimation.h" |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 12 | |
jbauch | f91e6d0 | 2016-01-24 23:05:21 -0800 | [diff] [blame] | 13 | #include <algorithm> |
Piotr Tworek | 5e4833c | 2017-12-12 12:09:31 +0100 | [diff] [blame] | 14 | #include <cstdio> |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 15 | #include <limits> |
| 16 | #include <string> |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 17 | |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 18 | #include "absl/memory/memory.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 19 | #include "logging/rtc_event_log/events/rtc_event.h" |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 20 | #include "logging/rtc_event_log/events/rtc_event_bwe_update_loss_based.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 21 | #include "logging/rtc_event_log/rtc_event_log.h" |
| 22 | #include "modules/remote_bitrate_estimator/include/bwe_defines.h" |
| 23 | #include "rtc_base/checks.h" |
| 24 | #include "rtc_base/logging.h" |
| 25 | #include "system_wrappers/include/field_trial.h" |
| 26 | #include "system_wrappers/include/metrics.h" |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 27 | |
| 28 | namespace webrtc { |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 29 | namespace { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 30 | constexpr TimeDelta kBweIncreaseInterval = TimeDelta::Millis<1000>(); |
| 31 | constexpr TimeDelta kBweDecreaseInterval = TimeDelta::Millis<300>(); |
| 32 | constexpr TimeDelta kStartPhase = TimeDelta::Millis<2000>(); |
| 33 | constexpr TimeDelta kBweConverganceTime = TimeDelta::Millis<20000>(); |
| 34 | constexpr int kLimitNumPackets = 20; |
| 35 | constexpr DataRate kDefaultMaxBitrate = DataRate::BitsPerSec<1000000000>(); |
| 36 | constexpr TimeDelta kLowBitrateLogPeriod = TimeDelta::Millis<10000>(); |
| 37 | constexpr TimeDelta kRtcEventLogPeriod = TimeDelta::Millis<5000>(); |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 38 | // Expecting that RTCP feedback is sent uniformly within [0.5, 1.5]s intervals. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 39 | constexpr TimeDelta kMaxRtcpFeedbackInterval = TimeDelta::Millis<5000>(); |
| 40 | constexpr int kFeedbackTimeoutIntervals = 3; |
| 41 | constexpr TimeDelta kTimeoutInterval = TimeDelta::Millis<1000>(); |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 42 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 43 | constexpr float kDefaultLowLossThreshold = 0.02f; |
| 44 | constexpr float kDefaultHighLossThreshold = 0.1f; |
| 45 | constexpr DataRate kDefaultBitrateThreshold = DataRate::Zero(); |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 46 | |
stefan@webrtc.org | 474e36e | 2015-01-19 15:44:47 +0000 | [diff] [blame] | 47 | struct UmaRampUpMetric { |
| 48 | const char* metric_name; |
| 49 | int bitrate_kbps; |
| 50 | }; |
| 51 | |
| 52 | const UmaRampUpMetric kUmaRampupMetrics[] = { |
| 53 | {"WebRTC.BWE.RampUpTimeTo500kbpsInMs", 500}, |
| 54 | {"WebRTC.BWE.RampUpTimeTo1000kbpsInMs", 1000}, |
| 55 | {"WebRTC.BWE.RampUpTimeTo2000kbpsInMs", 2000}}; |
| 56 | const size_t kNumUmaRampupMetrics = |
| 57 | sizeof(kUmaRampupMetrics) / sizeof(kUmaRampupMetrics[0]); |
| 58 | |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 59 | const char kBweLosExperiment[] = "WebRTC-BweLossExperiment"; |
| 60 | |
| 61 | bool BweLossExperimentIsEnabled() { |
| 62 | std::string experiment_string = |
| 63 | webrtc::field_trial::FindFullName(kBweLosExperiment); |
| 64 | // The experiment is enabled iff the field trial string begins with "Enabled". |
| 65 | return experiment_string.find("Enabled") == 0; |
| 66 | } |
| 67 | |
| 68 | bool ReadBweLossExperimentParameters(float* low_loss_threshold, |
| 69 | float* high_loss_threshold, |
| 70 | uint32_t* bitrate_threshold_kbps) { |
| 71 | RTC_DCHECK(low_loss_threshold); |
| 72 | RTC_DCHECK(high_loss_threshold); |
| 73 | RTC_DCHECK(bitrate_threshold_kbps); |
| 74 | std::string experiment_string = |
| 75 | webrtc::field_trial::FindFullName(kBweLosExperiment); |
| 76 | int parsed_values = |
| 77 | sscanf(experiment_string.c_str(), "Enabled-%f,%f,%u", low_loss_threshold, |
| 78 | high_loss_threshold, bitrate_threshold_kbps); |
| 79 | if (parsed_values == 3) { |
| 80 | RTC_CHECK_GT(*low_loss_threshold, 0.0f) |
| 81 | << "Loss threshold must be greater than 0."; |
| 82 | RTC_CHECK_LE(*low_loss_threshold, 1.0f) |
| 83 | << "Loss threshold must be less than or equal to 1."; |
| 84 | RTC_CHECK_GT(*high_loss_threshold, 0.0f) |
| 85 | << "Loss threshold must be greater than 0."; |
| 86 | RTC_CHECK_LE(*high_loss_threshold, 1.0f) |
| 87 | << "Loss threshold must be less than or equal to 1."; |
| 88 | RTC_CHECK_LE(*low_loss_threshold, *high_loss_threshold) |
| 89 | << "The low loss threshold must be less than or equal to the high loss " |
| 90 | "threshold."; |
| 91 | RTC_CHECK_GE(*bitrate_threshold_kbps, 0) |
| 92 | << "Bitrate threshold can't be negative."; |
| 93 | RTC_CHECK_LT(*bitrate_threshold_kbps, |
| 94 | std::numeric_limits<int>::max() / 1000) |
| 95 | << "Bitrate must be smaller enough to avoid overflows."; |
| 96 | return true; |
| 97 | } |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 98 | RTC_LOG(LS_WARNING) << "Failed to parse parameters for BweLossExperiment " |
| 99 | "experiment from field trial string. Using default."; |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 100 | *low_loss_threshold = kDefaultLowLossThreshold; |
| 101 | *high_loss_threshold = kDefaultHighLossThreshold; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 102 | *bitrate_threshold_kbps = kDefaultBitrateThreshold.kbps(); |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 103 | return false; |
| 104 | } |
jbauch | f91e6d0 | 2016-01-24 23:05:21 -0800 | [diff] [blame] | 105 | } // namespace |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 106 | |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 107 | LinkCapacityTracker::LinkCapacityTracker() |
| 108 | : tracking_rate("rate", TimeDelta::seconds(10)) { |
| 109 | ParseFieldTrial({&tracking_rate}, |
| 110 | field_trial::FindFullName("WebRTC-Bwe-LinkCapacity")); |
| 111 | } |
| 112 | |
| 113 | LinkCapacityTracker::~LinkCapacityTracker() {} |
| 114 | |
| 115 | void LinkCapacityTracker::OnOveruse(DataRate acknowledged_rate, |
| 116 | Timestamp at_time) { |
| 117 | capacity_estimate_bps_ = |
| 118 | std::min(capacity_estimate_bps_, acknowledged_rate.bps<double>()); |
| 119 | last_link_capacity_update_ = at_time; |
| 120 | } |
| 121 | |
| 122 | void LinkCapacityTracker::OnStartingRate(DataRate start_rate) { |
| 123 | if (last_link_capacity_update_.IsInfinite()) |
| 124 | capacity_estimate_bps_ = start_rate.bps<double>(); |
| 125 | } |
| 126 | |
| 127 | void LinkCapacityTracker::OnRateUpdate(DataRate acknowledged, |
| 128 | Timestamp at_time) { |
| 129 | if (acknowledged.bps() > capacity_estimate_bps_) { |
| 130 | TimeDelta delta = at_time - last_link_capacity_update_; |
| 131 | double alpha = delta.IsFinite() ? exp(-(delta / tracking_rate.Get())) : 0; |
| 132 | capacity_estimate_bps_ = alpha * capacity_estimate_bps_ + |
| 133 | (1 - alpha) * acknowledged.bps<double>(); |
| 134 | } |
| 135 | last_link_capacity_update_ = at_time; |
| 136 | } |
| 137 | |
| 138 | void LinkCapacityTracker::OnRttBackoff(DataRate backoff_rate, |
| 139 | Timestamp at_time) { |
| 140 | capacity_estimate_bps_ = |
| 141 | std::min(capacity_estimate_bps_, backoff_rate.bps<double>()); |
| 142 | last_link_capacity_update_ = at_time; |
| 143 | } |
| 144 | |
| 145 | DataRate LinkCapacityTracker::estimate() const { |
| 146 | return DataRate::bps(capacity_estimate_bps_); |
| 147 | } |
| 148 | |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 149 | RttBasedBackoff::RttBasedBackoff() |
| 150 | : rtt_limit_("limit", TimeDelta::PlusInfinity()), |
| 151 | drop_fraction_("fraction", 0.5), |
| 152 | drop_interval_("interval", TimeDelta::ms(300)), |
| 153 | persist_on_route_change_("persist"), |
| 154 | // By initializing this to plus infinity, we make sure that we never |
| 155 | // trigger rtt backoff unless packet feedback is enabled. |
| 156 | last_propagation_rtt_update_(Timestamp::PlusInfinity()), |
| 157 | last_propagation_rtt_(TimeDelta::Zero()) { |
| 158 | ParseFieldTrial({&rtt_limit_, &drop_fraction_, &drop_interval_, |
| 159 | &persist_on_route_change_}, |
| 160 | field_trial::FindFullName("WebRTC-Bwe-MaxRttLimit")); |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 161 | } |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 162 | |
| 163 | void RttBasedBackoff::OnRouteChange() { |
| 164 | if (!persist_on_route_change_) { |
| 165 | last_propagation_rtt_update_ = Timestamp::PlusInfinity(); |
| 166 | last_propagation_rtt_ = TimeDelta::Zero(); |
| 167 | } |
| 168 | } |
| 169 | |
| 170 | void RttBasedBackoff::UpdatePropagationRtt(Timestamp at_time, |
| 171 | TimeDelta propagation_rtt) { |
| 172 | last_propagation_rtt_update_ = at_time; |
| 173 | last_propagation_rtt_ = propagation_rtt; |
| 174 | } |
| 175 | |
| 176 | TimeDelta RttBasedBackoff::RttLowerBound(Timestamp at_time) const { |
| 177 | // TODO(srte): Use time since last unacknowledged packet for this. |
| 178 | TimeDelta time_since_rtt = at_time - last_propagation_rtt_update_; |
| 179 | return time_since_rtt + last_propagation_rtt_; |
| 180 | } |
| 181 | |
| 182 | RttBasedBackoff::~RttBasedBackoff() = default; |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 183 | |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 184 | SendSideBandwidthEstimation::SendSideBandwidthEstimation(RtcEventLog* event_log) |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 185 | : lost_packets_since_last_loss_update_(0), |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 186 | expected_packets_since_last_loss_update_(0), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 187 | current_bitrate_(DataRate::Zero()), |
| 188 | min_bitrate_configured_( |
| 189 | DataRate::bps(congestion_controller::GetMinBitrateBps())), |
| 190 | max_bitrate_configured_(kDefaultMaxBitrate), |
| 191 | last_low_bitrate_log_(Timestamp::MinusInfinity()), |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 192 | has_decreased_since_last_fraction_loss_(false), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 193 | last_loss_feedback_(Timestamp::MinusInfinity()), |
| 194 | last_loss_packet_report_(Timestamp::MinusInfinity()), |
| 195 | last_timeout_(Timestamp::MinusInfinity()), |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 196 | last_fraction_loss_(0), |
stefan | 3821ff8 | 2016-09-04 05:07:26 -0700 | [diff] [blame] | 197 | last_logged_fraction_loss_(0), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 198 | last_round_trip_time_(TimeDelta::Zero()), |
| 199 | bwe_incoming_(DataRate::Zero()), |
| 200 | delay_based_bitrate_(DataRate::Zero()), |
| 201 | time_last_decrease_(Timestamp::MinusInfinity()), |
| 202 | first_report_time_(Timestamp::MinusInfinity()), |
stefan@webrtc.org | 548b228 | 2014-11-03 14:42:43 +0000 | [diff] [blame] | 203 | initially_lost_packets_(0), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 204 | bitrate_at_2_seconds_(DataRate::Zero()), |
stefan@webrtc.org | 474e36e | 2015-01-19 15:44:47 +0000 | [diff] [blame] | 205 | uma_update_state_(kNoUpdate), |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 206 | uma_rtt_state_(kNoUpdate), |
terelius | 006d93d | 2015-11-05 12:02:15 -0800 | [diff] [blame] | 207 | rampup_uma_stats_updated_(kNumUmaRampupMetrics, false), |
stefan | 3821ff8 | 2016-09-04 05:07:26 -0700 | [diff] [blame] | 208 | event_log_(event_log), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 209 | last_rtc_event_log_(Timestamp::MinusInfinity()), |
sprang | c1b57a1 | 2017-02-28 08:50:47 -0800 | [diff] [blame] | 210 | in_timeout_experiment_( |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 211 | webrtc::field_trial::IsEnabled("WebRTC-FeedbackTimeout")), |
| 212 | low_loss_threshold_(kDefaultLowLossThreshold), |
| 213 | high_loss_threshold_(kDefaultHighLossThreshold), |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 214 | bitrate_threshold_(kDefaultBitrateThreshold) { |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 215 | RTC_DCHECK(event_log); |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 216 | if (BweLossExperimentIsEnabled()) { |
| 217 | uint32_t bitrate_threshold_kbps; |
| 218 | if (ReadBweLossExperimentParameters(&low_loss_threshold_, |
| 219 | &high_loss_threshold_, |
| 220 | &bitrate_threshold_kbps)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 221 | RTC_LOG(LS_INFO) << "Enabled BweLossExperiment with parameters " |
| 222 | << low_loss_threshold_ << ", " << high_loss_threshold_ |
| 223 | << ", " << bitrate_threshold_kbps; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 224 | bitrate_threshold_ = DataRate::kbps(bitrate_threshold_kbps); |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 225 | } |
| 226 | } |
ivoc | 14d5dbe | 2016-07-04 07:06:55 -0700 | [diff] [blame] | 227 | } |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 228 | |
andresp@webrtc.org | 16b75c2 | 2014-03-21 14:00:51 +0000 | [diff] [blame] | 229 | SendSideBandwidthEstimation::~SendSideBandwidthEstimation() {} |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 230 | |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 231 | void SendSideBandwidthEstimation::OnRouteChange() { |
| 232 | lost_packets_since_last_loss_update_ = 0; |
| 233 | expected_packets_since_last_loss_update_ = 0; |
| 234 | current_bitrate_ = DataRate::Zero(); |
| 235 | min_bitrate_configured_ = |
| 236 | DataRate::bps(congestion_controller::GetMinBitrateBps()); |
| 237 | max_bitrate_configured_ = kDefaultMaxBitrate; |
| 238 | last_low_bitrate_log_ = Timestamp::MinusInfinity(); |
| 239 | has_decreased_since_last_fraction_loss_ = false; |
| 240 | last_loss_feedback_ = Timestamp::MinusInfinity(); |
| 241 | last_loss_packet_report_ = Timestamp::MinusInfinity(); |
| 242 | last_timeout_ = Timestamp::MinusInfinity(); |
| 243 | last_fraction_loss_ = 0; |
| 244 | last_logged_fraction_loss_ = 0; |
| 245 | last_round_trip_time_ = TimeDelta::Zero(); |
| 246 | bwe_incoming_ = DataRate::Zero(); |
| 247 | delay_based_bitrate_ = DataRate::Zero(); |
| 248 | time_last_decrease_ = Timestamp::MinusInfinity(); |
| 249 | first_report_time_ = Timestamp::MinusInfinity(); |
| 250 | initially_lost_packets_ = 0; |
| 251 | bitrate_at_2_seconds_ = DataRate::Zero(); |
| 252 | uma_update_state_ = kNoUpdate; |
| 253 | uma_rtt_state_ = kNoUpdate; |
| 254 | last_rtc_event_log_ = Timestamp::MinusInfinity(); |
| 255 | |
| 256 | rtt_backoff_.OnRouteChange(); |
| 257 | } |
| 258 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 259 | void SendSideBandwidthEstimation::SetBitrates( |
| 260 | absl::optional<DataRate> send_bitrate, |
| 261 | DataRate min_bitrate, |
| 262 | DataRate max_bitrate, |
| 263 | Timestamp at_time) { |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 264 | SetMinMaxBitrate(min_bitrate, max_bitrate); |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 265 | if (send_bitrate) { |
| 266 | link_capacity_.OnStartingRate(*send_bitrate); |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 267 | SetSendBitrate(*send_bitrate, at_time); |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 268 | } |
philipel | c6957c7 | 2016-04-28 15:52:49 +0200 | [diff] [blame] | 269 | } |
| 270 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 271 | void SendSideBandwidthEstimation::SetSendBitrate(DataRate bitrate, |
| 272 | Timestamp at_time) { |
| 273 | RTC_DCHECK(bitrate > DataRate::Zero()); |
| 274 | // Reset to avoid being capped by the estimate. |
| 275 | delay_based_bitrate_ = DataRate::Zero(); |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 276 | if (loss_based_bandwidth_estimation_.Enabled()) { |
| 277 | loss_based_bandwidth_estimation_.MaybeReset(bitrate); |
| 278 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 279 | CapBitrateToThresholds(at_time, bitrate); |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 280 | // Clear last sent bitrate history so the new value can be used directly |
| 281 | // and not capped. |
| 282 | min_bitrate_history_.clear(); |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 283 | } |
| 284 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 285 | void SendSideBandwidthEstimation::SetMinMaxBitrate(DataRate min_bitrate, |
| 286 | DataRate max_bitrate) { |
michaelt | f082c2a | 2016-11-07 04:17:14 -0800 | [diff] [blame] | 287 | min_bitrate_configured_ = |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 288 | std::max(min_bitrate, congestion_controller::GetMinBitrate()); |
| 289 | if (max_bitrate > DataRate::Zero() && max_bitrate.IsFinite()) { |
| 290 | max_bitrate_configured_ = std::max(min_bitrate_configured_, max_bitrate); |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 291 | } else { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 292 | max_bitrate_configured_ = kDefaultMaxBitrate; |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 293 | } |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 296 | int SendSideBandwidthEstimation::GetMinBitrate() const { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 297 | return min_bitrate_configured_.bps<int>(); |
henrik.lundin@webrtc.org | 845862f | 2014-03-06 07:19:28 +0000 | [diff] [blame] | 298 | } |
| 299 | |
Stefan Holmer | e590416 | 2015-03-26 11:11:06 +0100 | [diff] [blame] | 300 | void SendSideBandwidthEstimation::CurrentEstimate(int* bitrate, |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 301 | uint8_t* loss, |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 +0000 | [diff] [blame] | 302 | int64_t* rtt) const { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 303 | *bitrate = current_bitrate_.bps<int>(); |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 304 | *loss = last_fraction_loss_; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 305 | *rtt = last_round_trip_time_.ms<int64_t>(); |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 306 | } |
| 307 | |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 308 | DataRate SendSideBandwidthEstimation::GetEstimatedLinkCapacity() const { |
| 309 | return link_capacity_.estimate(); |
| 310 | } |
| 311 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 312 | void SendSideBandwidthEstimation::UpdateReceiverEstimate(Timestamp at_time, |
| 313 | DataRate bandwidth) { |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 314 | bwe_incoming_ = bandwidth; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 315 | CapBitrateToThresholds(at_time, current_bitrate_); |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 318 | void SendSideBandwidthEstimation::UpdateDelayBasedEstimate(Timestamp at_time, |
| 319 | DataRate bitrate) { |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 320 | if (acknowledged_rate_) { |
| 321 | if (bitrate < delay_based_bitrate_) { |
| 322 | link_capacity_.OnOveruse(*acknowledged_rate_, at_time); |
| 323 | } |
| 324 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 325 | delay_based_bitrate_ = bitrate; |
| 326 | CapBitrateToThresholds(at_time, current_bitrate_); |
stefan | 32f8154 | 2016-01-20 07:13:58 -0800 | [diff] [blame] | 327 | } |
| 328 | |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 329 | void SendSideBandwidthEstimation::SetAcknowledgedRate( |
| 330 | absl::optional<DataRate> acknowledged_rate, |
| 331 | Timestamp at_time) { |
| 332 | acknowledged_rate_ = acknowledged_rate; |
| 333 | if (acknowledged_rate && loss_based_bandwidth_estimation_.Enabled()) { |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 334 | loss_based_bandwidth_estimation_.UpdateAcknowledgedBitrate( |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 335 | *acknowledged_rate, at_time); |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 336 | } |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | void SendSideBandwidthEstimation::IncomingPacketFeedbackVector( |
| 340 | const TransportPacketsFeedback& report) { |
| 341 | if (loss_based_bandwidth_estimation_.Enabled()) { |
| 342 | loss_based_bandwidth_estimation_.UpdateLossStatistics( |
| 343 | report.packet_feedbacks, report.feedback_time); |
| 344 | } |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 345 | } |
| 346 | |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 347 | void SendSideBandwidthEstimation::UpdateReceiverBlock(uint8_t fraction_loss, |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 348 | TimeDelta rtt, |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 349 | int number_of_packets, |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 350 | Timestamp at_time) { |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 351 | const int kRoundingConstant = 128; |
| 352 | int packets_lost = (static_cast<int>(fraction_loss) * number_of_packets + |
| 353 | kRoundingConstant) >> |
| 354 | 8; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 355 | UpdatePacketsLost(packets_lost, number_of_packets, at_time); |
| 356 | UpdateRtt(rtt, at_time); |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | void SendSideBandwidthEstimation::UpdatePacketsLost(int packets_lost, |
| 360 | int number_of_packets, |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 361 | Timestamp at_time) { |
| 362 | last_loss_feedback_ = at_time; |
| 363 | if (first_report_time_.IsInfinite()) |
| 364 | first_report_time_ = at_time; |
stefan@webrtc.org | 83d4804 | 2014-11-10 13:55:16 +0000 | [diff] [blame] | 365 | |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 366 | // Check sequence number diff and weight loss report |
| 367 | if (number_of_packets > 0) { |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 368 | // Accumulate reports. |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 369 | lost_packets_since_last_loss_update_ += packets_lost; |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 370 | expected_packets_since_last_loss_update_ += number_of_packets; |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 371 | |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 372 | // Don't generate a loss rate until it can be based on enough packets. |
| 373 | if (expected_packets_since_last_loss_update_ < kLimitNumPackets) |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 374 | return; |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 375 | |
| 376 | has_decreased_since_last_fraction_loss_ = false; |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 377 | int64_t lost_q8 = lost_packets_since_last_loss_update_ << 8; |
| 378 | int64_t expected = expected_packets_since_last_loss_update_; |
| 379 | last_fraction_loss_ = std::min<int>(lost_q8 / expected, 255); |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 380 | |
| 381 | // Reset accumulators. |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 382 | |
| 383 | lost_packets_since_last_loss_update_ = 0; |
pbos | b7edb88 | 2015-10-22 08:52:20 -0700 | [diff] [blame] | 384 | expected_packets_since_last_loss_update_ = 0; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 385 | last_loss_packet_report_ = at_time; |
| 386 | UpdateEstimate(at_time); |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 387 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 388 | UpdateUmaStatsPacketsLost(at_time, packets_lost); |
stefan@webrtc.org | db26247 | 2014-11-04 19:32:10 +0000 | [diff] [blame] | 389 | } |
| 390 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 391 | void SendSideBandwidthEstimation::UpdateUmaStatsPacketsLost(Timestamp at_time, |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 392 | int packets_lost) { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 393 | DataRate bitrate_kbps = DataRate::kbps((current_bitrate_.bps() + 500) / 1000); |
stefan@webrtc.org | 474e36e | 2015-01-19 15:44:47 +0000 | [diff] [blame] | 394 | for (size_t i = 0; i < kNumUmaRampupMetrics; ++i) { |
| 395 | if (!rampup_uma_stats_updated_[i] && |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 396 | bitrate_kbps.kbps() >= kUmaRampupMetrics[i].bitrate_kbps) { |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 397 | RTC_HISTOGRAMS_COUNTS_100000(i, kUmaRampupMetrics[i].metric_name, |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 398 | (at_time - first_report_time_).ms()); |
stefan@webrtc.org | 474e36e | 2015-01-19 15:44:47 +0000 | [diff] [blame] | 399 | rampup_uma_stats_updated_[i] = true; |
| 400 | } |
| 401 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 402 | if (IsInStartPhase(at_time)) { |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 403 | initially_lost_packets_ += packets_lost; |
stefan@webrtc.org | db26247 | 2014-11-04 19:32:10 +0000 | [diff] [blame] | 404 | } else if (uma_update_state_ == kNoUpdate) { |
| 405 | uma_update_state_ = kFirstDone; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 406 | bitrate_at_2_seconds_ = bitrate_kbps; |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 407 | RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitiallyLostPackets", |
| 408 | initially_lost_packets_, 0, 100, 50); |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 409 | RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialBandwidthEstimate", |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 410 | bitrate_at_2_seconds_.kbps(), 0, 2000, 50); |
stefan@webrtc.org | db26247 | 2014-11-04 19:32:10 +0000 | [diff] [blame] | 411 | } else if (uma_update_state_ == kFirstDone && |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 412 | at_time - first_report_time_ >= kBweConverganceTime) { |
stefan@webrtc.org | db26247 | 2014-11-04 19:32:10 +0000 | [diff] [blame] | 413 | uma_update_state_ = kDone; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 414 | int bitrate_diff_kbps = std::max( |
| 415 | bitrate_at_2_seconds_.kbps<int>() - bitrate_kbps.kbps<int>(), 0); |
asapersson | 1d02d3e | 2016-09-09 22:40:25 -0700 | [diff] [blame] | 416 | RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialVsConvergedDiff", bitrate_diff_kbps, |
| 417 | 0, 2000, 50); |
stefan@webrtc.org | 548b228 | 2014-11-03 14:42:43 +0000 | [diff] [blame] | 418 | } |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 419 | } |
| 420 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 421 | void SendSideBandwidthEstimation::UpdateRtt(TimeDelta rtt, Timestamp at_time) { |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 422 | // Update RTT if we were able to compute an RTT based on this RTCP. |
| 423 | // FlexFEC doesn't send RTCP SR, which means we won't be able to compute RTT. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 424 | if (rtt > TimeDelta::Zero()) |
| 425 | last_round_trip_time_ = rtt; |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 426 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 427 | if (!IsInStartPhase(at_time) && uma_rtt_state_ == kNoUpdate) { |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 428 | uma_rtt_state_ = kDone; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 429 | RTC_HISTOGRAM_COUNTS("WebRTC.BWE.InitialRtt", rtt.ms<int>(), 0, 2000, 50); |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 430 | } |
| 431 | } |
| 432 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 433 | void SendSideBandwidthEstimation::UpdateEstimate(Timestamp at_time) { |
| 434 | DataRate new_bitrate = current_bitrate_; |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 435 | if (rtt_backoff_.RttLowerBound(at_time) > rtt_backoff_.rtt_limit_) { |
| 436 | if (at_time - time_last_decrease_ >= rtt_backoff_.drop_interval_) { |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 437 | time_last_decrease_ = at_time; |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 438 | new_bitrate = current_bitrate_ * rtt_backoff_.drop_fraction_; |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 439 | link_capacity_.OnRttBackoff(new_bitrate, at_time); |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 440 | } |
| 441 | CapBitrateToThresholds(at_time, new_bitrate); |
| 442 | return; |
| 443 | } |
| 444 | |
stefan | fa15669 | 2016-01-21 08:55:03 -0800 | [diff] [blame] | 445 | // We trust the REMB and/or delay-based estimate during the first 2 seconds if |
| 446 | // we haven't had any packet loss reported, to allow startup bitrate probing. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 447 | if (last_fraction_loss_ == 0 && IsInStartPhase(at_time)) { |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 448 | new_bitrate = std::max(bwe_incoming_, new_bitrate); |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 449 | new_bitrate = std::max(delay_based_bitrate_, new_bitrate); |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 450 | if (loss_based_bandwidth_estimation_.Enabled()) { |
| 451 | loss_based_bandwidth_estimation_.SetInitialBitrate(new_bitrate); |
| 452 | } |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 453 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 454 | if (new_bitrate != current_bitrate_) { |
stefan | fa15669 | 2016-01-21 08:55:03 -0800 | [diff] [blame] | 455 | min_bitrate_history_.clear(); |
Christoffer Rodbro | 982639c | 2019-01-18 15:34:59 +0100 | [diff] [blame^] | 456 | if (loss_based_bandwidth_estimation_.Enabled()) { |
| 457 | min_bitrate_history_.push_back(std::make_pair(at_time, new_bitrate)); |
| 458 | } else { |
| 459 | min_bitrate_history_.push_back( |
| 460 | std::make_pair(at_time, current_bitrate_)); |
| 461 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 462 | CapBitrateToThresholds(at_time, new_bitrate); |
stefan | fa15669 | 2016-01-21 08:55:03 -0800 | [diff] [blame] | 463 | return; |
| 464 | } |
stefan@webrtc.org | 82462aa | 2014-10-23 11:57:05 +0000 | [diff] [blame] | 465 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 466 | UpdateMinHistory(at_time); |
| 467 | if (last_loss_packet_report_.IsInfinite()) { |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 468 | // No feedback received. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 469 | CapBitrateToThresholds(at_time, current_bitrate_); |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 470 | return; |
| 471 | } |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 472 | |
| 473 | if (loss_based_bandwidth_estimation_.Enabled()) { |
| 474 | loss_based_bandwidth_estimation_.Update( |
| 475 | at_time, min_bitrate_history_.front().second, last_round_trip_time_); |
| 476 | new_bitrate = MaybeRampupOrBackoff(new_bitrate, at_time); |
| 477 | CapBitrateToThresholds(at_time, new_bitrate); |
| 478 | return; |
| 479 | } |
| 480 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 481 | TimeDelta time_since_loss_packet_report = at_time - last_loss_packet_report_; |
| 482 | TimeDelta time_since_loss_feedback = at_time - last_loss_feedback_; |
| 483 | if (time_since_loss_packet_report < 1.2 * kMaxRtcpFeedbackInterval) { |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 484 | // We only care about loss above a given bitrate threshold. |
| 485 | float loss = last_fraction_loss_ / 256.0f; |
| 486 | // We only make decisions based on loss when the bitrate is above a |
| 487 | // threshold. This is a crude way of handling loss which is uncorrelated |
| 488 | // to congestion. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 489 | if (current_bitrate_ < bitrate_threshold_ || loss <= low_loss_threshold_) { |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 490 | // Loss < 2%: Increase rate by 8% of the min bitrate in the last |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 491 | // kBweIncreaseInterval. |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 492 | // Note that by remembering the bitrate over the last second one can |
| 493 | // rampup up one second faster than if only allowed to start ramping |
| 494 | // at 8% per second rate now. E.g.: |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 495 | // If sending a constant 100kbps it can rampup immediately to 108kbps |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 496 | // whenever a receiver report is received with lower packet loss. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 497 | // If instead one would do: current_bitrate_ *= 1.08^(delta time), |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 498 | // it would take over one second since the lower packet loss to achieve |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 499 | // 108kbps. |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 500 | new_bitrate = |
| 501 | DataRate::bps(min_bitrate_history_.front().second.bps() * 1.08 + 0.5); |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 502 | |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 503 | // Add 1 kbps extra, just to make sure that we do not get stuck |
| 504 | // (gives a little extra increase at low rates, negligible at higher |
| 505 | // rates). |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 506 | new_bitrate += DataRate::bps(1000); |
| 507 | } else if (current_bitrate_ > bitrate_threshold_) { |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 508 | if (loss <= high_loss_threshold_) { |
| 509 | // Loss between 2% - 10%: Do nothing. |
| 510 | } else { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 511 | // Loss > 10%: Limit the rate decreases to once a kBweDecreaseInterval |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 512 | // + rtt. |
| 513 | if (!has_decreased_since_last_fraction_loss_ && |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 514 | (at_time - time_last_decrease_) >= |
| 515 | (kBweDecreaseInterval + last_round_trip_time_)) { |
| 516 | time_last_decrease_ = at_time; |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 517 | |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 518 | // Reduce rate: |
| 519 | // newRate = rate * (1 - 0.5*lossRate); |
| 520 | // where packetLoss = 256*lossRate; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 521 | new_bitrate = |
| 522 | DataRate::bps((current_bitrate_.bps() * |
| 523 | static_cast<double>(512 - last_fraction_loss_)) / |
| 524 | 512.0); |
Stefan Holmer | 9c79ed9 | 2017-03-31 15:53:27 +0200 | [diff] [blame] | 525 | has_decreased_since_last_fraction_loss_ = true; |
| 526 | } |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 527 | } |
andresp@webrtc.org | 07bc734 | 2014-03-21 16:51:01 +0000 | [diff] [blame] | 528 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 529 | } else if (time_since_loss_feedback > |
| 530 | kFeedbackTimeoutIntervals * kMaxRtcpFeedbackInterval && |
| 531 | (last_timeout_.IsInfinite() || |
| 532 | at_time - last_timeout_ > kTimeoutInterval)) { |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 533 | if (in_timeout_experiment_) { |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 534 | RTC_LOG(LS_WARNING) << "Feedback timed out (" |
| 535 | << ToString(time_since_loss_feedback) |
| 536 | << "), reducing bitrate."; |
| 537 | new_bitrate = new_bitrate * 0.8; |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 538 | // Reset accumulators since we've already acted on missing feedback and |
| 539 | // shouldn't to act again on these old lost packets. |
Sebastian Jansson | 439f0bc | 2018-02-20 10:46:39 +0100 | [diff] [blame] | 540 | lost_packets_since_last_loss_update_ = 0; |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 541 | expected_packets_since_last_loss_update_ = 0; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 542 | last_timeout_ = at_time; |
Stefan Holmer | 52200d0 | 2016-09-20 14:14:23 +0200 | [diff] [blame] | 543 | } |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 544 | } |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 545 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 546 | CapBitrateToThresholds(at_time, new_bitrate); |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 547 | } |
andresp@webrtc.org | 4e69f78 | 2014-03-17 17:07:48 +0000 | [diff] [blame] | 548 | |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 549 | void SendSideBandwidthEstimation::UpdatePropagationRtt( |
| 550 | Timestamp at_time, |
| 551 | TimeDelta propagation_rtt) { |
Sebastian Jansson | 2464348 | 2018-11-14 14:19:45 +0100 | [diff] [blame] | 552 | rtt_backoff_.UpdatePropagationRtt(at_time, propagation_rtt); |
Sebastian Jansson | 2e068e8 | 2018-10-08 12:49:53 +0200 | [diff] [blame] | 553 | } |
| 554 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 555 | bool SendSideBandwidthEstimation::IsInStartPhase(Timestamp at_time) const { |
| 556 | return first_report_time_.IsInfinite() || |
| 557 | at_time - first_report_time_ < kStartPhase; |
stefan@webrtc.org | 548b228 | 2014-11-03 14:42:43 +0000 | [diff] [blame] | 558 | } |
| 559 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 560 | void SendSideBandwidthEstimation::UpdateMinHistory(Timestamp at_time) { |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 561 | // Remove old data points from history. |
| 562 | // Since history precision is in ms, add one so it is able to increase |
| 563 | // bitrate if it is off by as little as 0.5ms. |
| 564 | while (!min_bitrate_history_.empty() && |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 565 | at_time - min_bitrate_history_.front().first + TimeDelta::ms(1) > |
| 566 | kBweIncreaseInterval) { |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 567 | min_bitrate_history_.pop_front(); |
| 568 | } |
| 569 | |
| 570 | // Typical minimum sliding-window algorithm: Pop values higher than current |
| 571 | // bitrate before pushing it. |
| 572 | while (!min_bitrate_history_.empty() && |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 573 | current_bitrate_ <= min_bitrate_history_.back().second) { |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 574 | min_bitrate_history_.pop_back(); |
| 575 | } |
| 576 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 577 | min_bitrate_history_.push_back(std::make_pair(at_time, current_bitrate_)); |
andresp@webrtc.org | 44caf01 | 2014-03-26 21:00:21 +0000 | [diff] [blame] | 578 | } |
| 579 | |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 580 | DataRate SendSideBandwidthEstimation::MaybeRampupOrBackoff(DataRate new_bitrate, |
| 581 | Timestamp at_time) { |
| 582 | // TODO(crodbro): reuse this code in UpdateEstimate instead of current |
| 583 | // inlining of very similar functionality. |
| 584 | const TimeDelta time_since_loss_packet_report = |
| 585 | at_time - last_loss_packet_report_; |
| 586 | const TimeDelta time_since_loss_feedback = at_time - last_loss_feedback_; |
| 587 | if (time_since_loss_packet_report < 1.2 * kMaxRtcpFeedbackInterval) { |
| 588 | new_bitrate = min_bitrate_history_.front().second * 1.08; |
| 589 | new_bitrate += DataRate::bps(1000); |
| 590 | } else if (time_since_loss_feedback > |
| 591 | kFeedbackTimeoutIntervals * kMaxRtcpFeedbackInterval && |
| 592 | (last_timeout_.IsInfinite() || |
| 593 | at_time - last_timeout_ > kTimeoutInterval)) { |
| 594 | if (in_timeout_experiment_) { |
| 595 | RTC_LOG(LS_WARNING) << "Feedback timed out (" |
| 596 | << ToString(time_since_loss_feedback) |
| 597 | << "), reducing bitrate."; |
| 598 | new_bitrate = new_bitrate * 0.8; |
| 599 | // Reset accumulators since we've already acted on missing feedback and |
| 600 | // shouldn't to act again on these old lost packets. |
| 601 | lost_packets_since_last_loss_update_ = 0; |
| 602 | expected_packets_since_last_loss_update_ = 0; |
| 603 | last_timeout_ = at_time; |
| 604 | } |
| 605 | } |
| 606 | return new_bitrate; |
| 607 | } |
| 608 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 609 | void SendSideBandwidthEstimation::CapBitrateToThresholds(Timestamp at_time, |
| 610 | DataRate bitrate) { |
| 611 | if (bwe_incoming_ > DataRate::Zero() && bitrate > bwe_incoming_) { |
| 612 | bitrate = bwe_incoming_; |
andresp@webrtc.org | 4e69f78 | 2014-03-17 17:07:48 +0000 | [diff] [blame] | 613 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 614 | if (delay_based_bitrate_ > DataRate::Zero() && |
| 615 | bitrate > delay_based_bitrate_) { |
| 616 | bitrate = delay_based_bitrate_; |
stefan | 32f8154 | 2016-01-20 07:13:58 -0800 | [diff] [blame] | 617 | } |
Christoffer Rodbro | 3a83748 | 2018-11-19 15:30:23 +0100 | [diff] [blame] | 618 | if (loss_based_bandwidth_estimation_.Enabled() && |
| 619 | loss_based_bandwidth_estimation_.GetEstimate() > DataRate::Zero()) { |
| 620 | bitrate = std::min(bitrate, loss_based_bandwidth_estimation_.GetEstimate()); |
| 621 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 622 | if (bitrate > max_bitrate_configured_) { |
| 623 | bitrate = max_bitrate_configured_; |
andresp@webrtc.org | 4e69f78 | 2014-03-17 17:07:48 +0000 | [diff] [blame] | 624 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 625 | if (bitrate < min_bitrate_configured_) { |
| 626 | if (last_low_bitrate_log_.IsInfinite() || |
| 627 | at_time - last_low_bitrate_log_ > kLowBitrateLogPeriod) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 628 | RTC_LOG(LS_WARNING) << "Estimated available bandwidth " |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 629 | << ToString(bitrate) |
| 630 | << " is below configured min bitrate " |
| 631 | << ToString(min_bitrate_configured_) << "."; |
| 632 | last_low_bitrate_log_ = at_time; |
stefan | b6b0b92 | 2015-09-04 03:04:56 -0700 | [diff] [blame] | 633 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 634 | bitrate = min_bitrate_configured_; |
andresp@webrtc.org | 4e69f78 | 2014-03-17 17:07:48 +0000 | [diff] [blame] | 635 | } |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 636 | |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 637 | if (bitrate != current_bitrate_ || |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 638 | last_fraction_loss_ != last_logged_fraction_loss_ || |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 639 | at_time - last_rtc_event_log_ > kRtcEventLogPeriod) { |
Karl Wiberg | 918f50c | 2018-07-05 11:40:33 +0200 | [diff] [blame] | 640 | event_log_->Log(absl::make_unique<RtcEventBweUpdateLossBased>( |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 641 | bitrate.bps(), last_fraction_loss_, |
Elad Alon | 4a87e1c | 2017-10-03 16:11:34 +0200 | [diff] [blame] | 642 | expected_packets_since_last_loss_update_)); |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 643 | last_logged_fraction_loss_ = last_fraction_loss_; |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 644 | last_rtc_event_log_ = at_time; |
philipel | 1b96531 | 2017-04-18 06:55:32 -0700 | [diff] [blame] | 645 | } |
Sebastian Jansson | 7c1744d | 2018-10-08 11:00:50 +0200 | [diff] [blame] | 646 | current_bitrate_ = bitrate; |
Sebastian Jansson | 57f3ad0 | 2018-11-23 14:49:18 +0100 | [diff] [blame] | 647 | |
| 648 | if (acknowledged_rate_) { |
| 649 | link_capacity_.OnRateUpdate(std::min(current_bitrate_, *acknowledged_rate_), |
| 650 | at_time); |
| 651 | } |
andresp@webrtc.org | 4e69f78 | 2014-03-17 17:07:48 +0000 | [diff] [blame] | 652 | } |
pwestin@webrtc.org | 1cd1162 | 2012-04-19 12:13:52 +0000 | [diff] [blame] | 653 | } // namespace webrtc |