Use vcm::VideoReceiver on the receive side.

webrtc/video/vie_receiver.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_receiver.h"
 
 #include <vector>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/rtp_rtcp/include/fec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/receive_statistics.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_cvo.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
-#include "webrtc/modules/video_coding/include/video_coding.h"
+#include "webrtc/modules/video_coding/video_coding_impl.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
 #include "webrtc/system_wrappers/include/timestamp_extrapolator.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
 namespace webrtc {
 
 static const int kPacketLogIntervalMs = 10000;
 
-ViEReceiver::ViEReceiver(VideoCodingModule* module_vcm,
+ViEReceiver::ViEReceiver(vcm::VideoReceiver* video_receiver,
                          RemoteBitrateEstimator* remote_bitrate_estimator,
                          RtpFeedback* rtp_feedback)
     : clock_(Clock::GetRealTimeClock()),
-      vcm_(module_vcm),
+      video_receiver_(video_receiver),
       remote_bitrate_estimator_(remote_bitrate_estimator),
       ntp_estimator_(clock_),
       rtp_payload_registry_(RTPPayloadStrategy::CreateStrategy(false)),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
                                                      this,
                                                      rtp_feedback,
                                                      &rtp_payload_registry_)),
       rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
       fec_receiver_(FecReceiver::Create(this)),
@@ skipping 86 matching lines @@
 void ViEReceiver::EnableReceiveRtpHeaderExtension(const std::string& extension,
                                                   int id) {
   RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
   RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
       StringToRtpExtensionType(extension), id));
 }
 
 int32_t ViEReceiver::OnReceivedPayloadData(const uint8_t* payload_data,
                                            const size_t payload_size,
                                            const WebRtcRTPHeader* rtp_header) {
-  RTC_DCHECK(vcm_);
+  RTC_DCHECK(video_receiver_);
   WebRtcRTPHeader rtp_header_with_ntp = *rtp_header;
   rtp_header_with_ntp.ntp_time_ms =
       ntp_estimator_.Estimate(rtp_header->header.timestamp);
-  if (vcm_->IncomingPacket(payload_data,
-                           payload_size,
-                           rtp_header_with_ntp) != 0) {
+  if (video_receiver_->IncomingPacket(payload_data, payload_size,
+                                      rtp_header_with_ntp) != 0) {
     // Check this...
     return -1;
   }
   return 0;
 }
 
 bool ViEReceiver::OnRecoveredPacket(const uint8_t* rtp_packet,
                                     size_t rtp_packet_length) {
   RTPHeader header;
   if (!rtp_header_parser_->Parse(rtp_packet, rtp_packet_length, &header)) {
@@ skipping 80 matching lines @@
                                           payload_specific, in_order);
 }
 
 bool ViEReceiver::ParseAndHandleEncapsulatingHeader(const uint8_t* packet,
                                                     size_t packet_length,
                                                     const RTPHeader& header) {
   if (rtp_payload_registry_.IsRed(header)) {
     int8_t ulpfec_pt = rtp_payload_registry_.ulpfec_payload_type();
     if (packet[header.headerLength] == ulpfec_pt) {
       rtp_receive_statistics_->FecPacketReceived(header, packet_length);
-      // Notify vcm about received FEC packets to avoid NACKing these packets.
+      // Notify video_receiver about received FEC packets to avoid NACKing these
+      // packets.
       NotifyReceiverOfFecPacket(header);
     }
     if (fec_receiver_->AddReceivedRedPacket(
             header, packet, packet_length, ulpfec_pt) != 0) {
       return false;
     }
     return fec_receiver_->ProcessReceivedFec() == 0;
   } else if (rtp_payload_registry_.IsRtx(header)) {
     if (header.headerLength + header.paddingLength == packet_length) {
       // This is an empty packet and should be silently dropped before trying to
@@ skipping 114 matching lines @@
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   // Check if this is a retransmission.
   int64_t min_rtt = 0;
   rtp_rtcp_->RTT(rtp_receiver_->SSRC(), nullptr, nullptr, &min_rtt, nullptr);
   return !in_order &&
       statistician->IsRetransmitOfOldPacket(header, min_rtt);
 }
 }  // namespace webrtc