Move, almost, all receive side references to RTP to RtpStreamReceiver.

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.
  */
 
@@ skipping 11 matching lines @@
 #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"
 #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"
 #include "webrtc/video/receive_statistics_proxy.h"
+#include "webrtc/video/vie_remb.h"
 
 namespace webrtc {
 
 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,
@@ skipping 27 matching lines @@
 
 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,
+    VieRemb* remb,
     const VideoReceiveStream::Config& config,
-    ReceiveStatisticsProxy* receive_stats_proxy)
+    ReceiveStatisticsProxy* receive_stats_proxy,
+    ProcessThread* process_thread)
     : clock_(Clock::GetRealTimeClock()),
+      config_(config),
       video_receiver_(video_receiver),
       remote_bitrate_estimator_(remote_bitrate_estimator),
       packet_router_(packet_router),
+      remb_(remb),
+      process_thread_(process_thread),
       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,
                                     receive_stats_proxy,
                                     remote_bitrate_estimator_,
                                     paced_sender,
                                     packet_router)) {
   packet_router_->AddRtpModule(rtp_rtcp_.get());
   rtp_receive_statistics_->RegisterRtpStatisticsCallback(receive_stats_proxy);
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(receive_stats_proxy);
 
   RTC_DCHECK(config.rtp.rtcp_mode != RtcpMode::kOff)
       << "A stream should not be configured with RTCP disabled. This value is "
          "reserved for internal usage.";
+  RTC_DCHECK(config_.rtp.remote_ssrc != 0);
+  // TODO(pbos): What's an appropriate local_ssrc for receive-only streams?
+  RTC_DCHECK(config_.rtp.local_ssrc != 0);
+  RTC_DCHECK(config_.rtp.remote_ssrc != config_.rtp.local_ssrc);
+
   rtp_rtcp_->SetRTCPStatus(config.rtp.rtcp_mode);
+  rtp_rtcp_->SetSSRC(config.rtp.local_ssrc);
   rtp_rtcp_->SetKeyFrameRequestMethod(kKeyFrameReqPliRtcp);
+  if (config.rtp.remb) {
+    rtp_rtcp_->SetREMBStatus(true);
+    remb_->AddReceiveChannel(rtp_rtcp_.get());
+  }
+
+  for (size_t i = 0; i < config.rtp.extensions.size(); ++i) {
+    EnableReceiveRtpHeaderExtension(config.rtp.extensions[i].name,
+                                    config.rtp.extensions[i].id);
+  }
 
   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);
+
+  // TODO(pbos): Support multiple RTX, per video payload.
+  for (const auto& kv : config_.rtp.rtx) {
+    RTC_DCHECK(kv.second.ssrc != 0);
+    RTC_DCHECK(kv.second.payload_type != 0);
+
+    rtp_payload_registry_.SetRtxSsrc(kv.second.ssrc);
+    rtp_payload_registry_.SetRtxPayloadType(kv.second.payload_type,
+                                            kv.first);
+  }
+
+  // If set to true, the RTX payload type mapping supplied in
+  // |SetRtxPayloadType| will be used when restoring RTX packets. Without it,
+  // RTX packets will always be restored to the last non-RTX packet payload type
+  // received.
+  // TODO(holmer): When Chrome no longer depends on this being false by default,
+  // always use the mapping and remove this whole codepath.
+  rtp_payload_registry_.set_use_rtx_payload_mapping_on_restore(
+      config_.rtp.use_rtx_payload_mapping_on_restore);
+
+  if (IsFecEnabled()) {
+    VideoCodec ulpfec_codec = {};
+    ulpfec_codec.codecType = kVideoCodecULPFEC;
+    strncpy(ulpfec_codec.plName, "ulpfec", sizeof(ulpfec_codec.plName));
+    ulpfec_codec.plType = config_.rtp.fec.ulpfec_payload_type;
+    RTC_CHECK(SetReceiveCodec(ulpfec_codec));
+
+    VideoCodec red_codec = {};
+    red_codec.codecType = kVideoCodecRED;
+    strncpy(red_codec.plName, "red", sizeof(red_codec.plName));
+    red_codec.plType = config_.rtp.fec.red_payload_type;
+    RTC_CHECK(SetReceiveCodec(red_codec));
+    if (config_.rtp.fec.red_rtx_payload_type != -1) {
+      rtp_payload_registry_.SetRtxPayloadType(
+          config_.rtp.fec.red_rtx_payload_type,
+          config_.rtp.fec.red_payload_type);
+    }
+  }
+
+  if (config.rtp.rtcp_xr.receiver_reference_time_report)
+    rtp_rtcp_->SetRtcpXrRrtrStatus(true);
+
+  // Stats callback for CNAME changes.
+  rtp_rtcp_->RegisterRtcpStatisticsCallback(receive_stats_proxy);
+
+  process_thread_->RegisterModule(rtp_receive_statistics_.get());
+  process_thread_->RegisterModule(rtp_rtcp_.get());
 }
 
 RtpStreamReceiver::~RtpStreamReceiver() {
+  process_thread_->DeRegisterModule(rtp_receive_statistics_.get());
+  process_thread_->DeRegisterModule(rtp_rtcp_.get());
+
   packet_router_->RemoveRtpModule(rtp_rtcp_.get());
+  rtp_rtcp_->SetREMBStatus(false);
+  remb_->RemoveReceiveChannel(rtp_rtcp_.get());
   UpdateHistograms();
 }
 
