Disable pacer disabling.

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 201 matching lines @@
 const float PacedSender::kDefaultPaceMultiplier = 2.5f;
 
 PacedSender::PacedSender(Clock* clock,
                          Callback* callback,
                          int bitrate_kbps,
                          int max_bitrate_kbps,
                          int min_bitrate_kbps)
     : clock_(clock),
       callback_(callback),
       critsect_(CriticalSectionWrapper::CreateCriticalSection()),
-      enabled_(true),
       paused_(false),
       probing_enabled_(true),
       media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)),
       padding_budget_(new paced_sender::IntervalBudget(min_bitrate_kbps)),
       prober_(new BitrateProber()),
       bitrate_bps_(1000 * bitrate_kbps),
       time_last_update_us_(clock->TimeInMicroseconds()),
       packets_(new paced_sender::PacketQueue()),
       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) {
   assert(packet_counter_ == 0);
   probing_enabled_ = enabled;
 }
 
-void PacedSender::SetStatus(bool enable) {
-  CriticalSectionScoped cs(critsect_.get());
-  enabled_ = enable;
-}
-
-bool PacedSender::Enabled() const {
-  CriticalSectionScoped cs(critsect_.get());
-  return enabled_;
-}
-
 void PacedSender::UpdateBitrate(int bitrate_kbps,
                                 int max_bitrate_kbps,
                                 int min_bitrate_kbps) {
   CriticalSectionScoped cs(critsect_.get());
   media_budget_->set_target_rate_kbps(max_bitrate_kbps);
   padding_budget_->set_target_rate_kbps(min_bitrate_kbps);
   bitrate_bps_ = 1000 * bitrate_kbps;
 }
 
-bool PacedSender::SendPacket(RtpPacketSender::Priority priority,
-                             uint32_t ssrc,
-                             uint16_t sequence_number,
-                             int64_t capture_time_ms,
-                             size_t bytes,
-                             bool retransmission) {
+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 (!enabled_) {
-    return true;  // We can send now.
-  }
   if (probing_enabled_ && !prober_->IsProbing()) {
     prober_->SetEnabled(true);
   }
   prober_->MaybeInitializeProbe(bitrate_bps_);
 
   if (capture_time_ms < 0) {
     capture_time_ms = clock_->TimeInMilliseconds();
   }
 
   packets_->Push(paced_sender::Packet(
       priority, ssrc, sequence_number, capture_time_ms,
       clock_->TimeInMilliseconds(), bytes, retransmission, packet_counter_++));
-  return false;
 }
 
 int64_t PacedSender::ExpectedQueueTimeMs() const {
   CriticalSectionScoped cs(critsect_.get());
   int target_rate = media_budget_->target_rate_kbps();
   assert(target_rate > 0);
   return static_cast<int64_t>(packets_->SizeInBytes() * 8 / target_rate);
 }
 
 size_t PacedSender::QueueSizePackets() const {
@@ skipping 22 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);
 }
 
 int32_t 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;
-  if (!enabled_) {
+  if (paused_)
     return 0;
+  if (elapsed_time_ms > 0) {
+    int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
+    UpdateBytesPerInterval(delta_time_ms);
   }
-  if (!paused_) {
-    if (elapsed_time_ms > 0) {
-      int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
-      UpdateBytesPerInterval(delta_time_ms);
+  while (!packets_->Empty()) {
+    if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
+      return 0;
     }
-    while (!packets_->Empty()) {
-      if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) {
+
+    // Since we need to release the lock in order to send, we first pop the
+    // element from the priority queue but keep it in storage, so that we can
+    // reinsert it if send fails.
+    const paced_sender::Packet& packet = packets_->BeginPop();
+    if (SendPacket(packet)) {
+      // Send succeeded, remove it from the queue.
+      packets_->FinalizePop(packet);
+      if (prober_->IsProbing()) {
         return 0;
       }
+    } else {
+      // Send failed, put it back into the queue.
+      packets_->CancelPop(packet);
+      return 0;
+    }
+  }
 
-      // Since we need to release the lock in order to send, we first pop the
-      // element from the priority queue but keep it in storage, so that we can
-      // reinsert it if send fails.
-      const paced_sender::Packet& packet = packets_->BeginPop();
-      if (SendPacket(packet)) {
-        // Send succeeded, remove it from the queue.
-        packets_->FinalizePop(packet);
-        if (prober_->IsProbing()) {
-          return 0;
-        }
-      } else {
-        // Send failed, put it back into the queue.
-        packets_->CancelPop(packet);
-        return 0;
-      }
-    }
+  if (!packets_->Empty())
+    return 0;
 
-    if (!packets_->Empty())
-      return 0;
+  size_t padding_needed;
+  if (prober_->IsProbing())
+    padding_needed = prober_->RecommendedPacketSize();
+  else
+    padding_needed = padding_budget_->bytes_remaining();
 
-    size_t padding_needed;
-    if (prober_->IsProbing())
-      padding_needed = prober_->RecommendedPacketSize();
-    else
-      padding_needed = padding_budget_->bytes_remaining();
-
-    if (padding_needed > 0)
-      SendPadding(static_cast<size_t>(padding_needed));
-  }
+  if (padding_needed > 0)
+    SendPadding(static_cast<size_t>(padding_needed));
   return 0;
 }
 
 bool PacedSender::SendPacket(const paced_sender::Packet& packet) {
   critsect_->Leave();
   const bool success = callback_->TimeToSendPacket(packet.ssrc,
                                                    packet.sequence_number,
                                                    packet.capture_time_ms,
                                                    packet.retransmission);
   critsect_->Enter();
@@ skipping 18 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