Move receive RtpRtcp ownership from ViEChannel to ViEReceiver.

webrtc/video/vie_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/video/vie_channel.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/common_video/include/frame_callback.h"
 #include "webrtc/common_video/include/incoming_video_stream.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
-#include "webrtc/modules/pacing/paced_sender.h"
-#include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/video_coding_impl.h"
 #include "webrtc/modules/video_processing/include/video_processing.h"
 #include "webrtc/modules/video_render/video_render_defines.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/payload_router.h"
 #include "webrtc/video/receive_statistics_proxy.h"
 
 namespace webrtc {
 
 static const int kMaxPacketAgeToNack = 450;
 static const int kMaxNackListSize = 250;
 
-namespace {
-
-std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
-    ReceiveStatistics* receive_statistics,
-    Transport* outgoing_transport,
-    RtcpRttStats* rtt_stats,
-    RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
-    RemoteBitrateEstimator* remote_bitrate_estimator,
-    RtpPacketSender* paced_sender,
-    TransportSequenceNumberAllocator* transport_sequence_number_allocator) {
-  RtpRtcp::Configuration configuration;
-  configuration.audio = false;
-  configuration.receiver_only = true;
-  configuration.receive_statistics = receive_statistics;
-  configuration.outgoing_transport = outgoing_transport;
-  configuration.intra_frame_callback = nullptr;
-  configuration.rtt_stats = rtt_stats;
-  configuration.rtcp_packet_type_counter_observer =
-      rtcp_packet_type_counter_observer;
-  configuration.paced_sender = paced_sender;
-  configuration.transport_sequence_number_allocator =
-      transport_sequence_number_allocator;
-  configuration.send_bitrate_observer = nullptr;
-  configuration.send_frame_count_observer = nullptr;
-  configuration.send_side_delay_observer = nullptr;
-  configuration.bandwidth_callback = nullptr;
-  configuration.transport_feedback_callback = nullptr;
-
-  std::unique_ptr<RtpRtcp> rtp_rtcp(RtpRtcp::CreateRtpRtcp(configuration));
-  rtp_rtcp->SetSendingStatus(false);
-  rtp_rtcp->SetSendingMediaStatus(false);
-  rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
-
-  return rtp_rtcp;
-}
-
-}  // namespace
-
 // Helper class receiving statistics callbacks.
 class ChannelStatsObserver : public CallStatsObserver {
  public:
   explicit ChannelStatsObserver(ViEChannel* owner) : owner_(owner) {}
   virtual ~ChannelStatsObserver() {}
 
   // Implements StatsObserver.
   virtual void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
     owner_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
   }
 
  private:
   ViEChannel* const owner_;
 };
 
 ViEChannel::ViEChannel(Transport* transport,
                        ProcessThread* module_process_thread,
                        vcm::VideoReceiver* video_receiver,
                        RemoteBitrateEstimator* remote_bitrate_estimator,
                        RtcpRttStats* rtt_stats,
                        PacedSender* paced_sender,
                        PacketRouter* packet_router)
     : module_process_thread_(module_process_thread),
       video_receiver_(video_receiver),
-      vie_receiver_(video_receiver_, remote_bitrate_estimator, this),
+      vie_receiver_(video_receiver, remote_bitrate_estimator, this, transport,
+                    rtt_stats, paced_sender, packet_router),
+      rtp_rtcp_(vie_receiver_.rtp_rtcp()),
       stats_observer_(new ChannelStatsObserver(this)),
       receive_stats_callback_(nullptr),
       incoming_video_stream_(nullptr),
-      rtt_stats_(rtt_stats),
-      paced_sender_(paced_sender),
-      packet_router_(packet_router),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(nullptr),
-      last_rtt_ms_(0),
-      rtp_rtcp_(CreateRtpRtcpModule(vie_receiver_.GetReceiveStatistics(),
-                                    transport,
-                                    rtt_stats_,
-                                    &rtcp_packet_type_counter_observer_,
-                                    remote_bitrate_estimator,
-                                    paced_sender_,
-                                    packet_router_)) {
-  vie_receiver_.Init(rtp_rtcp_.get());
+      last_rtt_ms_(0) {
   RTC_DCHECK(video_receiver_);
   video_receiver_->SetNackSettings(kMaxNackListSize,
                                    max_nack_reordering_threshold_, 0);
 }
 
 int32_t ViEChannel::Init() {
   static const int kDefaultRenderDelayMs = 10;
   module_process_thread_->RegisterModule(vie_receiver_.GetReceiveStatistics());
+  module_process_thread_->RegisterModule(rtp_rtcp_);
 
-  // RTP/RTCP initialization.
-  module_process_thread_->RegisterModule(rtp_rtcp_.get());
-  packet_router_->AddRtpModule(rtp_rtcp_.get());
-
-  rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
   if (video_receiver_->RegisterReceiveCallback(this) != 0) {
     return -1;
   }
   video_receiver_->RegisterFrameTypeCallback(this);
   video_receiver_->RegisterReceiveStatisticsCallback(this);
   video_receiver_->RegisterDecoderTimingCallback(this);
   video_receiver_->SetRenderDelay(kDefaultRenderDelayMs);
 
   return 0;
 }
 
 ViEChannel::~ViEChannel() {
   // Make sure we don't get more callbacks from the RTP module.
   module_process_thread_->DeRegisterModule(
       vie_receiver_.GetReceiveStatistics());
 
-  packet_router_->RemoveRtpModule(rtp_rtcp_.get());
-  module_process_thread_->DeRegisterModule(rtp_rtcp_.get());
+  module_process_thread_->DeRegisterModule(rtp_rtcp_);
 }
 
 void ViEChannel::SetProtectionMode(bool enable_nack,
                                    bool enable_fec,
                                    int payload_type_red,
                                    int payload_type_fec) {
   // Validate payload types. If either RED or FEC payload types are set then
   // both should be. If FEC is enabled then they both have to be set.
   if (enable_fec || payload_type_red != -1 || payload_type_fec != -1) {
     RTC_DCHECK_GE(payload_type_red, 0);
@@ skipping 54 matching lines @@
 }
 
 RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const {
   RTC_DCHECK(!rtp_rtcp_->Sending());
   RTC_DCHECK_EQ(ssrc, rtp_rtcp_->SSRC());
   return rtp_rtcp_->GetRtpState();
 }
 
 void ViEChannel::RegisterRtcpPacketTypeCounterObserver(
     RtcpPacketTypeCounterObserver* observer) {
-  rtcp_packet_type_counter_observer_.Set(observer);
-}
-
-RtpRtcp* ViEChannel::rtp_rtcp() const {
-  return rtp_rtcp_.get();
+  vie_receiver_.RegisterRtcpPacketTypeCounterObserver(observer);
 }
 
 ViEReceiver* ViEChannel::vie_receiver() {
   return &vie_receiver_;
 }
 
 CallStatsObserver* ViEChannel::GetStatsObserver() {
   return stats_observer_.get();
 }
 
@@ skipping 114 matching lines @@
   rtc::CritScope lock(&crit_);
   receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   rtc::CritScope lock(&crit_);
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc