Move simple RtpRtcp calls to VideoSendStream.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 151 matching lines @@
                    congestion_controller_->GetBitrateController()
                        ->CreateRtcpBandwidthObserver(),
                    congestion_controller_->GetTransportFeedbackObserver(),
                    nullptr,
                    call_stats_->rtcp_rtt_stats(),
                    congestion_controller_->pacer(),
                    congestion_controller_->packet_router(),
                    config_.rtp.ssrcs.size(),
                    true),
       vie_receiver_(vie_channel_.vie_receiver()),
+      rtp_rtcp_modules_(vie_channel_.rtp_rtcp()),
       input_(&vie_encoder_,
              config_.local_renderer,
              &stats_proxy_,
              &overuse_detector_) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
 
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
   RTC_DCHECK(module_process_thread_);
   RTC_DCHECK(call_stats_);
   RTC_DCHECK(congestion_controller_);
@@ skipping 20 matching lines @@
       RTC_CHECK_EQ(0, vie_channel_.SetSendAbsoluteSendTimeStatus(true, id));
     } else if (extension == RtpExtension::kVideoRotation) {
       RTC_CHECK_EQ(0, vie_channel_.SetSendVideoRotationStatus(true, id));
     } else if (extension == RtpExtension::kTransportSequenceNumber) {
       RTC_CHECK_EQ(0, vie_channel_.SetSendTransportSequenceNumber(true, id));
     } else {
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
 
-  RtpRtcp* rtp_module = vie_channel_.rtp_rtcp();
-  remb_->AddRembSender(rtp_module);
-  rtp_module->SetREMBStatus(true);
+  remb_->AddRembSender(rtp_rtcp_modules_[0]);
+  rtp_rtcp_modules_[0]->SetREMBStatus(true);
 
   // Enable NACK, FEC or both.
   const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0;
   const bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1;
   // TODO(changbin): Should set RTX for RED mapping in RTP sender in future.
   vie_channel_.SetProtectionMode(enable_protection_nack, enable_protection_fec,
-                                  config_.rtp.fec.red_payload_type,
-                                  config_.rtp.fec.ulpfec_payload_type);
+                                 config_.rtp.fec.red_payload_type,
+                                 config_.rtp.fec.ulpfec_payload_type);
   vie_encoder_.SetProtectionMethod(enable_protection_nack,
-                                    enable_protection_fec);
+                                   enable_protection_fec);
 
   ConfigureSsrcs();
 
-  vie_channel_.SetRTCPCName(config_.rtp.c_name.c_str());
-
+  // TODO(pbos): Should we set CNAME on all RTP modules?
+  rtp_rtcp_modules_.front()->SetCNAME(config_.rtp.c_name.c_str());
   // 28 to match packet overhead in ModuleRtpRtcpImpl.
   RTC_DCHECK_LE(config_.rtp.max_packet_size, static_cast<size_t>(0xFFFF - 28));
-  vie_channel_.SetMTU(static_cast<uint16_t>(config_.rtp.max_packet_size + 28));
+  const uint16_t mtu = static_cast<uint16_t>(config_.rtp.max_packet_size + 28);

[stefan-webrtc, 2016/02/22 13:11:52]

Make 28 a named constant.

[pbos-webrtc, 2016/02/22 13:21:01]

Done.

+  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
+    rtp_rtcp->RegisterRtcpStatisticsCallback(&stats_proxy_);
+    rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
+    rtp_rtcp->SetMaxTransferUnit(mtu);
+  }
 
   RTC_DCHECK(config.encoder_settings.encoder != nullptr);
   RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
   RTC_CHECK_EQ(0, vie_encoder_.RegisterExternalEncoder(
                       config.encoder_settings.encoder,
                       config.encoder_settings.payload_type,
                       config.encoder_settings.internal_source));
 
   RTC_CHECK(ReconfigureVideoEncoder(encoder_config));
 
   vie_channel_.RegisterSendSideDelayObserver(&stats_proxy_);
 
   if (config_.post_encode_callback)
     vie_encoder_.RegisterPostEncodeImageCallback(&encoded_frame_proxy_);
 
   if (config_.suspend_below_min_bitrate)
     vie_encoder_.SuspendBelowMinBitrate();
 
   encoder_feedback_.AddEncoder(config_.rtp.ssrcs, &vie_encoder_);
 
