Remove ViEChannel calls for VideoReceiveStream.

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 59 matching lines @@
       uint32_t* sent_nack_rate_bps,
       uint32_t* sent_fec_rate_bps) override {
     return owner_->ProtectionRequest(delta_fec_params, key_fec_params,
                                      sent_video_rate_bps, sent_nack_rate_bps,
                                      sent_fec_rate_bps);
   }
  private:
   ViEChannel* owner_;
 };
 
-ViEChannel::ViEChannel(uint32_t number_of_cores,
-                       Transport* transport,
+ViEChannel::ViEChannel(Transport* transport,
                        ProcessThread* module_process_thread,
                        PayloadRouter* send_payload_router,
                        VideoCodingModule* vcm,
                        RtcpIntraFrameObserver* intra_frame_observer,
                        RtcpBandwidthObserver* bandwidth_observer,
                        TransportFeedbackObserver* transport_feedback_observer,
                        RemoteBitrateEstimator* remote_bitrate_estimator,
                        RtcpRttStats* rtt_stats,
                        PacedSender* paced_sender,
                        PacketRouter* packet_router,
                        size_t max_rtp_streams,
                        bool sender)
-    : number_of_cores_(number_of_cores),
-      sender_(sender),
+    : sender_(sender),
       module_process_thread_(module_process_thread),
       send_payload_router_(send_payload_router),
       vcm_protection_callback_(new ViEChannelProtectionCallback(this)),
       vcm_(vcm),
       vie_receiver_(vcm_, remote_bitrate_estimator, this),
       vie_sync_(vcm_),
       stats_observer_(new ChannelStatsObserver(this)),
       receive_stats_callback_(nullptr),
       incoming_video_stream_(nullptr),
       intra_frame_observer_(intra_frame_observer),
@@ skipping 302 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;
 }
 
-int32_t ViEChannel::SetReceiveCodec(const VideoCodec& video_codec) {
-  RTC_DCHECK(!sender_);
-  if (!vie_receiver_.SetReceiveCodec(video_codec)) {
-    return -1;
-  }
-
-  if (video_codec.codecType != kVideoCodecRED &&
-      video_codec.codecType != kVideoCodecULPFEC) {
-    // Register codec type with VCM, but do not register RED or ULPFEC.
-    if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) !=
-        VCM_OK) {
-      return -1;
-    }
-  }
-  return 0;
-}
-
-void ViEChannel::RegisterExternalDecoder(const uint8_t pl_type,
-                                         VideoDecoder* decoder) {
-  RTC_DCHECK(!sender_);
-  vcm_->RegisterExternalDecoder(decoder, pl_type);
-}
-
-int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames,
-                                           uint32_t* num_delta_frames) {
-  rtc::CritScope lock(&crit_);
-  *num_key_frames = receive_frame_counts_.key_frames;
-  *num_delta_frames = receive_frame_counts_.delta_frames;
-  return 0;
-}
-
-void ViEChannel::SetExpectedRenderDelay(int delay_ms) {
-  RTC_DCHECK(!sender_);
-  vcm_->SetRenderDelay(delay_ms);
-}
-
 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) {
@@ skipping 108 matching lines @@
     return 0;
   // Enable the extension.
   int error = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     error |= rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionTransmissionTimeOffset, id);
   }
   return error;
 }
 
-int ViEChannel::SetReceiveTimestampOffsetStatus(bool enable, int id) {
-  return vie_receiver_.SetReceiveTimestampOffsetStatus(enable, id) ? 0 : -1;
-}
-
 int ViEChannel::SetSendAbsoluteSendTimeStatus(bool enable, int id) {
   // Disable any previous registrations of this extension to avoid errors.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionAbsoluteSendTime);
   if (!enable)
     return 0;
   // Enable the extension.
   int error = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     error |= rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionAbsoluteSendTime, id);
   }
   return error;
 }
 
-int ViEChannel::SetReceiveAbsoluteSendTimeStatus(bool enable, int id) {
-  return vie_receiver_.SetReceiveAbsoluteSendTimeStatus(enable, id) ? 0 : -1;
-}
-
 int ViEChannel::SetSendVideoRotationStatus(bool enable, int id) {
   // Disable any previous registrations of this extension to avoid errors.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->DeregisterSendRtpHeaderExtension(kRtpExtensionVideoRotation);
   if (!enable)
     return 0;
   // Enable the extension.
   int error = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     error |= rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionVideoRotation, id);
   }
   return error;
 }
 
-int ViEChannel::SetReceiveVideoRotationStatus(bool enable, int id) {
-  return vie_receiver_.SetReceiveVideoRotationStatus(enable, id) ? 0 : -1;
-}
-
 int ViEChannel::SetSendTransportSequenceNumber(bool enable, int id) {
+  RTC_DCHECK(sender_);
   // Disable any previous registrations of this extension to avoid errors.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->DeregisterSendRtpHeaderExtension(
         kRtpExtensionTransportSequenceNumber);
   }
   if (!enable)
     return 0;
   // Enable the extension.
   int error = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     error |= rtp_rtcp->RegisterSendRtpHeaderExtension(
         kRtpExtensionTransportSequenceNumber, id);
   }
   return error;
 }
 
