Tune BWE to be more sensitive on low capacity networks.

webrtc/modules/remote_bitrate_estimator/test/estimators/nada.cc

 /*
  *  Copyright (c) 2015 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 10 matching lines @@
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/common.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
+namespace {
+// Used as an upper bound for calling AcceleratedRampDown.
+const float kMaxCongestionSignalMs =
+    40.0f + NadaBweSender::kMinNadaBitrateKbps / 15;
+}  // namespace
+
+const int NadaBweSender::kMinNadaBitrateKbps = 50;
 const int64_t NadaBweReceiver::kReceivingRateTimeWindowMs = 500;
 
 NadaBweReceiver::NadaBweReceiver(int flow_id)
     : BweReceiver(flow_id, kReceivingRateTimeWindowMs),
       clock_(0),
       last_feedback_ms_(0),
       recv_stats_(ReceiveStatistics::Create(&clock_)),
       baseline_delay_ms_(10000),  // Initialized as an upper bound.
       delay_signal_ms_(0),
       last_congestion_signal_ms_(0),
@@ skipping 112 matching lines @@
 
 // Implementation according to Cisco's proposal by default.
 NadaBweSender::NadaBweSender(int kbps, BitrateObserver* observer, Clock* clock)
     : BweSender(kbps),  // Referred as "Reference Rate" = R_n.,
       clock_(clock),
       observer_(observer),
       original_operating_mode_(true) {
 }
 
 NadaBweSender::NadaBweSender(BitrateObserver* observer, Clock* clock)
-    : BweSender(kMinBitrateKbps),  // Referred as "Reference Rate" = R_n.
+    : BweSender(kMinNadaBitrateKbps),  // Referred as "Reference Rate" = R_n.
       clock_(clock),
       observer_(observer),
-      original_operating_mode_(true) {
-}
+      original_operating_mode_(true) {}
 
 NadaBweSender::~NadaBweSender() {
 }
 
 int NadaBweSender::GetFeedbackIntervalMs() const {
   return 100;
 }
 
 void NadaBweSender::GiveFeedback(const FeedbackPacket& feedback) {
   const NadaFeedback& fb = static_cast<const NadaFeedback&>(feedback);
@@ skipping 28 matching lines @@
         fb.derivative() < kDerivativeUpperBound) {
       AcceleratedRampUp(fb);
     } else {
       GradualRateUpdate(fb, delta_s, 1.0);
     }
   } else {
     // Modified if conditions and rate update; new ramp down mode.
     if (fb.congestion_signal() == fb.est_queuing_delay_signal_ms() &&
         fb.est_queuing_delay_signal_ms() < kQueuingDelayUpperBoundMs &&
         fb.exp_smoothed_delay_ms() <
-            kMinBitrateKbps / kProportionalityDelayBits &&
+            kMinNadaBitrateKbps / kProportionalityDelayBits &&
         fb.derivative() < kDerivativeUpperBound &&
-        fb.receiving_rate() > kMinBitrateKbps) {
+        fb.receiving_rate() > kMinNadaBitrateKbps) {
       AcceleratedRampUp(fb);
     } else if (fb.congestion_signal() > kMaxCongestionSignalMs ||
                fb.exp_smoothed_delay_ms() > kMaxCongestionSignalMs) {
       AcceleratedRampDown(fb);
     } else {
       double bitrate_reference =
-          (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinBitrateKbps);
+          (2.0 * bitrate_kbps_) / (kMaxBitrateKbps + kMinNadaBitrateKbps);
       double smoothing_factor = pow(bitrate_reference, 0.75);
       GradualRateUpdate(fb, delta_s, smoothing_factor);
     }
   }
 
   bitrate_kbps_ = std::min(bitrate_kbps_, kMaxBitrateKbps);
-  bitrate_kbps_ = std::max(bitrate_kbps_, kMinBitrateKbps);
+  bitrate_kbps_ = std::max(bitrate_kbps_, kMinNadaBitrateKbps);
 
   observer_->OnNetworkChanged(1000 * bitrate_kbps_, 0, rtt_ms);
 }
 
 int64_t NadaBweSender::TimeUntilNextProcess() {
   return 100;
 }
 
 void NadaBweSender::Process() {
 }
@@ skipping 21 matching lines @@
                                       float delta_s,
                                       double smoothing_factor) {
   const float kTauOMs = 500.0f;           // Referred as tau_o.
   const float kEta = 2.0f;                // Referred as eta.
   const float kKappa = 1.0f;              // Referred as kappa.
   const float kReferenceDelayMs = 10.0f;  // Referred as x_ref.
   const float kPriorityWeight = 1.0f;     // Referred as w.
 
   float x_hat = fb.congestion_signal() + kEta * kTauOMs * fb.derivative();
 
-  float kTheta =
-      kPriorityWeight * (kMaxBitrateKbps - kMinBitrateKbps) * kReferenceDelayMs;
+  float kTheta = kPriorityWeight * (kMaxBitrateKbps - kMinNadaBitrateKbps) *
+                 kReferenceDelayMs;
 
-  int original_increase =
-      static_cast<int>((kKappa * delta_s *
-                        (kTheta - (bitrate_kbps_ - kMinBitrateKbps) * x_hat)) /
-                           (kTauOMs * kTauOMs) +
-                       0.5f);
+  int original_increase = static_cast<int>(
+      (kKappa * delta_s *
+       (kTheta - (bitrate_kbps_ - kMinNadaBitrateKbps) * x_hat)) /
+          (kTauOMs * kTauOMs) +
+      0.5f);
 
   bitrate_kbps_ = bitrate_kbps_ + smoothing_factor * original_increase;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc