Deprecate VideoDecoder::Reset() and remove calls.

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 896 matching lines @@
 }
 
 void ViEChannel::StartReceive() {
   if (!sender_)
     StartDecodeThread();
   vie_receiver_.StartReceive();
 }
 
 void ViEChannel::StopReceive() {
   vie_receiver_.StopReceive();
-  if (!sender_) {
+  if (!sender_)
     StopDecodeThread();
-    vcm_->ResetDecoder();

[stefan-webrtc, 2016/02/01 16:23:08]

Is this safe to remove? I assume it is, but it would be good if you explained
why you think it is. 

[pbos-webrtc, 2016/02/02 13:25:12]

Yeah, I don't think there's any point in killing the decoder here, if we don't
then it doesn't have to reinitialize if it starts receiving again.

-  }
 }
 
 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,
@@ skipping 228 matching lines @@
     I420FrameCallback* pre_render_callback) {
   rtc::CritScope lock(&crit_);
   pre_render_callback_ = pre_render_callback;
 }
 
 void ViEChannel::RegisterPreDecodeImageCallback(
     EncodedImageCallback* pre_decode_callback) {
   vcm_->RegisterPreDecodeImageCallback(pre_decode_callback);
 }
 
-// TODO(pbos): Remove OnInitializeDecoder which is called from the RTP module,
-// any decoder resetting should be handled internally within the VCM.
+// TODO(pbos): Consider updating callback to contain video resolution so we can
+// initialize the decoder earlier here.
 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) {
   LOG(LS_INFO) << "OnInitializeDecoder " << static_cast<int>(payload_type)
                << " " << payload_name;
-  vcm_->ResetDecoder();
-
   return 0;

[stefan-webrtc, 2016/02/01 16:23:08]

This change doesn't seem trivial to me. Should we instead do an InitEncode()?
Are we guaranteed to do that InitEncode/Reset once a frame gets to the decoder?
For instance, I'm not sure we have checks on payload type change in the VCM, so
if we switch payload type maybe we don't reset the decoder now?

[pbos-webrtc, 2016/02/02 13:25:12]

Decode in VideoReceiver calls VCMCodecDataBase::GetDecoder which reinitializes
if payload_type has changed, the only difference here is that it will do a
decoder release on the network(?) thread.

 }
 
 void ViEChannel::OnIncomingSSRCChanged(const uint32_t ssrc) {
   rtp_rtcp_modules_[0]->SetRemoteSSRC(ssrc);
 }
 
 void ViEChannel::OnIncomingCSRCChanged(const uint32_t CSRC, const bool added) {}
 
 void ViEChannel::RegisterSendFrameCountObserver(
     FrameCountObserver* observer) {
   send_frame_count_observer_.Set(observer);
 }
 
 void ViEChannel::RegisterReceiveStatisticsProxy(
     ReceiveStatisticsProxy* receive_statistics_proxy) {
   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