Reduce the BWE with 50% when feedback is received too late.

webrtc/modules/congestion_controller/delay_based_bwe.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 31 matching lines @@
 
 // Parameters for linear least squares fit of regression line to noisy data.
 constexpr size_t kDefaultTrendlineWindowSize = 15;
 constexpr double kDefaultTrendlineSmoothingCoeff = 0.9;
 constexpr double kDefaultTrendlineThresholdGain = 4.0;
 
 // Parameters for Theil-Sen robust fitting of line to noisy data.
 constexpr size_t kDefaultMedianSlopeWindowSize = 20;
 constexpr double kDefaultMedianSlopeThresholdGain = 4.0;
 
+constexpr int kMaxConsecutiveFailedLookups = 5;
+
 const char kBitrateEstimateExperiment[] = "WebRTC-ImprovedBitrateEstimate";
 const char kBweTrendlineFilterExperiment[] = "WebRTC-BweTrendlineFilter";
 const char kBweMedianSlopeFilterExperiment[] = "WebRTC-BweMedianSlopeFilter";
 
 bool BitrateEstimateExperimentIsEnabled() {
   return webrtc::field_trial::FindFullName(kBitrateEstimateExperiment) ==
          "Enabled";
 }
 
 bool TrendlineFilterExperimentIsEnabled() {
@@ skipping 154 matching lines @@
       detector_(),
       receiver_incoming_bitrate_(),
       last_update_ms_(-1),
       last_seen_packet_ms_(-1),
       uma_recorded_(false),
       trendline_window_size_(kDefaultTrendlineWindowSize),
       trendline_smoothing_coeff_(kDefaultTrendlineSmoothingCoeff),
       trendline_threshold_gain_(kDefaultTrendlineThresholdGain),
       probing_interval_estimator_(&rate_control_),
       median_slope_window_size_(kDefaultMedianSlopeWindowSize),
-      median_slope_threshold_gain_(kDefaultMedianSlopeThresholdGain) {
+      median_slope_threshold_gain_(kDefaultMedianSlopeThresholdGain),
+      consecutive_delayed_feedbacks_(0) {
   if (in_trendline_experiment_) {
     ReadTrendlineFilterExperimentParameters(&trendline_window_size_,
                                             &trendline_smoothing_coeff_,
                                             &trendline_threshold_gain_);
     LOG(LS_INFO) << "Trendline filter experiment enabled with parameters "
                  << trendline_window_size_ << ',' << trendline_smoothing_coeff_
                  << ',' << trendline_threshold_gain_;
   }
   if (in_median_slope_experiment_) {
     ReadMedianSlopeFilterExperimentParameters(&median_slope_window_size_,
@@ skipping 12 matching lines @@
 DelayBasedBwe::Result DelayBasedBwe::IncomingPacketFeedbackVector(
     const std::vector<PacketInfo>& packet_feedback_vector) {
   RTC_DCHECK(network_thread_.CalledOnValidThread());
   if (!uma_recorded_) {
     RTC_HISTOGRAM_ENUMERATION(kBweTypeHistogram,
                               BweNames::kSendSideTransportSeqNum,
                               BweNames::kBweNamesMax);
     uma_recorded_ = true;
   }
   Result aggregated_result;
+  bool delayed_feedback = true;
   for (const auto& packet_info : packet_feedback_vector) {
+    if (packet_info.send_time_ms < 0)
+      continue;
+    delayed_feedback = false;
     Result result = IncomingPacketInfo(packet_info);
     if (result.updated)
       aggregated_result = result;
   }
+  if (delayed_feedback) {
+    ++consecutive_delayed_feedbacks_;
+  } else {
+    consecutive_delayed_feedbacks_ = 0;
+  }
+  if (consecutive_delayed_feedbacks_ >= kMaxConsecutiveFailedLookups) {
+    aggregated_result =
+        OnLongFeedbackDelay(packet_feedback_vector.back().arrival_time_ms);
+  }
   return aggregated_result;
 }
 
+DelayBasedBwe::Result DelayBasedBwe::OnLongFeedbackDelay(
+    int64_t arrival_time_ms) {
+  RTC_DCHECK(rate_control_.ValidEstimate());

[terelius, 2017/02/10 15:21:12]

Is this DCHECK really guaranteed to pass? There are several code paths that can
set bitrate_is_initialized_, and it is not clear to me which one is supposed to
have executed.

[stefan-webrtc, 2017/02/13 08:22:48]

It is guranteed, since we always set the start bitrate from the Call
constructor. I can probably be convinced that this isn't a good thing to DCHECK
on though.

[nisse-webrtc, 2017/02/13 09:55:34]

What's the alternative? Do nothing if there's no estimate?

[stefan-webrtc, 2017/02/13 14:41:13]

Either that, or to take our estimated acked bitrate, if we have one, and use
that as our estimate.

Another option would be to compute an estimate as we talked about, by making an
assumption of how large the packets sent actually were. That's a bigger change,
so I'd prefer to do that later if we think it's worth it.

[terelius, 2017/02/13 14:46:47]

Acknowledged.

[nisse-webrtc, 2017/02/13 14:49:49]

If we think RTC_DCHECK is good enough for now, can you add a comment pointing
out why it's true (thanks to the Call constructor)?

[stefan-webrtc, 2017/02/13 15:35:48]

Extended the comment. Thanks

+  rate_control_.SetEstimate(rate_control_.LatestEstimate() / 2,
+                            arrival_time_ms);
+  Result result;
+  result.updated = true;
+  result.probe = false;
+  result.target_bitrate_bps = rate_control_.LatestEstimate();
+  consecutive_delayed_feedbacks_ = 0;
+  LOG(LS_WARNING) << "Long feedback delay detected, reducing BWE to "
+                  << result.target_bitrate_bps;
+  return result;
+}
+
 DelayBasedBwe::Result DelayBasedBwe::IncomingPacketInfo(
     const PacketInfo& info) {
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   receiver_incoming_bitrate_.Update(info.arrival_time_ms, info.payload_size);
   Result result;
   // Reset if the stream has timed out.
   if (last_seen_packet_ms_ == -1 ||
       now_ms - last_seen_packet_ms_ > kStreamTimeOutMs) {
     inter_arrival_.reset(
@@ skipping 123 matching lines @@
 void DelayBasedBwe::SetMinBitrate(int min_bitrate_bps) {
   // 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);
 }
 
 int64_t DelayBasedBwe::GetProbingIntervalMs() const {
   return probing_interval_estimator_.GetIntervalMs();
 }
 }  // namespace webrtc