Use vcm::VideoReceiver on the receive side.

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/include/video_coding.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;
@@ skipping 47 matching lines @@
   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,
-                       VideoCodingModule* vcm,
+                       vcm::VideoReceiver* video_receiver,
                        RemoteBitrateEstimator* remote_bitrate_estimator,
                        RtcpRttStats* rtt_stats,
                        PacedSender* paced_sender,
                        PacketRouter* packet_router)
     : module_process_thread_(module_process_thread),
-      vcm_(vcm),
-      vie_receiver_(vcm_, remote_bitrate_estimator, this),
+      video_receiver_(video_receiver),
+      vie_receiver_(video_receiver_, remote_bitrate_estimator, this),
       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());
-  RTC_DCHECK(vcm_);
-  vcm_->SetNackSettings(kMaxNackListSize, max_nack_reordering_threshold_, 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());
 
   // RTP/RTCP initialization.
   module_process_thread_->RegisterModule(rtp_rtcp_.get());
   packet_router_->AddRtpModule(rtp_rtcp_.get());
 
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
-  if (vcm_->RegisterReceiveCallback(this) != 0) {
+  if (video_receiver_->RegisterReceiveCallback(this) != 0) {
     return -1;
   }
-  vcm_->RegisterFrameTypeCallback(this);
-  vcm_->RegisterReceiveStatisticsCallback(this);
-  vcm_->RegisterDecoderTimingCallback(this);
-  vcm_->SetRenderDelay(kDefaultRenderDelayMs);
+  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());
@@ skipping 20 matching lines @@
     payload_type_fec = 0;
   }
 
   VCMVideoProtection protection_method;
   if (enable_nack) {
     protection_method = enable_fec ? kProtectionNackFEC : kProtectionNack;
   } else {
     protection_method = kProtectionNone;
   }
 
-  vcm_->SetVideoProtection(protection_method, true);
+  video_receiver_->SetVideoProtection(protection_method, true);
 
   // Set NACK.
   ProcessNACKRequest(enable_nack);
 
   // Set FEC.
   rtp_rtcp_->SetGenericFECStatus(enable_fec,
                                  static_cast<uint8_t>(payload_type_red),
                                  static_cast<uint8_t>(payload_type_fec));
 }
 
 void ViEChannel::ProcessNACKRequest(const bool enable) {
   if (enable) {
     // Turn on NACK.
     if (rtp_rtcp_->RTCP() == RtcpMode::kOff)
       return;
     vie_receiver_.SetNackStatus(true, max_nack_reordering_threshold_);
-    vcm_->RegisterPacketRequestCallback(this);
+    video_receiver_->RegisterPacketRequestCallback(this);
     // Don't introduce errors when NACK is enabled.
-    vcm_->SetDecodeErrorMode(kNoErrors);
+    video_receiver_->SetDecodeErrorMode(kNoErrors);
 
   } else {
-    vcm_->RegisterPacketRequestCallback(nullptr);
+    video_receiver_->RegisterPacketRequestCallback(nullptr);
     // When NACK is off, allow decoding with errors. Otherwise, the video
     // will freeze, and will only recover with a complete key frame.
-    vcm_->SetDecodeErrorMode(kWithErrors);
+    video_receiver_->SetDecodeErrorMode(kWithErrors);
     vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
   }
 }
 
 int ViEChannel::GetRequiredNackListSize(int target_delay_ms) {
   // The max size of the nack list should be large enough to accommodate the
   // the number of packets (frames) resulting from the increased delay.
   // Roughly estimating for ~40 packets per frame @ 30fps.
   return target_delay_ms * 40 * 30 / 1000;
 }
@@ skipping 14 matching lines @@
 }
 
 ViEReceiver* ViEChannel::vie_receiver() {
   return &vie_receiver_;
 }
 
 CallStatsObserver* ViEChannel::GetStatsObserver() {
   return stats_observer_.get();
 }
 
-// Do not acquire the lock of |vcm_| in this function. Decode callback won't
-// necessarily be called from the decoding thread. The decoding thread may have
-// held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring
-// the same lock in the path of decode callback can deadlock.
+// Do not acquire the lock of |video_receiver_| in this function. Decode
+// callback won't necessarily be called from the decoding thread. The decoding
+// thread may have held the lock when calling VideoDecoder::Decode, Reset, or
+// Release. Acquiring the same lock in the path of decode callback can deadlock.
 int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) {  // NOLINT
   rtc::CritScope lock(&crit_);
 
   if (pre_render_callback_)
     pre_render_callback_->FrameCallback(&video_frame);
 
   // TODO(pbos): Remove stream id argument.
   incoming_video_stream_->RenderFrame(0xFFFFFFFF, video_frame);
   return 0;
 }
@@ skipping 58 matching lines @@
   return rtp_rtcp_->SendRTCPSliceLossIndication(
       static_cast<uint8_t>(picture_id));
 }
 
 int32_t ViEChannel::ResendPackets(const uint16_t* sequence_numbers,
                                   uint16_t length) {
   return rtp_rtcp_->SendNACK(sequence_numbers, length);
 }
 
 void ViEChannel::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
-  vcm_->SetReceiveChannelParameters(max_rtt_ms);
+  video_receiver_->SetReceiveChannelParameters(max_rtt_ms);
 
   rtc::CritScope lock(&crit_);
   last_rtt_ms_ = avg_rtt_ms;
 }
 
 void ViEChannel::RegisterPreRenderCallback(
     I420FrameCallback* pre_render_callback) {
   rtc::CritScope lock(&crit_);
   pre_render_callback_ = pre_render_callback;
 }
@@ skipping 21 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