-  vie_channel_.RegisterSendChannelRtcpStatisticsCallback(&stats_proxy_);
-  vie_channel_.RegisterSendChannelRtpStatisticsCallback(&stats_proxy_);
   vie_channel_.RegisterRtcpPacketTypeCounterObserver(&stats_proxy_);
   vie_channel_.RegisterSendBitrateObserver(&stats_proxy_);
   vie_channel_.RegisterSendFrameCountObserver(&stats_proxy_);
 
   module_process_thread_->RegisterModule(&overuse_detector_);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
   Stop();
 
   module_process_thread_->DeRegisterModule(&overuse_detector_);
   // Remove vcm_protection_callback (part of vie_channel_) before destroying
   // ViEChannel. vcm_ is owned by ViEEncoder and the registered callback does
   // not outlive it.
   vcm_->RegisterProtectionCallback(nullptr);
   vie_channel_.RegisterSendFrameCountObserver(nullptr);
   vie_channel_.RegisterSendBitrateObserver(nullptr);
   vie_channel_.RegisterRtcpPacketTypeCounterObserver(nullptr);
-  vie_channel_.RegisterSendChannelRtpStatisticsCallback(nullptr);
-  vie_channel_.RegisterSendChannelRtcpStatisticsCallback(nullptr);
 
-  vie_encoder_.DeRegisterExternalEncoder(
-      config_.encoder_settings.payload_type);
+  vie_encoder_.DeRegisterExternalEncoder(config_.encoder_settings.payload_type);
 
   call_stats_->DeregisterStatsObserver(vie_channel_.GetStatsObserver());
-
-  RtpRtcp* rtp_module = vie_channel_.rtp_rtcp();
-  rtp_module->SetREMBStatus(false);
-  remb_->RemoveRembSender(rtp_module);
+  rtp_rtcp_modules_[0]->SetREMBStatus(false);
+  remb_->RemoveRembSender(rtp_rtcp_modules_[0]);
 
   // Remove the feedback, stop all encoding threads and processing. This must be
   // done before deleting the channel.
   encoder_feedback_.RemoveEncoder(&vie_encoder_);
 
   congestion_controller_->GetRemoteBitrateEstimator(false)->RemoveStream(
       vie_receiver_->GetRemoteSsrc());
 }
 
 VideoCaptureInput* VideoSendStream::Input() {
@@ skipping 182 matching lines @@
   if (config_.overuse_callback)
     config_.overuse_callback->OnLoadUpdate(LoadObserver::kOveruse);
 }
 
 void VideoSendStream::NormalUsage() {
   if (config_.overuse_callback)
     config_.overuse_callback->OnLoadUpdate(LoadObserver::kUnderuse);
 }
 
 void VideoSendStream::ConfigureSsrcs() {
-  vie_channel_.SetSSRC(config_.rtp.ssrcs.front(), kViEStreamTypeNormal, 0);
+  // Configure regular SSRCs.
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
-    vie_channel_.SetSSRC(ssrc, kViEStreamTypeNormal,
-                          static_cast<unsigned char>(i));
+    RtpRtcp* const rtp_rtcp = rtp_rtcp_modules_[i];
+    rtp_rtcp->SetSSRC(ssrc);
+
+    // Restore RTP state if previous existed.
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
-      vie_channel_.SetRtpStateForSsrc(ssrc, it->second);
+      rtp_rtcp->SetRtpStateForSsrc(ssrc, it->second);
   }
 
-  if (config_.rtp.rtx.ssrcs.empty()) {
+  // Set up RTX if available.
+  if (config_.rtp.rtx.ssrcs.empty())
     return;
-  }
 
-  // Set up RTX.
+  // Configure RTX SSRCs.
   RTC_DCHECK_EQ(config_.rtp.rtx.ssrcs.size(), config_.rtp.ssrcs.size());
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.rtx.ssrcs[i];
-    vie_channel_.SetSSRC(config_.rtp.rtx.ssrcs[i], kViEStreamTypeRtx,
-                          static_cast<unsigned char>(i));
+    RtpRtcp* const rtp_rtcp = rtp_rtcp_modules_[i];
+    rtp_rtcp->SetRtxSsrc(ssrc);
     RtpStateMap::iterator it = suspended_ssrcs_.find(ssrc);
     if (it != suspended_ssrcs_.end())
