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 <utility>
+#include <vector>
 
 #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/bitrate_controller/include/bitrate_controller.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_base.h"
 #include "webrtc/voice_engine/transmit_mixer.h"
 #include "webrtc/voice_engine/voice_engine_impl.h"
 
@@ skipping 11 matching lines @@
 namespace internal {
 AudioSendStream::AudioSendStream(
     const webrtc::AudioSendStream::Config& config,
     const rtc::scoped_refptr<webrtc::AudioState>& audio_state,
     rtc::TaskQueue* worker_queue,
     PacketRouter* packet_router,
     CongestionController* congestion_controller,
     BitrateAllocator* bitrate_allocator,
     RtcEventLog* event_log,
     RtcpRttStats* rtcp_rtt_stats)
-    : worker_queue_(worker_queue),
+    : clock_(Clock::GetRealTimeClock()),
+      worker_queue_(worker_queue),
       config_(config),
       audio_state_(audio_state),
       bitrate_allocator_(bitrate_allocator),
       congestion_controller_(congestion_controller) {
   LOG(LS_INFO) << "AudioSendStream: " << config_.ToString();
   RTC_DCHECK_NE(config_.voe_channel_id, -1);
   RTC_DCHECK(audio_state_.get());
   RTC_DCHECK(congestion_controller);
 
   VoiceEngineImpl* voe_impl = static_cast<VoiceEngineImpl*>(voice_engine());
   channel_proxy_ = voe_impl->GetChannelProxy(config_.voe_channel_id);
   channel_proxy_->SetRtcEventLog(event_log);
   channel_proxy_->SetRtcpRttStats(rtcp_rtt_stats);
   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);
       bandwidth_observer_.reset(congestion_controller->GetBitrateController()
                                     ->CreateRtcpBandwidthObserver());
     } else {
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
   channel_proxy_->RegisterSenderCongestionControlObjects(
       congestion_controller->pacer(), congestion_controller, packet_router,
       bandwidth_observer_.get());
   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 131 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 seq_num) {
+  if (ssrc != config_.rtp.ssrc)
+    return;
+
+  const int64_t sent_time_ms = clock_->TimeInMilliseconds();
+
+  // 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.

[minyue-webrtc, 2017/03/15 10:54:13]

second "which" -> that

[elad.alon_webrtc.org, 2017/03/16 18:37:35]

This code no longer exists after the redesign.

+  rtc::CritScope lock(&packets_sent_since_last_feedback_cs_);
+
+  // Prevent unbounded memory consumption if OnTransportFeedback ends up

[minyue-webrtc, 2017/03/15 10:54:13]

I think this may be better taken care inside the packet loss tracker

[elad.alon_webrtc.org, 2017/03/16 18:37:34]

No longer relevant after redesign, but for posterity, this needed to be done
like this because we wanted the ownership of the tracker in Channel, and to no
introduce new threading constraints on the objects along the way to Channel.

+  // 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() &&
+      (packets_sent_since_last_feedback_[0].sequence_number == seq_num ||
+       ForwardDiff(packets_sent_since_last_feedback_[0].sequence_number,
+                   seq_num) >= 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() &&
+           (it->sequence_number == seq_num ||
+            ForwardDiff(it->sequence_number, seq_num) >= 0x8000)) {
+      ++it;
+    }
+    packets_sent_since_last_feedback_.erase(
+        packets_sent_since_last_feedback_.cbegin(), it);
+  }
+
+  packets_sent_since_last_feedback_.emplace_back(
+      SentTransportPacketRecord{seq_num, sent_time_ms});
+}
+
+void AudioSendStream::OnTransportFeedback(
+    const rtcp::TransportFeedback& feedback) {
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  std::vector<SentTransportPacketRecord> 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 113 matching lines @@
         LOG(LS_WARNING) << "SetVADStatus() failed.";
         return false;
       }
     }
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace webrtc