Add NACK rate throttling for audio channels.

webrtc/voice_engine/channel.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.
  */
 
 #include "webrtc/voice_engine/channel.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/format_macros.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/rate_limiter.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/call/rtc_event_log.h"
 #include "webrtc/common.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/audio_coding/codecs/builtin_audio_decoder_factory.h"
 #include "webrtc/modules/audio_device/include/audio_device.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/include/module_common_types.h"
 #include "webrtc/modules/pacing/packet_router.h"
@@ skipping 10 matching lines @@
 #include "webrtc/voice_engine/output_mixer.h"
 #include "webrtc/voice_engine/statistics.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/utility.h"
 
 namespace webrtc {
 namespace voe {
 
 namespace {
 
+constexpr int64_t kMaxRetranmissionWindowMs = 1000;
+constexpr int64_t kMinRetranmissionWindowMs = 30;
+
 bool RegisterReceiveCodec(std::unique_ptr<AudioCodingModule>* acm,
                           acm2::RentACodec* rac,
                           const CodecInst& ci) {
   const int result = (*acm)->RegisterReceiveCodec(
       ci, [&] { return rac->RentIsacDecoder(ci.plfreq); });
   return result == 0;
 }
 
 }  // namespace
 
@@ skipping 467 matching lines @@
     return -1;
   }
 
   // Update the packet delay.
   UpdatePacketDelay(rtpHeader->header.timestamp,
                     rtpHeader->header.sequenceNumber);
 
   int64_t round_trip_time = 0;
   _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, NULL, NULL,
                       NULL);
+  int64_t nack_window_ms = round_trip_time;
+  if (nack_window_ms < kMinRetranmissionWindowMs) {
+    nack_window_ms = kMinRetranmissionWindowMs;
+  } else if (nack_window_ms > kMaxRetranmissionWindowMs) {
+    nack_window_ms = kMaxRetranmissionWindowMs;
+  }
+  nack_rate_limiter_->SetWindowSize(nack_window_ms);

[stefan-webrtc, 2016/07/28 07:27:38]

This seems like a slightly odd place for this. Wouldn't it make more sense to do
this where an rtcp packet is recieved, as that actually may mean that the rtt is
updated?

[minyue-webrtc, 2016/07/28 08:17:27]

It might be good to put in VoERtcpObserver

[sprang_webrtc, 2016/07/28 13:00:58]

Done.

 
   std::vector<uint16_t> nack_list = audio_coding_->GetNackList(round_trip_time);
   if (!nack_list.empty()) {
     // Can't use nack_list.data() since it's not supported by all
     // compilers.
     ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
   }
   return 0;
 }
 
@@ skipping 348 matching lines @@
       _rxAgcIsEnabled(false),
       _rxNsIsEnabled(false),
       restored_packet_in_use_(false),
       rtcp_observer_(new VoERtcpObserver(this)),
       network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
       associate_send_channel_(ChannelOwner(nullptr)),
       pacing_enabled_(config.Get<VoicePacing>().enabled),
       feedback_observer_proxy_(new TransportFeedbackProxy()),
       seq_num_allocator_proxy_(new TransportSequenceNumberProxy()),
       rtp_packet_sender_proxy_(new RtpPacketSenderProxy()),
+      nack_rate_limiter_(new RateLimiter(Clock::GetRealTimeClock(),
+                                         kMaxRetranmissionWindowMs)),
       decoder_factory_(decoder_factory) {
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::Channel() - ctor");
   AudioCodingModule::Config acm_config;
   acm_config.id = VoEModuleId(instanceId, channelId);
   if (config.Get<NetEqCapacityConfig>().enabled) {
     // Clamping the buffer capacity at 20 packets. While going lower will
     // probably work, it makes little sense.
     acm_config.neteq_config.max_packets_in_buffer =
         std::max(20, config.Get<NetEqCapacityConfig>().capacity);
@@ skipping 11 matching lines @@
   configuration.outgoing_transport = this;
   configuration.receive_statistics = rtp_receive_statistics_.get();
   configuration.bandwidth_callback = rtcp_observer_.get();
   if (pacing_enabled_) {
     configuration.paced_sender = rtp_packet_sender_proxy_.get();
     configuration.transport_sequence_number_allocator =
         seq_num_allocator_proxy_.get();
     configuration.transport_feedback_callback = feedback_observer_proxy_.get();
   }
   configuration.event_log = &(*event_log_proxy_);
+  configuration.retransmission_rate_limiter = nack_rate_limiter_.get();

[stefan-webrtc, 2016/07/28 07:27:38]

should we rename it retransmission_rate_limiter_ instead of nack_rate_limiter_?

[sprang_webrtc, 2016/07/28 13:00:58]

Done.

 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
   _rtpRtcpModule->SetSendingMediaStatus(false);
 
   statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
       statistics_proxy_.get());
 
   Config audioproc_config;
   audioproc_config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
@@ skipping 399 matching lines @@
     return -1;
   }
 
   return 0;
 }
 
 void Channel::SetBitRate(int bitrate_bps) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SetBitRate(bitrate_bps=%d)", bitrate_bps);
   audio_coding_->SetBitRate(bitrate_bps);
+  nack_rate_limiter_->SetMaxRate(bitrate_bps);

[stefan-webrtc, 2016/07/28 07:27:38]

What will the default be if this is never called? Most of the time audio isn't
hooked up to the bitrate allocator.

[sprang_webrtc, 2016/07/28 13:00:58]

Rate limit defaults to maxint, so always allows retransimssion. That sound like
the right thing?

[stefan-webrtc, 2016/07/28 15:06:15]

Acknowledged.

 }
 
 void Channel::OnIncomingFractionLoss(int fraction_lost) {
   network_predictor_->UpdatePacketLossRate(fraction_lost);
   uint8_t average_fraction_loss = network_predictor_->GetLossRate();
 
   // Normalizes rate to 0 - 100.
   if (audio_coding_->SetPacketLossRate(100 * average_fraction_loss / 255) !=
       0) {
     assert(false);  // This should not happen.
@@ skipping 2197 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc