Add interval estimator to remote bitrate estimator

webrtc/modules/remote_bitrate_estimator/aimd_rate_control.cc

 /*
  *  Copyright (c) 2014 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 112 matching lines @@
     current_input_ = *input;
   }
 }
 
 void AimdRateControl::SetEstimate(int bitrate_bps, int64_t now_ms) {
   updated_ = true;
   bitrate_is_initialized_ = true;
   current_bitrate_bps_ = ChangeBitrate(bitrate_bps, bitrate_bps, now_ms);
 }
 
+int AimdRateControl::GetNearMaxIncreaseRateBps() const {
+  double bits_per_frame = static_cast<double>(current_bitrate_bps_) / 30.0;
+  double packets_per_frame = std::ceil(bits_per_frame / (8.0 * 1200.0));
+  double avg_packet_size_bits = bits_per_frame / packets_per_frame;
+  // Approximate the over-use estimator delay to 100 ms.
+  const int64_t response_time = in_experiment_ ? (rtt_ + 100) * 2 : rtt_ + 100;
+
+  constexpr double kMinIncreaseRateBps = 4000;

[stefan-webrtc, 2016/11/08 13:06:28]

4000 is larger than before when it was 1000, right?

[michaelt, 2016/11/09 07:54:44]

No its actually smaller.
Before we had 1kbps per call. And we called it with the current impl. in a
interval of 200ms.
So the increase rate per second was 5kbps.

[stefan-webrtc, 2016/11/09 18:01:10]

Should we keep 5 kbps then? BTW, how come it was always 200 ms? Looks to me like
it could vary? Probably not a big difference, so this is likely fine.

[michaelt, 2016/11/10 08:57:31]

this 200ms are not const as you expected, they are dependent on
GetFeedbackInterval (min interval 200ms) and on the TWCC report interval (50ms -
250ms). For small bit rates the interval is longer for large bitrates the
interval is shorter. If you are OK with it I would let it for the moment stay at
4kbps. We will do some real call analyzes. With this CL to see how the system
behaves.

[stefan-webrtc, 2016/11/14 14:53:48]

SG

+  return std::max(kMinIncreaseRateBps,
+                  (avg_packet_size_bits * 1000) / response_time);
+}
+
+rtc::Optional<int> AimdRateControl::GetLastDecrease() const {
+  return last_decrease_;
+}
+
 uint32_t AimdRateControl::ChangeBitrate(uint32_t current_bitrate_bps,
                                         uint32_t incoming_bitrate_bps,
                                         int64_t now_ms) {
   if (!updated_) {
     return current_bitrate_bps_;
   }
   // An over-use should always trigger us to reduce the bitrate, even though
   // we have not yet established our first estimate. By acting on the over-use,
   // we will end up with a valid estimate.
   if (!bitrate_is_initialized_ && current_input_.bw_state != kBwOverusing)
@@ skipping 11 matching lines @@
       break;
 
     case kRcIncrease:
       if (avg_max_bitrate_kbps_ >= 0 &&
           incoming_bitrate_kbps >
               avg_max_bitrate_kbps_ + 3 * std_max_bit_rate) {
         ChangeRegion(kRcMaxUnknown);
         avg_max_bitrate_kbps_ = -1.0;
       }
       if (rate_control_region_ == kRcNearMax) {
-        // Approximate the over-use estimator delay to 100 ms.
-        const int64_t response_time = rtt_ + 100;
-        uint32_t additive_increase_bps = AdditiveRateIncrease(
-            now_ms, time_last_bitrate_change_, response_time);
+        uint32_t additive_increase_bps =
+            AdditiveRateIncrease(now_ms, time_last_bitrate_change_);
         current_bitrate_bps += additive_increase_bps;
-
       } else {
         uint32_t multiplicative_increase_bps = MultiplicativeRateIncrease(
             now_ms, time_last_bitrate_change_, current_bitrate_bps);
         current_bitrate_bps += multiplicative_increase_bps;
       }
 
       time_last_bitrate_change_ = now_ms;
       break;
 
     case kRcDecrease:
       bitrate_is_initialized_ = true;
       if (incoming_bitrate_bps < min_configured_bitrate_bps_) {
         current_bitrate_bps = min_configured_bitrate_bps_;
       } else {
         // Set bit rate to something slightly lower than max
         // to get rid of any self-induced delay.
         current_bitrate_bps = static_cast<uint32_t>(beta_ *
                                                     incoming_bitrate_bps + 0.5);
         if (current_bitrate_bps > current_bitrate_bps_) {
           // Avoid increasing the rate when over-using.
           if (rate_control_region_ != kRcMaxUnknown) {
             current_bitrate_bps = static_cast<uint32_t>(
                 beta_ * avg_max_bitrate_kbps_ * 1000 + 0.5f);
           }
           current_bitrate_bps = std::min(current_bitrate_bps,
                                          current_bitrate_bps_);
         }
         ChangeRegion(kRcNearMax);
 
+        if (incoming_bitrate_bps < current_bitrate_bps_)

[stefan-webrtc, 2016/11/08 13:06:28]

{}

[michaelt, 2016/11/09 07:54:44]

Done.

+          last_decrease_ =
+              rtc::Optional<int>(current_bitrate_bps_ - current_bitrate_bps);
         if (incoming_bitrate_kbps < avg_max_bitrate_kbps_ -
             3 * std_max_bit_rate) {
           avg_max_bitrate_kbps_ = -1.0f;
         }
 
         UpdateMaxBitRateEstimate(incoming_bitrate_kbps);
       }
       // Stay on hold until the pipes are cleared.
       ChangeState(kRcHold);
       time_last_bitrate_change_ = now_ms;
@@ skipping 18 matching lines @@
   if (last_ms > -1) {
     int time_since_last_update_ms = std::min(static_cast<int>(now_ms - last_ms),
                                              1000);
     alpha = pow(alpha,  time_since_last_update_ms / 1000.0);
   }
   uint32_t multiplicative_increase_bps = std::max(
       current_bitrate_bps * (alpha - 1.0), 1000.0);
   return multiplicative_increase_bps;
 }
 
-uint32_t AimdRateControl::AdditiveRateIncrease(
-    int64_t now_ms, int64_t last_ms, int64_t response_time_ms) const {
-  assert(response_time_ms > 0);
-  double beta = 0.0;
-  if (last_ms > 0) {
-    beta = std::min((now_ms - last_ms) / static_cast<double>(response_time_ms),
-                    1.0);
-    if (in_experiment_)
-      beta /= 2.0;
-  }
-  double bits_per_frame = static_cast<double>(current_bitrate_bps_) / 30.0;
-  double packets_per_frame = std::ceil(bits_per_frame / (8.0 * 1200.0));
-  double avg_packet_size_bits = bits_per_frame / packets_per_frame;
-  uint32_t additive_increase_bps = std::max(
-      1000.0, beta * avg_packet_size_bits);
-  return additive_increase_bps;
+uint32_t AimdRateControl::AdditiveRateIncrease(int64_t now_ms,
+                                               int64_t last_ms) const {
+  return (GetNearMaxIncreaseRateBps() / 1000.0) * (now_ms - last_ms);

[stefan-webrtc, 2016/11/08 13:06:28]

You can remove () around GetNear...

[michaelt, 2016/11/09 07:54:44]

Done.

 }
 
 void AimdRateControl::UpdateMaxBitRateEstimate(float incoming_bitrate_kbps) {
   const float alpha = 0.05f;
   if (avg_max_bitrate_kbps_ == -1.0f) {
     avg_max_bitrate_kbps_ = incoming_bitrate_kbps;
   } else {
     avg_max_bitrate_kbps_ = (1 - alpha) * avg_max_bitrate_kbps_ +
         alpha * incoming_bitrate_kbps;
   }
@@ skipping 36 matching lines @@
 }
 
 void AimdRateControl::ChangeRegion(RateControlRegion region) {
   rate_control_region_ = region;
 }
 
 void AimdRateControl::ChangeState(RateControlState new_state) {
   rate_control_state_ = new_state;
 }
 }  // namespace webrtc