Refactor NACK bitrate allocation

webrtc/modules/pacing/paced_sender.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 14 matching lines @@
 #include "webrtc/system_wrappers/include/field_trial.h"
 
 namespace {
 // Time limit in milliseconds between packet bursts.
 const int64_t kMinPacketLimitMs = 5;
 
 // Upper cap on process interval, in case process has not been called in a long
 // time.
 const int64_t kMaxIntervalTimeMs = 30;
 
+const int64_t kMaxRtt = 1000;

[danilchap, 2016/06/23 12:46:12]

kMaxRttMs

 }  // namespace
 
 // TODO(sprang): Move at least PacketQueue and MediaBudget out to separate
 // files, so that we can more easily test them.
 
 namespace webrtc {
 namespace paced_sender {
 struct Packet {
   Packet(RtpPacketSender::Priority priority,
          uint32_t ssrc,
@@ skipping 208 matching lines @@
       probing_enabled_(true),
       media_budget_(new paced_sender::IntervalBudget(0)),
       padding_budget_(new paced_sender::IntervalBudget(0)),
       prober_(new BitrateProber()),
       estimated_bitrate_bps_(0),
       min_send_bitrate_kbps_(0u),
       max_padding_bitrate_kbps_(0u),
       pacing_bitrate_kbps_(0),
       time_last_update_us_(clock->TimeInMicroseconds()),
       packets_(new paced_sender::PacketQueue(clock)),
-      packet_counter_(0) {
+      packet_counter_(0),
+      retransmission_rate_(kMaxRtt, 8) {  // Scale 8 for bits per second.

[danilchap, 2016/06/23 12:46:12]

shouldn't this be 8000 instead of 8? (scale is for 8bps not 8bpms)

[sprang_webrtc, 2016/06/28 09:12:32]

Yes.

   UpdateBytesPerInterval(kMinPacketLimitMs);
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::Pause() {
   CriticalSectionScoped cs(critsect_.get());
   paused_ = true;
 }
 
@@ skipping 45 matching lines @@
   prober_->OnIncomingPacket(estimated_bitrate_bps_, bytes, now_ms);
 
   if (capture_time_ms < 0)
     capture_time_ms = now_ms;
 
   packets_->Push(paced_sender::Packet(priority, ssrc, sequence_number,
                                       capture_time_ms, now_ms, bytes,
                                       retransmission, packet_counter_++));
 }
 
+bool PacedSender::AllocateRetransmissionBitrate(size_t bytes) {
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  CriticalSectionScoped cs(critsect_.get());
+
+  rtc::Optional<uint32_t> retransmission_rate_bps =
+      retransmission_rate_.Rate(now_ms);
+  if (!retransmission_rate_bps) {
+    // Rate not high enough to measure, let it slide.
+    return true;
+  }
+
+  int64_t max_retransmission_rate_bps =

[danilchap, 2016/06/23 12:46:12]

rate (bits/s) * rtt (ms) should result in bits, not bits/s
Can you add a comment how you get bits/s or why is it valid to compare bits vs
bits/s next line

[sprang_webrtc, 2016/06/28 09:12:32]

Not sure what happened here, thought I had removed this code. I changed it to
update the window size of the rate limiter instead and just use rate limit. Not
sure how this (incorrect) code ended up back here...

+      (2 * rtt_ms_ *
+       std::max(min_send_bitrate_kbps_ * 1000, estimated_bitrate_bps_)) /
+      1000;
+  if (*retransmission_rate_bps < max_retransmission_rate_bps) {
+    retransmission_rate_.Update(bytes, now_ms);
+    return true;
+  }
+
+  return false;
+}
+
+int PacedSender::CurrentRetransmissionBitrate() {
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  CriticalSectionScoped cs(critsect_.get());
+  return retransmission_rate_.Rate(now_ms).value_or(0);
+}
+
+void PacedSender::OnRttUpdate(int64_t rtt) {
+  RTC_DCHECK_GT(rtt, 0);
+  CriticalSectionScoped cs(critsect_.get());
+  rtt_ms_ = std::min(rtt, kMaxRtt);
+  retransmission_rate_.SetWindowSize(rtt_ms_, clock_->TimeInMilliseconds());
+}
+
 int64_t PacedSender::ExpectedQueueTimeMs() const {
   CriticalSectionScoped cs(critsect_.get());
   RTC_DCHECK_GT(pacing_bitrate_kbps_, 0u);
   return static_cast<int64_t>(packets_->SizeInBytes() * 8 /
                               pacing_bitrate_kbps_);
 }
 
 size_t PacedSender::QueueSizePackets() const {
   CriticalSectionScoped cs(critsect_.get());
   return packets_->SizeInPackets();
@@ skipping 132 matching lines @@
     media_budget_->UseBudget(bytes_sent);
     padding_budget_->UseBudget(bytes_sent);
   }
 }
 
 void PacedSender::UpdateBytesPerInterval(int64_t delta_time_ms) {
   media_budget_->IncreaseBudget(delta_time_ms);
   padding_budget_->IncreaseBudget(delta_time_ms);
 }
 }  // namespace webrtc