Video/Screenshare loopback tool.

webrtc/modules/congestion_controller/send_side_congestion_controller.cc

 /*
  *  Copyright (c) 2012 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 126 matching lines @@
     Observer* observer,
     RtcEventLog* event_log,
     PacedSender* pacer)
     : clock_(clock),
       observer_(observer),
       event_log_(event_log),
       pacer_(pacer),
       bitrate_controller_(
           BitrateController::CreateBitrateController(clock_, event_log)),
       acknowledged_bitrate_estimator_(
-          rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
+          rtc::MakeUnique<AcknowledgedBitrateEstimator>(event_log)),
       probe_controller_(new ProbeController(pacer_, clock_)),
       retransmission_rate_limiter_(
           new RateLimiter(clock, kRetransmitWindowSizeMs)),
       transport_feedback_adapter_(clock_),
       last_reported_bitrate_bps_(0),
       last_reported_fraction_loss_(0),
       last_reported_rtt_(0),
       network_state_(kNetworkUp),
       pause_pacer_(false),
       pacer_paused_(false),
@@ skipping 251 matching lines @@
   uint8_t fraction_loss;
   int64_t rtt;
   bool estimate_changed = bitrate_controller_->GetNetworkParameters(
       &bitrate_bps, &fraction_loss, &rtt);
   if (estimate_changed) {
     pacer_->SetEstimatedBitrate(bitrate_bps);
     probe_controller_->SetEstimatedBitrate(bitrate_bps);
     retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
   }
 
-  bitrate_bps = IsNetworkDown() || IsSendQueueFull() ? 0 : bitrate_bps;
+  // bitrate_bps = IsNetworkDown() || IsSendQueueFull() ? 0 : bitrate_bps;
+
+  if (IsNetworkDown()) {
+    bitrate_bps = 0;
+  } else {
+    int64_t expected_queue = pacer_->ExpectedQueueTimeMs();
+
+    if (expected_queue > 50) {
+      float reduction_rate =
+          std::max<float>(0.0f, 1.0 - expected_queue / 1000.0);
+      if (!reduction_rate_ || *reduction_rate_ > reduction_rate) {
+        reduction_rate_.emplace(reduction_rate);
+      }
+    }
+
+    if (reduction_rate_) {
+      if (expected_queue == 0) {
+        reduction_rate_.reset();
+      } else {
+        bitrate_bps *= *reduction_rate_;
+      }
+    }
+  }
 
   if (HasNetworkParametersToReportChanged(bitrate_bps, fraction_loss, rtt)) {
     int64_t probing_interval_ms;
     {
       rtc::CritScope cs(&bwe_lock_);
       probing_interval_ms = delay_based_bwe_->GetExpectedBwePeriodMs();
     }
     {
       rtc::CritScope cs(&observer_lock_);
       if (observer_) {
@@ skipping 17 matching lines @@
     LOG(LS_INFO) << "Bitrate estimate state changed, BWE: " << bitrate_bps
                  << " bps.";
   }
   last_reported_bitrate_bps_ = bitrate_bps;
   last_reported_fraction_loss_ = fraction_loss;
   last_reported_rtt_ = rtt;
   return changed;
 }
 
 bool SendSideCongestionController::IsSendQueueFull() const {
-  return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
+  return pacer_->ExpectedQueueTimeMs() > 2000;
 }
 
 bool SendSideCongestionController::IsNetworkDown() const {
   rtc::CritScope cs(&network_state_lock_);
   return network_state_ == kNetworkDown;
 }
 
+void SendSideCongestionController::PrintDebugStuff() {
+  print_ = true;
+}
+
 }  // namespace webrtc