Tweaked version of BBR for WebRTC.

webrtc/modules/remote_bitrate_estimator/test/packet_sender.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.
  */
 
 #include "webrtc/modules/remote_bitrate_estimator/test/packet_sender.h"
 
 #include <algorithm>
 #include <list>
 #include <sstream>
 
 #include "webrtc/modules/include/module_common_types.h"
+#include "webrtc/modules/pacing/bbr_paced_sender.h"
+#include "webrtc/modules/pacing/pacer.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/metric_recorder.h"
 #include "webrtc/rtc_base/checks.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 void PacketSender::Pause() {
   running_ = false;
@@ skipping 121 matching lines @@
   RecordBitrate();
 }
 
 uint32_t VideoSender::TargetBitrateKbps() {
   return (source_->bits_per_second() + 500) / 1000;
 }
 
 PacedVideoSender::PacedVideoSender(PacketProcessorListener* listener,
                                    VideoSource* source,
                                    BandwidthEstimatorType estimator)
-    : VideoSender(listener, source, estimator), pacer_(&clock_, this, nullptr) {
-  modules_.push_back(&pacer_);
-  pacer_.SetEstimatedBitrate(source->bits_per_second());
+    : VideoSender(listener, source, estimator),
+      // Ugly hack to use BBR's pacer.
+      // TODO(gnish): make pacer choice dependant on the algorithm being used.
+      pacer_(new BbrPacedSender(&clock_, this, nullptr)) {

[philipel, 2017/08/17 12:52:27]

Let pacer be a unique ptr, but instantiate it with a PacedSender instead.

[gnish1, 2017/08/17 15:37:49]

Done.

+  modules_.push_back(pacer_.get());
+  pacer_->SetEstimatedBitrate(source->bits_per_second());
 }
 
 PacedVideoSender::~PacedVideoSender() {
   for (Packet* packet : pacer_queue_)
     delete packet;
   for (Packet* packet : queue_)
     delete packet;
 }
 
 void PacedVideoSender::RunFor(int64_t time_ms, Packets* in_out) {
@@ skipping 25 matching lines @@
     // happens if the prober wants to probe, but there's no packet to send.
     if (time_until_next_event_ms == 0 && last_run_time_ms == 0)
       time_until_next_event_ms = 1;
     last_run_time_ms = time_until_next_event_ms;
 
     Packets generated_packets;
     source_->RunFor(time_until_next_event_ms, &generated_packets);
     if (!generated_packets.empty()) {
       for (Packet* packet : generated_packets) {
         MediaPacket* media_packet = static_cast<MediaPacket*>(packet);
-        pacer_.InsertPacket(
+        pacer_->InsertPacket(
             PacedSender::kNormalPriority, media_packet->header().ssrc,
             media_packet->header().sequenceNumber, media_packet->send_time_ms(),
             media_packet->payload_size(), false);
+        pacer_queue_size_in_bytes_ += media_packet->payload_size();
         pacer_queue_.push_back(packet);
         assert(pacer_queue_.size() < 10000);
       }
     }
 
     clock_.AdvanceTimeMilliseconds(time_until_next_event_ms);
 
     if (time_until_next_event_ms == time_until_feedback_ms) {
       if (!feedbacks.empty()) {
         bwe_->GiveFeedback(*feedbacks.front());
@@ skipping 56 matching lines @@
                                         const PacedPacketInfo& pacing_info) {
   for (Packets::iterator it = pacer_queue_.begin(); it != pacer_queue_.end();
        ++it) {
     MediaPacket* media_packet = static_cast<MediaPacket*>(*it);
     if (media_packet->header().sequenceNumber == sequence_number) {
       int64_t pace_out_time_ms = clock_.TimeInMilliseconds();
 
       // Make sure a packet is never paced out earlier than when it was put into
       // the pacer.
       assert(pace_out_time_ms >= media_packet->send_time_ms());
-
       media_packet->SetAbsSendTimeMs(pace_out_time_ms);
       media_packet->set_send_time_us(1000 * pace_out_time_ms);
       media_packet->set_sender_timestamp_us(1000 * pace_out_time_ms);
       queue_.push_back(media_packet);
+      pacer_queue_size_in_bytes_ -= media_packet->payload_size();
       pacer_queue_.erase(it);
       return true;
     }
   }
   return false;
 }
 
 size_t PacedVideoSender::TimeToSendPadding(size_t bytes,
                                            const PacedPacketInfo& pacing_info) {
   return 0;
 }
 
 void PacedVideoSender::OnNetworkChanged(uint32_t target_bitrate_bps,
                                         uint8_t fraction_lost,
                                         int64_t rtt) {
   VideoSender::OnNetworkChanged(target_bitrate_bps, fraction_lost, rtt);
-  pacer_.SetEstimatedBitrate(target_bitrate_bps);
+  pacer_->SetEstimatedBitrate(target_bitrate_bps);
+}
+
+void PacedVideoSender::OnNetworkChanged(uint32_t bitrate_for_encoder_bps,
+                                        uint32_t bitrate_for_pacer_bps,
+                                        bool in_probe_rtt,
+                                        int64_t target_set_time,
+                                        uint64_t congestion_window) {
+  VideoSender::OnNetworkChanged(bitrate_for_encoder_bps, 0u, 0u);
+  pacer_->SetEstimatedBitrateAndCongestionWindow(
+      bitrate_for_pacer_bps, in_probe_rtt, congestion_window);
+}
+
+void PacedVideoSender::OnBytesAcked(size_t bytes) {
+  pacer_->OnBytesAcked(bytes);
 }
 
 const int kNoLimit = std::numeric_limits<int>::max();
 const int kPacketSizeBytes = 1200;
 
 TcpSender::TcpSender(PacketProcessorListener* listener,
                      int flow_id,
                      int64_t offset_ms)
     : TcpSender(listener, flow_id, offset_ms, kNoLimit) {
 }
@@ skipping 159 matching lines @@
   RecordBitrate();
 }
 
 uint32_t TcpSender::TargetBitrateKbps() {
   return bitrate_kbps_;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc