Move simple RtpRtcp calls to VideoSendStream.

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.
  */
 
@@ skipping 391 matching lines @@
     packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_);
   }
   // Register new active modules.
   for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) {
     module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]);
     packet_router_->AddRtpModule(rtp_rtcp_modules_[i], sender_);
   }
   return 0;
 }
 
-void ViEChannel::SetRTCPMode(const RtcpMode rtcp_mode) {
-  RTC_DCHECK(sender_);
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->SetRTCPStatus(rtcp_mode);
-}
-
 void ViEChannel::SetProtectionMode(bool enable_nack,
                                    bool enable_fec,
                                    int payload_type_red,
                                    int payload_type_fec) {
   // Validate payload types.
   if (enable_fec) {
     RTC_DCHECK_GE(payload_type_red, 0);
     RTC_DCHECK_GE(payload_type_fec, 0);
     RTC_DCHECK_LE(payload_type_red, 127);
     RTC_DCHECK_LE(payload_type_fec, 127);
@@ skipping 47 matching lines @@
       for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
         rtp_rtcp->SetStorePacketsStatus(false, 0);
       // 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);
     }
     vie_receiver_.SetNackStatus(false, max_nack_reordering_threshold_);
   }
 }
 
-bool ViEChannel::IsSendingFecEnabled() {
-  bool fec_enabled = false;
-  uint8_t pltype_red = 0;
-  uint8_t pltype_fec = 0;
-
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
-    rtp_rtcp->GenericFECStatus(&fec_enabled, &pltype_red, &pltype_fec);
-    if (fec_enabled)
-      return true;
-  }
-  return false;
-}
-
 int ViEChannel::SetSenderBufferingMode(int target_delay_ms) {
   if ((target_delay_ms < 0) || (target_delay_ms > kMaxTargetDelayMs)) {
     LOG(LS_ERROR) << "Invalid send buffer value.";
     return -1;
   }
   if (target_delay_ms == 0) {
     // Real-time mode.
     nack_history_size_sender_ = kMinSendSidePacketHistorySize;
   } else {
     nack_history_size_sender_ = GetRequiredNackListSize(target_delay_ms);
@@ skipping 72 matching lines @@
     return 0;
   // Enable the extension.
   int error = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     error |= rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionTransportSequenceNumber, id);
   }
   return error;
 }
 
-int32_t ViEChannel::SetSSRC(const uint32_t SSRC,
-                            const StreamType usage,
-                            const uint8_t simulcast_idx) {
-  RTC_DCHECK(sender_);
-  RtpRtcp* rtp_rtcp = rtp_rtcp_modules_[simulcast_idx];
-  if (usage == kViEStreamTypeRtx) {
-    rtp_rtcp->SetRtxSsrc(SSRC);
-  } else {
-    rtp_rtcp->SetSSRC(SSRC);
-  }
-  return 0;
-}
-
-int32_t ViEChannel::GetLocalSSRC(uint8_t idx, unsigned int* ssrc) {
-  RTC_DCHECK_LE(idx, rtp_rtcp_modules_.size());
-  *ssrc = rtp_rtcp_modules_[idx]->SSRC();
-  return 0;
-}
-
-int ViEChannel::SetRtxSendPayloadType(int payload_type,
-                                      int associated_payload_type) {
-  RTC_DCHECK(sender_);
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->SetRtxSendPayloadType(payload_type, associated_payload_type);
-  SetRtxSendStatus(true);
-  return 0;
-}
-
-void ViEChannel::SetRtxSendStatus(bool enable) {
-  int rtx_settings =
-      enable ? kRtxRetransmitted | kRtxRedundantPayloads : kRtxOff;
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->SetRtxSendStatus(rtx_settings);
-}
-
-void ViEChannel::SetRtpStateForSsrc(uint32_t ssrc, const RtpState& rtp_state) {
-  RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
-    if (rtp_rtcp->SetRtpStateForSsrc(ssrc, rtp_state))
-      return;
-  }
-}
-
 RtpState ViEChannel::GetRtpStateForSsrc(uint32_t ssrc) const {
   RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
   RtpState rtp_state;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     if (rtp_rtcp->GetRtpStateForSsrc(ssrc, &rtp_state))
       return rtp_state;
   }
   LOG(LS_ERROR) << "Couldn't get RTP state for ssrc: " << ssrc;
   return rtp_state;
 }
 
