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 79 matching lines @@
                        PacedSender* paced_sender,
                        PacketRouter* packet_router,
                        size_t max_rtp_streams,
                        bool sender)
     : number_of_cores_(number_of_cores),
       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),

[stefan-webrtc, 2016/02/05 14:35:57]

I wonder if it would make sense to instantiate the receiver in video receive
stream instead, and have it be the owner? VideoReceiveStream outlives ViEChannel
which is nice, so we don't have problems where vie_receiver_ will become null.

[pbos-webrtc, 2016/02/05 15:15:51]

I think that makes sense in a follow-up, right now the vie_receiver_ pointer
doesn't outlive vie_channel_ (declared after), so any use of vie_receiver_ where
vie_channel_ is dead is an use-after-free regardless. In the future I want to
move this out, but as a part of removing ViEChannel.

       vie_sync_(vcm_),
       stats_observer_(new ChannelStatsObserver(this)),
       receive_stats_callback_(nullptr),
       incoming_video_stream_(nullptr),
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       transport_feedback_observer_(transport_feedback_observer),
@@ skipping 299 matching lines @@
   // 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)) {

[stefan-webrtc, 2016/02/05 14:35:56]

Should be able to move this out too

[pbos-webrtc, 2016/02/05 15:15:51]

Done.

     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) {
+  RTC_DCHECK(!sender_);
   vie_receiver_.SetRtxPayloadType(payload_type, associated_payload_type);

[stefan-webrtc, 2016/02/05 14:35:57]

Move this out instead?

[pbos-webrtc, 2016/02/05 15:15:51]

Done.

 }
 
 void ViEChannel::SetUseRtxPayloadMappingOnRestore(bool val) {
   vie_receiver_.SetUseRtxPayloadMappingOnRestore(val);

[stefan-webrtc, 2016/02/05 14:35:56]

Same here

[pbos-webrtc, 2016/02/05 15:15:51]

Done.

 }
 
 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;
   }
 }
 
@@ skipping 117 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);

[stefan-webrtc, 2016/02/05 14:35:57]

Maybe move out too?

[pbos-webrtc, 2016/02/05 15:15:51]

Done.

 }
 
 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()]);
@@ skipping 58 matching lines @@
   return rtp_rtcp_modules_[0]->Sending();
 }
 
 void ViEChannel::StartReceive() {
   if (!sender_)
     StartDecodeThread();
   vie_receiver_.StartReceive();
 }
 
 void ViEChannel::StopReceive() {
   vie_receiver_.StopReceive();

[stefan-webrtc, 2016/02/05 14:35:56]

Should we call these from outside?

[pbos-webrtc, 2016/02/05 15:15:51]

Not until we've moved out the decoder thread (follow-up).

   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