Removed all RTP dependencies from ViEChannel and renamed class.

webrtc/video/rtp_stream_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/rtp_stream_receiver.h"
 
 #include <vector>
 
 #include "webrtc/base/logging.h"
+#include "webrtc/common_types.h"
 #include "webrtc/config.h"
 #include "webrtc/modules/pacing/packet_router.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/video_coding_impl.h"
@@ skipping 31 matching lines @@
   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;
 }
 
-
 static const int kPacketLogIntervalMs = 10000;
 
 RtpStreamReceiver::RtpStreamReceiver(
     vcm::VideoReceiver* video_receiver,
     RemoteBitrateEstimator* remote_bitrate_estimator,
     Transport* transport,
     RtcpRttStats* rtt_stats,
     PacedSender* paced_sender,
-    PacketRouter* packet_router)
+    PacketRouter* packet_router,
+    const VideoReceiveStream::Config& config,
+    StreamDataCountersCallback* stream_data_counters_callback,
+    RtcpStatisticsCallback* rtcp_statistics_callback,
+    RtcpPacketTypeCounterObserver* rtcp_counter_observer)
     : clock_(Clock::GetRealTimeClock()),
       video_receiver_(video_receiver),
       remote_bitrate_estimator_(remote_bitrate_estimator),
       packet_router_(packet_router),
       ntp_estimator_(clock_),
       rtp_payload_registry_(RTPPayloadStrategy::CreateStrategy(false)),
       rtp_header_parser_(RtpHeaderParser::Create()),
       rtp_receiver_(RtpReceiver::CreateVideoReceiver(clock_,
                                                      this,
                                                      this,
                                                      &rtp_payload_registry_)),
       rtp_receive_statistics_(ReceiveStatistics::Create(clock_)),
       fec_receiver_(FecReceiver::Create(this)),
       receiving_(false),
       restored_packet_in_use_(false),
       last_packet_log_ms_(-1),
       rtp_rtcp_(CreateRtpRtcpModule(rtp_receive_statistics_.get(),
                                     transport,
                                     rtt_stats,
-                                    &rtcp_packet_type_counter_observer_,
+                                    rtcp_counter_observer,
                                     remote_bitrate_estimator_,
                                     paced_sender,
                                     packet_router)) {
   packet_router_->AddRtpModule(rtp_rtcp_.get());
+  rtp_receive_statistics_->RegisterRtpStatisticsCallback(
+      stream_data_counters_callback);
+  rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
+      rtcp_statistics_callback);
+
+  RTC_DCHECK(config.rtp.rtcp_mode != RtcpMode::kOff)
+      << "A stream should not be configured with RTCP disabled. This value is "
+         "reserved for internal usage.";
+  rtp_rtcp_->SetRTCPStatus(config.rtp.rtcp_mode);
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
+
+  static const int kMaxPacketAgeToNack = 450;
+  NACKMethod nack_method =
+      config.rtp.nack.rtp_history_ms > 0 ? kNackRtcp : kNackOff;
+  const int max_reordering_threshold = (nack_method == kNackRtcp)
+      ? kMaxPacketAgeToNack : kDefaultMaxReorderingThreshold;
+  rtp_receiver_->SetNACKStatus(nack_method);
+  rtp_receive_statistics_->SetMaxReorderingThreshold(max_reordering_threshold);
+  rtp_rtcp_->SetGenericFECStatus(false, 0, 0);
 }
 
 RtpStreamReceiver::~RtpStreamReceiver() {
   packet_router_->RemoveRtpModule(rtp_rtcp_.get());
   UpdateHistograms();
 }
 
 void RtpStreamReceiver::UpdateHistograms() {
   FecPacketCounter counter = fec_receiver_->GetPacketCounter();
   if (counter.num_packets > 0) {
@@ skipping 15 matching lines @@
           video_codec.plName, kVideoPayloadTypeFrequency, 0,
           video_codec.maxBitrate, &old_pltype) != -1) {
     rtp_payload_registry_.DeRegisterReceivePayload(old_pltype);
   }
 
   return rtp_receiver_->RegisterReceivePayload(
              video_codec.plName, video_codec.plType, kVideoPayloadTypeFrequency,
              0, 0) == 0;
 }
 
-void RtpStreamReceiver::SetNackStatus(bool enable,
-                                      int max_nack_reordering_threshold) {
-  if (!enable) {
-    // Reset the threshold back to the lower default threshold when NACK is
-    // disabled since we no longer will be receiving retransmissions.
-    max_nack_reordering_threshold = kDefaultMaxReorderingThreshold;
-  }
-  rtp_receive_statistics_->SetMaxReorderingThreshold(
-      max_nack_reordering_threshold);
-  rtp_receiver_->SetNACKStatus(enable ? kNackRtcp : kNackOff);
-}
-
 void RtpStreamReceiver::SetRtxPayloadType(int payload_type,
                                           int associated_payload_type) {
   rtp_payload_registry_.SetRtxPayloadType(payload_type,
                                           associated_payload_type);
 }
 
 void RtpStreamReceiver::SetUseRtxPayloadMappingOnRestore(bool val) {
   rtp_payload_registry_.set_use_rtx_payload_mapping_on_restore(val);
 }
 
@@ skipping 21 matching lines @@
   return rtp_receiver_.get();
 }
 
 void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
     const std::string& extension, int id) {
   RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
   RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
       StringToRtpExtensionType(extension), id));
 }
 
-void RtpStreamReceiver::RegisterRtcpPacketTypeCounterObserver(
-    RtcpPacketTypeCounterObserver* observer) {
-  rtcp_packet_type_counter_observer_.Set(observer);
-}
-
-
 int32_t RtpStreamReceiver::OnReceivedPayloadData(
     const uint8_t* payload_data,
     const size_t payload_size,
     const WebRtcRTPHeader* rtp_header) {
   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 (video_receiver_->IncomingPacket(payload_data, payload_size,
                                       rtp_header_with_ntp) != 0) {
@@ skipping 80 matching lines @@
   rtp_payload_registry_.SetIncomingPayloadType(header);
   bool ret = ReceivePacket(rtp_packet, rtp_packet_length, header, in_order);
   // Update receive statistics after ReceivePacket.
   // Receive statistics will be reset if the payload type changes (make sure
   // that the first packet is included in the stats).
   rtp_receive_statistics_->IncomingPacket(
       header, rtp_packet_length, IsPacketRetransmitted(header, in_order));
   return ret;
 }
 
+int32_t RtpStreamReceiver::RequestKeyFrame() {
+  return rtp_rtcp_->RequestKeyFrame();
+}
+
+int32_t RtpStreamReceiver::SliceLossIndicationRequest(
+    const uint64_t picture_id) {
+  return rtp_rtcp_->SendRTCPSliceLossIndication(
+      static_cast<uint8_t>(picture_id));
+}
+
+int32_t RtpStreamReceiver::ResendPackets(const uint16_t* sequence_numbers,
+                                         uint16_t length) {
+  return rtp_rtcp_->SendNACK(sequence_numbers, length);
+}
+
 bool RtpStreamReceiver::ReceivePacket(const uint8_t* packet,
                                       size_t packet_length,
                                       const RTPHeader& header,
                                       bool in_order) {
   if (rtp_payload_registry_.IsEncapsulated(header)) {
     return ParseAndHandleEncapsulatingHeader(packet, packet_length, header);
   }
   const uint8_t* payload = packet + header.headerLength;
   assert(packet_length >= header.headerLength);
   size_t payload_length = packet_length - header.headerLength;
@@ skipping 141 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