-void RtpStreamReceiver::UpdateHistograms() {
-  FecPacketCounter counter = fec_receiver_->GetPacketCounter();
-  if (counter.num_packets > 0) {
-    RTC_LOGGED_HISTOGRAM_PERCENTAGE(
-        "WebRTC.Video.ReceivedFecPacketsInPercent",
-        static_cast<int>(counter.num_fec_packets * 100 / counter.num_packets));
-  }
-  if (counter.num_fec_packets > 0) {
-    RTC_LOGGED_HISTOGRAM_PERCENTAGE(
-        "WebRTC.Video.RecoveredMediaPacketsInPercentOfFec",
-        static_cast<int>(counter.num_recovered_packets * 100 /
-                         counter.num_fec_packets));
-  }
-}
-
 bool RtpStreamReceiver::SetReceiveCodec(const VideoCodec& video_codec) {
   int8_t old_pltype = -1;
   if (rtp_payload_registry_.ReceivePayloadType(
           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::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);
-}
-
-void RtpStreamReceiver::SetRtxSsrc(uint32_t ssrc) {
-  rtp_payload_registry_.SetRtxSsrc(ssrc);
-}
-
-bool RtpStreamReceiver::GetRtxSsrc(uint32_t* ssrc) const {
-  return rtp_payload_registry_.GetRtxSsrc(ssrc);
-}
-
-bool RtpStreamReceiver::IsFecEnabled() const {
-  return rtp_payload_registry_.ulpfec_payload_type() > -1;
-}
-
 uint32_t RtpStreamReceiver::GetRemoteSsrc() const {
   return rtp_receiver_->SSRC();
 }
 
 int RtpStreamReceiver::GetCsrcs(uint32_t* csrcs) const {
   return rtp_receiver_->CSRCs(csrcs);
 }
 
 RtpReceiver* RtpStreamReceiver::GetRtpReceiver() const {
   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));
-}
-
 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 90 matching lines @@
 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));
 }
 
+bool RtpStreamReceiver::IsFecEnabled() const {
+  return config_.rtp.fec.red_payload_type != -1 &&
+      config_.rtp.fec.ulpfec_payload_type != -1;
+}
+
+bool RtpStreamReceiver::IsRetransmissionsEnabled() const {
+  return config_.rtp.nack.rtp_history_ms > 0;
+}
+
+void RtpStreamReceiver::RequestPacketRetransmit(
+    const std::vector<uint16_t>& sequence_numbers) {
+  rtp_rtcp_->SendNack(sequence_numbers);
+}
+
 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)) {
@@ skipping 108 matching lines @@
   if (rtp_rtcp_->RemoteNTP(&ntp_secs, &ntp_frac, nullptr, nullptr,
                            &rtp_timestamp) != 0) {
     // Waiting for RTCP.
     return true;
   }
   ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
 
   return true;
 }
 
+void RtpStreamReceiver::SignalNetworkState(NetworkState state) {
+  rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
+                                               : RtcpMode::kOff);
+}
+
 void RtpStreamReceiver::StartReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = true;
 }
 
 void RtpStreamReceiver::StopReceive() {
   rtc::CritScope lock(&receive_cs_);
   receiving_ = false;
 }
 
-ReceiveStatistics* RtpStreamReceiver::GetReceiveStatistics() const {
-  return rtp_receive_statistics_.get();
-}
-
 bool RtpStreamReceiver::IsPacketInOrder(const RTPHeader& header) const {
   StreamStatistician* statistician =
       rtp_receive_statistics_->GetStatistician(header.ssrc);
   if (!statistician)
     return false;
   return statistician->IsPacketInOrder(header.sequenceNumber);
 }
 
 bool RtpStreamReceiver::IsPacketRetransmitted(const RTPHeader& header,
                                               bool in_order) const {
   // Retransmissions are handled separately if RTX is enabled.
   if (rtp_payload_registry_.RtxEnabled())
     return false;
   StreamStatistician* statistician =
       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);
 }
+
+void RtpStreamReceiver::UpdateHistograms() {
+  FecPacketCounter counter = fec_receiver_->GetPacketCounter();
+  if (counter.num_packets > 0) {
+    RTC_LOGGED_HISTOGRAM_PERCENTAGE(
+        "WebRTC.Video.ReceivedFecPacketsInPercent",
+        static_cast<int>(counter.num_fec_packets * 100 / counter.num_packets));
+  }
+  if (counter.num_fec_packets > 0) {
+    RTC_LOGGED_HISTOGRAM_PERCENTAGE(
+        "WebRTC.Video.RecoveredMediaPacketsInPercentOfFec",
+        static_cast<int>(counter.num_recovered_packets * 100 /
+                         counter.num_fec_packets));
+  }
+}
+
+void RtpStreamReceiver::EnableReceiveRtpHeaderExtension(
+    const std::string& extension, int id) {
+  // One-byte-extension local identifiers are in the range 1-14 inclusive.
+  RTC_DCHECK_GE(id, 1);
+  RTC_DCHECK_LE(id, 14);
+  RTC_DCHECK(RtpExtension::IsSupportedForVideo(extension));
+  RTC_CHECK(rtp_header_parser_->RegisterRtpHeaderExtension(
+      StringToRtpExtensionType(extension), id));
+}
+
 }  // namespace webrtc