Refactor NACK bitrate allocation

webrtc/modules/pacing/paced_sender.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_PACING_PACED_SENDER_H_
 #define WEBRTC_MODULES_PACING_PACED_SENDER_H_
 
 #include <list>
 #include <memory>
 #include <set>
 
+#include "webrtc/base/rate_statistics.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/modules/include/module.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/typedefs.h"
 
 namespace webrtc {
 class BitrateProber;
 class Clock;
 class CriticalSectionWrapper;
 
@@ skipping 73 matching lines @@
 
   // Returns true if we send the packet now, else it will add the packet
   // information to the queue and call TimeToSendPacket when it's time to send.
   void InsertPacket(RtpPacketSender::Priority priority,
                     uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
                     size_t bytes,
                     bool retransmission) override;
 
+  // Try to allocate bitrate for sending a retransmission. This may fail if too
+  // much retransmission is requested in relation to payload.
+  bool AllocateRetransmissionBitrate(size_t bytes) override;

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

this function doesn't seem to allocate(reserve) bitrate(speed), but checks if
retransmission is allowed because of bitrate.
It also assume the packet would be then retransmitted and updates rate because
of it.
May be remove this function from interface, and call it from InsertPacket
instead (that would be allowed to fail now).
i.e. in PacedPacket::InsertPacket 
have code like
if (retransmission) {
  if (!HasBandwidthForRetransmission()) {
    return false;
  }
  retransmission_rate_.Update(bytes, now_ms);
}

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

Actually, having this in the pacer didn't work well. I've moved it out to a
separate interface and renamed it RateLimiter.

+
+  // The current retransmission bitrate, in bps.
+  int CurrentRetransmissionBitrate() override;
+
+  // Set the current RTT. Used to determine maximum retransmission bitrate.
+  void OnRttUpdate(int64_t rtt);
+
   // Returns the time since the oldest queued packet was enqueued.
   virtual int64_t QueueInMs() const;
 
   virtual size_t QueueSizePackets() const;
 
   // Returns the number of milliseconds it will take to send the current
   // packets in the queue, given the current size and bitrate, ignoring prio.
   virtual int64_t ExpectedQueueTimeMs() const;
 
   // Returns the average time since being enqueued, in milliseconds, for all
@@ skipping 38 matching lines @@
   // order to meet pace time constraint).
   uint32_t estimated_bitrate_bps_ GUARDED_BY(critsect_);
   uint32_t min_send_bitrate_kbps_ GUARDED_BY(critsect_);
   uint32_t max_padding_bitrate_kbps_ GUARDED_BY(critsect_);
   uint32_t pacing_bitrate_kbps_ GUARDED_BY(critsect_);
 
   int64_t time_last_update_us_ GUARDED_BY(critsect_);
 
   std::unique_ptr<paced_sender::PacketQueue> packets_ GUARDED_BY(critsect_);
   uint64_t packet_counter_;
+
+  // Average retransmission bitrate, incoming to the pacer. Limits
+  // retransmission bitrate in relation to payload bitrate.
+  RateStatistics retransmission_rate_ GUARDED_BY(critsect_);
+  int64_t rtt_ms_ GUARDED_BY(critsect_);
 };
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_PACING_PACED_SENDER_H_