-      vie_channel_.SetRtpStateForSsrc(ssrc, it->second);
+      rtp_rtcp->SetRtpStateForSsrc(ssrc, it->second);
   }
 
+  // Configure RTX payload types.
   RTC_DCHECK_GE(config_.rtp.rtx.payload_type, 0);
-  vie_channel_.SetRtxSendPayloadType(config_.rtp.rtx.payload_type,
-                                      config_.encoder_settings.payload_type);
+  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
+    rtp_rtcp->SetRtxSendPayloadType(config_.rtp.rtx.payload_type,
+                                    config_.encoder_settings.payload_type);
+  }
   if (config_.rtp.fec.red_payload_type != -1 &&
       config_.rtp.fec.red_rtx_payload_type != -1) {
-    vie_channel_.SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type,
-                                        config_.rtp.fec.red_payload_type);
+    for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
+      rtp_rtcp->SetRtxSendPayloadType(config_.rtp.fec.red_rtx_payload_type,
+                                      config_.rtp.fec.red_payload_type);
+    }
   }
+  // Enable RTX in RTP modules.
+  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
+    rtp_rtcp->SetRtxSendStatus(kRtxRetransmitted | kRtxRedundantPayloads);

[stefan-webrtc, 2016/02/22 13:11:52]

I think you can move this to line 524 or 517

[pbos-webrtc, 2016/02/22 13:21:01]

Done.

 }
 
 std::map<uint32_t, RtpState> VideoSendStream::GetRtpStates() const {
   std::map<uint32_t, RtpState> rtp_states;
   for (size_t i = 0; i < config_.rtp.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.ssrcs[i];
     rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc);
   }
 
   for (size_t i = 0; i < config_.rtp.rtx.ssrcs.size(); ++i) {
     uint32_t ssrc = config_.rtp.rtx.ssrcs[i];
     rtp_states[ssrc] = vie_channel_.GetRtpStateForSsrc(ssrc);
   }
 
   return rtp_states;
 }
 
 void VideoSendStream::SignalNetworkState(NetworkState state) {
   // When network goes up, enable RTCP status before setting transmission state.
   // When it goes down, disable RTCP afterwards. This ensures that any packets
   // sent due to the network state changed will not be dropped.
-  if (state == kNetworkUp)
-    vie_channel_.SetRTCPMode(config_.rtp.rtcp_mode);
+  if (state == kNetworkUp) {
+    for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
+      rtp_rtcp->SetRTCPStatus(config_.rtp.rtcp_mode);
+  }
   vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp);
-  if (state == kNetworkDown)
-    vie_channel_.SetRTCPMode(RtcpMode::kOff);
+  if (state == kNetworkDown) {
+    for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
+      rtp_rtcp->SetRTCPStatus(RtcpMode::kOff);
+  }
 }
 
 int64_t VideoSendStream::GetRtt() const {
   webrtc::RtcpStatistics rtcp_stats;
   uint16_t frac_lost;
   uint32_t cumulative_lost;
   uint32_t extended_max_sequence_number;
   uint32_t jitter;
   int64_t rtt_ms;
   if (vie_channel_.GetSendRtcpStatistics(&frac_lost, &cumulative_lost,
-                                          &extended_max_sequence_number,
-                                          &jitter, &rtt_ms) == 0) {
+                                         &extended_max_sequence_number, &jitter,
+                                         &rtt_ms) == 0) {
     return rtt_ms;
   }
   return -1;
 }
 
 int VideoSendStream::GetPaddingNeededBps() const {
   return vie_encoder_.GetPaddingNeededBps();
 }
 
 bool VideoSendStream::SetSendCodec(VideoCodec video_codec) {
@@ skipping 29 matching lines @@
   used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams));
   vie_encoder_.SetSsrcs(used_ssrcs);
 
   // Restart the media flow
   vie_encoder_.Restart();
 
   return true;
 }
 }  // namespace internal
 }  // namespace webrtc