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);
 }
 
+rtc::Optional<int> AimdRateControl::GetNearMaxIncreaseRate() const {
+  return near_max_increase_rate_bps_;
+}
+
+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 15 matching lines @@
           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);
+        if (last_near_max_increase_rate_update_) {
+          near_max_increase_rate_bps_ = rtc::Optional<int>(
+              additive_increase_bps * 1000.0 /
+              (now_ms - *last_near_max_increase_rate_update_));

[stefan-webrtc, 2016/10/26 14:30:06]

An alternative to this would be to do something like:
std::min(now_ms - time_last_bitrate_change_, 500) or something like that. WDYT?

[michaelt, 2016/10/31 11:10:22]

I taught a little what would be the best solution. I would prefer to have a
"NearMaxIncresaseRate" function which would calculate the actual increase rate
depending on rtt,bitrate,.... This function would be then used in
AdditiveRateIncrease and for the probing interval estimator. We would have to
remove the min_increse per call, but we could replace it with a
min_increase_rate. WDYT?

+        }
         current_bitrate_bps += additive_increase_bps;
-
+        last_near_max_increase_rate_update_ = rtc::Optional<int64_t>(now_ms);
       } else {
+        last_near_max_increase_rate_update_ = rtc::Optional<int64_t>();
         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:
+      last_near_max_increase_rate_update_ = rtc::Optional<int64_t>();
       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_)
+          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 31 matching lines @@
   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(

[stefan-webrtc, 2016/10/26 14:30:06]

If we compute near_max_increase_rate_bps_ here instead we should be able to do:

near_max_increase_rate_bps_ = 1000 * std::max(1000.0, avg_packet_size_bits) /
response_time;

to get the increase per second, right?

[michaelt, 2016/10/31 11:10:22]

Without the max function it would  be:
near_max_increase_rate_bps_ = 1000 * avg_packet_size_bits / response_time;

       1000.0, beta * avg_packet_size_bits);
   return additive_increase_bps;
 }
 
 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_ +
@@ skipping 38 matching lines @@
 }
 
 void AimdRateControl::ChangeRegion(RateControlRegion region) {
   rate_control_region_ = region;
 }
 
 void AimdRateControl::ChangeState(RateControlState new_state) {
   rate_control_state_ = new_state;
 }
 }  // namespace webrtc