-int ViEChannel::SetReceiveTransportSequenceNumber(bool enable, int id) {
-  return vie_receiver_.SetReceiveTransportSequenceNumber(enable, id) ? 0 : -1;
-}
-
-void ViEChannel::SetRtcpXrRrtrStatus(bool enable) {
-  rtp_rtcp_modules_[0]->SetRtcpXrRrtrStatus(enable);
-}
-
-void ViEChannel::EnableTMMBR(bool enable) {
-  rtp_rtcp_modules_[0]->SetTMMBRStatus(enable);
-}
-
 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::SetRemoteSSRCType(const StreamType usage,
-                                      const uint32_t SSRC) {
-  vie_receiver_.SetRtxSsrc(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;
 }
 
 uint32_t ViEChannel::GetRemoteSSRC() {
+  RTC_DCHECK(sender_);
   return vie_receiver_.GetRemoteSsrc();
 }
 
 int ViEChannel::SetRtxSendPayloadType(int payload_type,
                                       int associated_payload_type) {
   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::SetRtxReceivePayloadType(int payload_type,
-                                          int associated_payload_type) {
-  vie_receiver_.SetRtxPayloadType(payload_type, associated_payload_type);
-}
-
-void ViEChannel::SetUseRtxPayloadMappingOnRestore(bool val) {
-  vie_receiver_.SetUseRtxPayloadMappingOnRestore(val);
-}
-
 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) {
   RTC_DCHECK(!rtp_rtcp_modules_[0]->Sending());
@@ skipping 63 matching lines @@
   *rtt_ms = rtt;
   return 0;
 }
 
 void ViEChannel::RegisterSendChannelRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->RegisterRtcpStatisticsCallback(callback);
 }
 
-void ViEChannel::RegisterReceiveChannelRtcpStatisticsCallback(
-    RtcpStatisticsCallback* callback) {
-  vie_receiver_.GetReceiveStatistics()->RegisterRtcpStatisticsCallback(
-      callback);
-  rtp_rtcp_modules_[0]->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 23 matching lines @@
     }
   }
 }
 
 void ViEChannel::RegisterSendChannelRtpStatisticsCallback(
       StreamDataCountersCallback* callback) {
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->RegisterSendChannelRtpStatisticsCallback(callback);
 }
 
-void ViEChannel::RegisterReceiveChannelRtpStatisticsCallback(
-    StreamDataCountersCallback* callback) {
-  vie_receiver_.GetReceiveStatistics()->RegisterRtpStatisticsCallback(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 61 matching lines @@
     StartDecodeThread();
   vie_receiver_.StartReceive();
 }
 
 void ViEChannel::StopReceive() {
   vie_receiver_.StopReceive();
   if (!sender_)
     StopDecodeThread();
 }
 
-int32_t ViEChannel::ReceivedRTPPacket(const void* rtp_packet,
-                                      size_t rtp_packet_length,
-                                      const PacketTime& packet_time) {
-  return vie_receiver_.ReceivedRTPPacket(
-      rtp_packet, rtp_packet_length, packet_time);
-}
-
 int32_t ViEChannel::ReceivedRTCPPacket(const void* rtcp_packet,
                                        size_t rtcp_packet_length) {
-  return vie_receiver_.ReceivedRTCPPacket(rtcp_packet, rtcp_packet_length);
+  RTC_DCHECK(sender_);
+  return vie_receiver_.DeliverRtcp(
+             reinterpret_cast<const uint8_t*>(rtcp_packet), rtcp_packet_length)
+             ? 0
+             : -1;
 }
 
 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];
 }
 
+ViEReceiver* ViEChannel::vie_receiver() {
+  return &vie_receiver_;
+}
+
 VCMProtectionCallback* ViEChannel::vcm_protection_callback() {
   return vcm_protection_callback_.get();
 }
 
 CallStatsObserver* ViEChannel::GetStatsObserver() {
   return stats_observer_.get();
 }
 
 // Do not acquire the lock of |vcm_| in this function. Decode callback won't
 // necessarily be called from the decoding thread. The decoding thread may have
@@ skipping 196 matching lines @@
                                  vie_receiver_.GetRtpReceiver());
 }
 
 int32_t ViEChannel::VoiceChannel() {
   RTC_DCHECK(!sender_);
   return vie_sync_.VoiceChannel();
 }
 
 void ViEChannel::RegisterPreRenderCallback(
     I420FrameCallback* pre_render_callback) {
+  RTC_DCHECK(!sender_);
   rtc::CritScope lock(&crit_);
   pre_render_callback_ = pre_render_callback;
 }
 
-void ViEChannel::RegisterPreDecodeImageCallback(
-    EncodedImageCallback* pre_decode_callback) {
-  RTC_DCHECK(!sender_);
-  vcm_->RegisterPreDecodeImageCallback(pre_decode_callback);
-}
-
 // TODO(pbos): Remove as soon as audio can handle a changing payload type
 // without this callback.
 int32_t ViEChannel::OnInitializeDecoder(
     const int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     const int frequency,
     const size_t channels,
     const uint32_t rate) {
   RTC_NOTREACHED();
   return 0;
@@ skipping 15 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