-// TODO(pbos): Set CNAME on all modules.
-int32_t ViEChannel::SetRTCPCName(const char* rtcp_cname) {
-  RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
-  return rtp_rtcp_modules_[0]->SetCNAME(rtcp_cname);
-}
-
-int32_t ViEChannel::GetRemoteRTCPCName(char rtcp_cname[]) {
-  uint32_t remoteSSRC = vie_receiver_.GetRemoteSsrc();
-  return rtp_rtcp_modules_[0]->RemoteCNAME(remoteSSRC, rtcp_cname);
-}
-
 int32_t ViEChannel::GetSendRtcpStatistics(uint16_t* fraction_lost,
                                           uint32_t* cumulative_lost,
                                           uint32_t* extended_max,
                                           uint32_t* jitter_samples,
                                           int64_t* rtt_ms) const {
   // Aggregate the report blocks associated with streams sent on this channel.
   std::vector<RTCPReportBlock> report_blocks;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->RemoteRTCPStat(&report_blocks);
 
@@ skipping 27 matching lines @@
   int64_t dummy;
   int64_t rtt = 0;
   if (rtp_rtcp_modules_[0]->RTT(remote_ssrc, &rtt, &dummy, &dummy, &dummy) !=
       0) {
     return -1;
   }
   *rtt_ms = rtt;
   return 0;
 }
 
-void ViEChannel::RegisterSendChannelRtcpStatisticsCallback(
-    RtcpStatisticsCallback* callback) {
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->RegisterRtcpStatisticsCallback(callback);
-}
-
 void ViEChannel::RegisterRtcpPacketTypeCounterObserver(
     RtcpPacketTypeCounterObserver* observer) {
   rtcp_packet_type_counter_observer_.Set(observer);
 }
 
 void ViEChannel::GetSendStreamDataCounters(
     StreamDataCounters* rtp_counters,
     StreamDataCounters* rtx_counters) const {
   *rtp_counters = StreamDataCounters();
   *rtx_counters = StreamDataCounters();
@@ skipping 17 matching lines @@
   uint32_t rtx_ssrc = 0;
   if (vie_receiver_.GetRtxSsrc(&rtx_ssrc)) {
     StreamStatistician* statistician =
         vie_receiver_.GetReceiveStatistics()->GetStatistician(rtx_ssrc);
     if (statistician) {
       statistician->GetReceiveStreamDataCounters(rtx_counters);
     }
   }
 }
 
-void ViEChannel::RegisterSendChannelRtpStatisticsCallback(
-      StreamDataCountersCallback* callback) {
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(callback);
-}
-
 void ViEChannel::GetSendRtcpPacketTypeCounter(
     RtcpPacketTypeCounter* packet_counter) const {
   std::map<uint32_t, RtcpPacketTypeCounter> counter_map =
       rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap();
 
   RtcpPacketTypeCounter counter;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     counter.Add(counter_map[rtp_rtcp->SSRC()]);
   *packet_counter = counter;
 }
@@ skipping 45 matching lines @@
   if (!rtp_rtcp_modules_[0]->Sending()) {
     return -1;
   }
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetSendingStatus(false);
   }
   return 0;
 }
 
-int32_t ViEChannel::SetMTU(uint16_t mtu) {
-  RTC_DCHECK(sender_);
-  for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
-    rtp_rtcp->SetMaxTransferUnit(mtu);
-  return 0;
-}
-
-RtpRtcp* ViEChannel::rtp_rtcp() {
-  return rtp_rtcp_modules_[0];
+const std::vector<RtpRtcp*>& ViEChannel::rtp_rtcp() const {
+  return rtp_rtcp_modules_;
 }
 
 ViEReceiver* ViEChannel::vie_receiver() {
   return &vie_receiver_;
 }
 
 VCMProtectionCallback* ViEChannel::vcm_protection_callback() {
   return vcm_protection_callback_.get();
 }
 
@@ skipping 216 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