Remove SendPacer from ViEEncoder

webrtc/modules/pacing/paced_sender.cc

Index: webrtc/modules/pacing/paced_sender.cc
diff --git a/webrtc/modules/pacing/paced_sender.cc b/webrtc/modules/pacing/paced_sender.cc
index b56d28510f2dc7c6cd377076506da81b987fd09f..2f556bb4ab64f0bcc544f0f6bf97cf9b7f3fe972 100644
--- a/webrtc/modules/pacing/paced_sender.cc
+++ b/webrtc/modules/pacing/paced_sender.cc
@@ -246,20 +246,21 @@ const int64_t PacedSender::kMaxQueueLengthMs = 2000;
 const float PacedSender::kDefaultPaceMultiplier = 2.5f;
 
 PacedSender::PacedSender(Clock* clock,
-                         Callback* callback,
-                         int bitrate_kbps,
-                         int max_bitrate_kbps,
-                         int min_bitrate_kbps)
+                         SenderDelegate* delegate,
+                         int estimated_bitrate_bps)
     : clock_(clock),
-      callback_(callback),
+      delegate_(delegate),
       critsect_(CriticalSectionWrapper::CreateCriticalSection()),
       paused_(false),
       probing_enabled_(true),
-      media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)),
-      padding_budget_(new paced_sender::IntervalBudget(min_bitrate_kbps)),
+      media_budget_(new paced_sender::IntervalBudget(
+          estimated_bitrate_bps / 1000 * kDefaultPaceMultiplier)),

[stefan-webrtc, 2016/04/29 10:48:38]

I'm slightly hesitant to moving kDefaultPaceMultiplier in here. It removes the
possibility of setting different multipliers for different applications / source
types. For instance if we know we're only operating on a local wifi (not going
over the open internet) we may want to have a higher multiplier. Do you think
there's a big benefit to having it here?

[perkj_webrtc, 2016/05/02 11:29:10]

I think its very weird that it has to be set outside the pacer. But if you ever
want to implement what you suggest it should be easy to add an API to the
PacedSender to configure it. 

+      padding_budget_(new paced_sender::IntervalBudget(0)),
       prober_(new BitrateProber()),
-      bitrate_bps_(1000 * bitrate_kbps),
-      max_bitrate_kbps_(max_bitrate_kbps),
+      estimated_bitrate_bps_(estimated_bitrate_bps),
+      min_send_bitrate_kbps_(0u),
+      target_bitrate_kbps_(estimated_bitrate_bps / 1000 *

[stefan-webrtc, 2016/04/29 10:48:38]

pacing_bitrate_kbps_, perhaps?

[perkj_webrtc, 2016/05/02 11:29:10]

Done.

+                           kDefaultPaceMultiplier),
       time_last_update_us_(clock->TimeInMicroseconds()),
       packets_(new paced_sender::PacketQueue(clock)),
       packet_counter_(0) {
@@ -283,16 +284,27 @@ void PacedSender::SetProbingEnabled(bool enabled) {
   probing_enabled_ = enabled;
 }
 
-void PacedSender::UpdateBitrate(int bitrate_kbps,
-                                int max_bitrate_kbps,
-                                int min_bitrate_kbps) {
+void PacedSender::SetMinimumSendBitrate(int bitrate_bps) {
   CriticalSectionScoped cs(critsect_.get());
-  // Don't set media bitrate here as it may be boosted in order to meet max
-  // queue time constraint. Just update max_bitrate_kbps_ and let media_budget_
-  // be updated in Process().
-  padding_budget_->set_target_rate_kbps(min_bitrate_kbps);
-  bitrate_bps_ = 1000 * bitrate_kbps;
-  max_bitrate_kbps_ = max_bitrate_kbps;
+  min_send_bitrate_kbps_ = bitrate_bps / 1000;
+  target_bitrate_kbps_ =
+      std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
+      kDefaultPaceMultiplier;
+}
+
+void PacedSender::SetNetWorkEstimateTargetBitrate(uint32_t bitrate_bps) {
+  LOG(LS_INFO) << "SetNetWorkEstimateTargetBitrate, bitrate " << bitrate_bps;
+
+  CriticalSectionScoped cs(critsect_.get());
+  estimated_bitrate_bps_ = bitrate_bps;
+  target_bitrate_kbps_ =
+      std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
+      kDefaultPaceMultiplier;
+}
+
+void PacedSender::SetPaddingBitrate(int bitrate_bps) {
+  CriticalSectionScoped cs(critsect_.get());
+  padding_budget_->set_target_rate_kbps(bitrate_bps / 1000);
 }
 
 void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
@@ -306,7 +318,7 @@ void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
   if (probing_enabled_ && !prober_->IsProbing())
     prober_->SetEnabled(true);
   int64_t now_ms = clock_->TimeInMilliseconds();
-  prober_->OnIncomingPacket(bitrate_bps_, bytes, now_ms);
+  prober_->OnIncomingPacket(estimated_bitrate_bps_, bytes, now_ms);
 
   if (capture_time_ms < 0)
     capture_time_ms = now_ms;
@@ -318,8 +330,9 @@ void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
 
 int64_t PacedSender::ExpectedQueueTimeMs() const {
   CriticalSectionScoped cs(critsect_.get());
-  RTC_DCHECK_GT(max_bitrate_kbps_, 0);
-  return static_cast<int64_t>(packets_->SizeInBytes() * 8 / max_bitrate_kbps_);
+  RTC_DCHECK_GT(target_bitrate_kbps_, 0u);
+  return static_cast<int64_t>(packets_->SizeInBytes() * 8 /
+                              target_bitrate_kbps_);
 }
 
 size_t PacedSender::QueueSizePackets() const {
@@ -360,7 +373,7 @@ void PacedSender::Process() {
   CriticalSectionScoped cs(critsect_.get());
   int64_t elapsed_time_ms = (now_us - time_last_update_us_ + 500) / 1000;
   time_last_update_us_ = now_us;
-  int target_bitrate_kbps = max_bitrate_kbps_;
+  int target_bitrate_kbps = target_bitrate_kbps_;
   // TODO(holmer): Remove the !paused_ check when issue 5307 has been fixed.
   if (!paused_ && elapsed_time_ms > 0) {
     size_t queue_size_bytes = packets_->SizeInBytes();
@@ -425,10 +438,9 @@ bool PacedSender::SendPacket(const paced_sender::Packet& packet) {
   if (paused_ && packet.priority != kHighPriority)
     return false;
   critsect_->Leave();
-  const bool success = callback_->TimeToSendPacket(packet.ssrc,
-                                                   packet.sequence_number,
-                                                   packet.capture_time_ms,
-                                                   packet.retransmission);
+  const bool success = delegate_->TimeToSendPacket(
+      packet.ssrc, packet.sequence_number, packet.capture_time_ms,
+      packet.retransmission);
   critsect_->Enter();
 
   if (success) {
@@ -447,7 +459,7 @@ bool PacedSender::SendPacket(const paced_sender::Packet& packet) {
 
 void PacedSender::SendPadding(size_t padding_needed) {
   critsect_->Leave();
-  size_t bytes_sent = callback_->TimeToSendPadding(padding_needed);
+  size_t bytes_sent = delegate_->TimeToSendPadding(padding_needed);
   critsect_->Enter();
 
   if (bytes_sent > 0) {