Attach TransportFeedbackPacketLossTracker to ANA (PLR only)

webrtc/audio/audio_send_stream.cc

 /*
  *  Copyright (c) 2015 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/audio/audio_send_stream.h"
 
 #include <string>
+#include <vector>
+#include <utility>
 
 #include "webrtc/audio/audio_state.h"
 #include "webrtc/audio/conversion.h"
 #include "webrtc/audio/scoped_voe_interface.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/mod_ops.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/voice_engine/channel_proxy.h"
 #include "webrtc/voice_engine/include/voe_audio_processing.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 #include "webrtc/voice_engine/include/voe_rtp_rtcp.h"
 #include "webrtc/voice_engine/include/voe_volume_control.h"
 #include "webrtc/voice_engine/voice_engine_impl.h"
@@ skipping 38 matching lines @@
       congestion_controller->GetTransportFeedbackObserver(), packet_router);
   channel_proxy_->SetRTCPStatus(true);
   channel_proxy_->SetLocalSSRC(config.rtp.ssrc);
   channel_proxy_->SetRTCP_CNAME(config.rtp.c_name);
   // TODO(solenberg): Config NACK history window (which is a packet count),
   // using the actual packet size for the configured codec.
   channel_proxy_->SetNACKStatus(config_.rtp.nack.rtp_history_ms != 0,
                                 config_.rtp.nack.rtp_history_ms / 20);
 
   channel_proxy_->RegisterExternalTransport(config.send_transport);
+  congestion_controller_->RegisterTransportFeedbackAdapterObserver(this);
 
   for (const auto& extension : config.rtp.extensions) {
     if (extension.uri == RtpExtension::kAudioLevelUri) {
       channel_proxy_->SetSendAudioLevelIndicationStatus(true, extension.id);
     } else if (extension.uri == RtpExtension::kTransportSequenceNumberUri) {
       channel_proxy_->EnableSendTransportSequenceNumber(extension.id);
       congestion_controller->EnablePeriodicAlrProbing(true);
     } else {
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
   if (!SetupSendCodec()) {
     LOG(LS_ERROR) << "Failed to set up send codec state.";
   }
 }
 
 AudioSendStream::~AudioSendStream() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString();
+  congestion_controller_->DeRegisterTransportFeedbackAdapterObserver(this);
   channel_proxy_->DeRegisterExternalTransport();
   channel_proxy_->ResetCongestionControlObjects();
   channel_proxy_->SetRtcEventLog(nullptr);
   channel_proxy_->SetRtcpRttStats(nullptr);
 }
 
 void AudioSendStream::Start() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (config_.min_bitrate_bps != -1 && config_.max_bitrate_bps != -1) {
     RTC_DCHECK_GE(config_.max_bitrate_bps, config_.min_bitrate_bps);
@@ skipping 138 matching lines @@
   if (bitrate_bps > max_bitrate_bps)
     bitrate_bps = max_bitrate_bps;
 
   channel_proxy_->SetBitrate(bitrate_bps, probing_interval_ms);
 
   // The amount of audio protection is not exposed by the encoder, hence
   // always returning 0.
   return 0;
 }
 
+void AudioSendStream::OnPacketAdded(uint32_t ssrc,
+                                    uint16_t transport_sequence_number) {
+  if (ssrc != config_.rtp.ssrc)
+    return;
+
+  // To make sure everything happens on the same thread, we'll buffer
+  // this information and pass it down with the first OnTransportFeedback,
+  // which is called on the thread which channel_proxy_ mostly works on.
+  rtc::CritScope lock(&packets_sent_since_last_feedback_cs_);
+
+  // Prevent unbounded memory consumption if OnTransportFeedback ends up
+  // never being called. Messages which are 0x8000 (or more) sequence numbers
+  // away from the newest message will end up having no effect, so we can
+  // discard those.
+  if (!packets_sent_since_last_feedback_.empty() &&
+      ForwardDiff(packets_sent_since_last_feedback_[0],
+                  transport_sequence_number) >= 0x8000) {
+    // The element are ordered (circularly), so we can batch-remove. No need
+    // for binary search, because we expect to usually find the edge in the
+    // beginning of the container.
+    auto it = packets_sent_since_last_feedback_.cbegin();
+    while (it != packets_sent_since_last_feedback_.cend() &&
+           ForwardDiff(*it, transport_sequence_number) >= 0x8000) {
+      ++it;
+    }
+    packets_sent_since_last_feedback_.erase(
+        packets_sent_since_last_feedback_.cbegin(), it);
+  }
+
+  packets_sent_since_last_feedback_.push_back(transport_sequence_number);
+}
+
+void AudioSendStream::OnTransportFeedback(
+    const rtcp::TransportFeedback& feedback) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  std::vector<uint16_t> packets_sent_since_last_feedback;
+  {
+    rtc::CritScope lock(&packets_sent_since_last_feedback_cs_);
+    std::swap(packets_sent_since_last_feedback_,
+              packets_sent_since_last_feedback);
+  }
+  channel_proxy_->HandleTransportFeedback(
+      packets_sent_since_last_feedback, feedback);
+}
+
 const webrtc::AudioSendStream::Config& AudioSendStream::config() const {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return config_;
 }
 
 void AudioSendStream::SetTransportOverhead(int transport_overhead_per_packet) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   congestion_controller_->SetTransportOverhead(transport_overhead_per_packet);
   channel_proxy_->SetTransportOverhead(transport_overhead_per_packet);
 }
@@ skipping 120 matching lines @@
         LOG(LS_WARNING) << "SetVADStatus() failed: " << base->LastError();
         return false;
       }
     }
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace webrtc