Send audio packets immediately instead of pacing them.

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 249 matching lines @@
       pacing_bitrate_kbps_(0),
       time_last_update_us_(clock->TimeInMicroseconds()),
       packets_(new paced_sender::PacketQueue(clock)),
       packet_counter_(0) {
   UpdateBytesPerInterval(kMinPacketLimitMs);
 }
 
 PacedSender::~PacedSender() {}
 
 void PacedSender::Pause() {
+  LOG(LS_INFO) << "PacedSender paused.";
   CriticalSectionScoped cs(critsect_.get());
   paused_ = true;
 }
 
 void PacedSender::Resume() {
+  LOG(LS_INFO) << "PacedSender resumed.";
   CriticalSectionScoped cs(critsect_.get());
   paused_ = false;
 }
 
 void PacedSender::SetProbingEnabled(bool enabled) {
   RTC_CHECK_EQ(0u, packet_counter_);
   probing_enabled_ = enabled;
 }
 
 void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
+  if (bitrate_bps == 0)
+    LOG(LS_ERROR) << "PacedSender is not designed to handle 0 bitrate.";

[stefan-webrtc, 2016/07/29 15:05:13]

Change to an RTC_DCHECK instead?

[terelius, 2016/07/30 18:14:14]

I would like to see if this ever happens in production.

   CriticalSectionScoped cs(critsect_.get());
   estimated_bitrate_bps_ = bitrate_bps;
   padding_budget_->set_target_rate_kbps(
       std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
   pacing_bitrate_kbps_ =
       std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
       kDefaultPaceMultiplier;
 }
 
 void PacedSender::SetSendBitrateLimits(int min_send_bitrate_bps,
@@ skipping 96 matching lines @@
     media_budget_->set_target_rate_kbps(target_bitrate_kbps);
 
     int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms);
     UpdateBytesPerInterval(delta_time_ms);
   }
 
   bool is_probing = prober_->IsProbing();
   int probe_cluster_id = is_probing ? prober_->CurrentClusterId()
                                     : PacketInfo::kNotAProbe;
   while (!packets_->Empty()) {
-    if (media_budget_->bytes_remaining() == 0 && !is_probing)
-      return;
-
     // 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, probe_cluster_id)) {
       // Send succeeded, remove it from the queue.
       packets_->FinalizePop(packet);
       if (is_probing)
         return;
     } else {
       // Send failed, put it back into the queue.
       packets_->CancelPop(packet);
       return;
     }
   }
 
+  RTC_DCHECK(packets_->Empty());
   // TODO(holmer): Remove the paused_ check when issue 5307 has been fixed.
-  if (paused_ || !packets_->Empty())
+  if (paused_)
     return;
 
   // We can not send padding unless a normal packet has first been sent. If we
   // do, timestamps get messed up.
   if (packet_counter_ > 0) {
     size_t padding_needed = is_probing ? prober_->RecommendedPacketSize()
                                        : padding_budget_->bytes_remaining();
 
     if (padding_needed > 0)
       SendPadding(padding_needed, probe_cluster_id);
   }
 }
 
 bool PacedSender::SendPacket(const paced_sender::Packet& packet,
                              int probe_cluster_id) {
   // 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;
+  if (packet.priority != kHighPriority) {
+    if (paused_)
+      return false;
+    if (media_budget_->bytes_remaining() == 0 &&
+        probe_cluster_id == PacketInfo::kNotAProbe)

[stefan-webrtc, 2016/07/29 15:05:13]

{}

[terelius, 2016/07/30 18:14:14]

Done.

+      return false;
+  }
   critsect_->Leave();
   const bool success = packet_sender_->TimeToSendPacket(
       packet.ssrc, packet.sequence_number, packet.capture_time_ms,
       packet.retransmission, probe_cluster_id);
   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.
@@ 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