Remove SendPacer from ViEEncoder

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 228 matching lines @@
 
   int target_rate_kbps_;
   int bytes_remaining_;
 };
 }  // namespace paced_sender
 
 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)
+                         PacketSender* packet_sender,
+                         int estimated_bitrate_bps)
     : clock_(clock),
-      callback_(callback),
+      packet_sender_(packet_sender),
       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)),
+      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),
+      pacing_bitrate_kbps_(estimated_bitrate_bps / 1000 *
+                           kDefaultPaceMultiplier),
       time_last_update_us_(clock->TimeInMicroseconds()),
       packets_(new paced_sender::PacketQueue(clock)),
       packet_counter_(0) {
   UpdateBytesPerInterval(kMinPacketLimitMs);
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::Pause() {
   CriticalSectionScoped cs(critsect_.get());
   paused_ = true;
 }
 
 void PacedSender::Resume() {
   CriticalSectionScoped cs(critsect_.get());
   paused_ = false;
 }
 
 void PacedSender::SetProbingEnabled(bool enabled) {
   RTC_CHECK_EQ(0u, packet_counter_);
   probing_enabled_ = enabled;
 }
 
-void PacedSender::UpdateBitrate(int bitrate_kbps,
-                                int max_bitrate_kbps,
-                                int min_bitrate_kbps) {
+void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
+  LOG(LS_INFO) << "SetNetWorkEstimateTargetBitrate, bitrate " << 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;
+  estimated_bitrate_bps_ = bitrate_bps;
+  pacing_bitrate_kbps_ =
+      std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
+      kDefaultPaceMultiplier;
+}
+
+void PacedSender::SetAllocatedSendBitrate(int allocated_bitrate,
+                                          int padding_bitrate) {
+  CriticalSectionScoped cs(critsect_.get());
+  min_send_bitrate_kbps_ = allocated_bitrate / 1000;
+  pacing_bitrate_kbps_ =
+      std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
+      kDefaultPaceMultiplier;
+  padding_budget_->set_target_rate_kbps(padding_bitrate / 1000);
 }
 
 void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
                                uint32_t ssrc,
                                uint16_t sequence_number,
                                int64_t capture_time_ms,
                                size_t bytes,
                                bool retransmission) {
   CriticalSectionScoped cs(critsect_.get());
 
   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;
 
   packets_->Push(paced_sender::Packet(priority, ssrc, sequence_number,
                                       capture_time_ms, now_ms, bytes,
                                       retransmission, packet_counter_++));
 }
 
 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(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();
 }
 
 int64_t PacedSender::QueueInMs() const {
   CriticalSectionScoped cs(critsect_.get());
 
@@ skipping 20 matching lines @@
   int64_t elapsed_time_us = clock_->TimeInMicroseconds() - time_last_update_us_;
   int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000;
   return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0);
 }
 
 void PacedSender::Process() {
   int64_t now_us = clock_->TimeInMicroseconds();
   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 = pacing_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();
     if (queue_size_bytes > 0) {
       // Assuming equal size packets and input/output rate, the average packet
       // has avg_time_left_ms left to get queue_size_bytes out of the queue, if
       // time constraint shall be met. Determine bitrate needed for that.
       packets_->UpdateQueueTime(clock_->TimeInMilliseconds());
       int64_t avg_time_left_ms = std::max<int64_t>(
           1, kMaxQueueLengthMs - packets_->AverageQueueTimeMs());
@@ skipping 44 matching lines @@
     SendPadding(static_cast<size_t>(padding_needed));
 }
 
 bool PacedSender::SendPacket(const paced_sender::Packet& packet) {
   // TODO(holmer): Because of this bug issue 5307 we have to send audio
   // packets even when the pacer is paused. Here we assume audio packets are
   // always high priority and that they are the only high priority packets.
   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 = packet_sender_->TimeToSendPacket(
+      packet.ssrc, packet.sequence_number, packet.capture_time_ms,
+      packet.retransmission);
   critsect_->Enter();
 
   if (success) {
     prober_->PacketSent(clock_->TimeInMilliseconds(), packet.bytes);
     // TODO(holmer): High priority packets should only be accounted for if we
     // are allocating bandwidth for audio.
     if (packet.priority != kHighPriority) {
       // Update media bytes sent.
       media_budget_->UseBudget(packet.bytes);
       padding_budget_->UseBudget(packet.bytes);
     }
   }
 
   return success;
 }
 
 void PacedSender::SendPadding(size_t padding_needed) {
   critsect_->Leave();
-  size_t bytes_sent = callback_->TimeToSendPadding(padding_needed);
+  size_t bytes_sent = packet_sender_->TimeToSendPadding(padding_needed);
   critsect_->Enter();
 
   if (bytes_sent > 0) {
     prober_->PacketSent(clock_->TimeInMilliseconds(), bytes_sent);
     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