Deprecate VideoDecoder::Reset() and remove calls.

webrtc/modules/video_coding/video_receiver.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 25 matching lines @@
       _receiveStatsCallback(NULL),
       _decoderTimingCallback(NULL),
       _packetRequestCallback(NULL),
       render_buffer_callback_(NULL),
       _decoder(NULL),
 #ifdef DEBUG_DECODER_BIT_STREAM
       _bitStreamBeforeDecoder(NULL),
 #endif
       _frameFromFile(),
       _scheduleKeyRequest(false),
+      drop_frames_until_keyframe_(false),
       max_nack_list_size_(0),
+      _codecDataBase(nullptr, nullptr),
       pre_decode_image_callback_(NULL),
-      _codecDataBase(nullptr, nullptr),
       _receiveStatsTimer(1000, clock_),
       _retransmissionTimer(10, clock_),
       _keyRequestTimer(500, clock_) {
   assert(clock_);
 #ifdef DEBUG_DECODER_BIT_STREAM
   _bitStreamBeforeDecoder = fopen("decoderBitStream.bit", "wb");
 #endif
 }
 
 VideoReceiver::~VideoReceiver() {
@@ skipping 216 matching lines @@
     CriticalSectionScoped cs(_receiveCritSect);
     prefer_late_decoding = _codecDataBase.PrefersLateDecoding();
   }
 
   VCMEncodedFrame* frame = _receiver.FrameForDecoding(
       maxWaitTimeMs, &nextRenderTimeMs, prefer_late_decoding);
 
   if (!frame)
     return VCM_FRAME_NOT_READY;
 
+  {
+    CriticalSectionScoped cs(process_crit_sect_.get());
+    if (drop_frames_until_keyframe_) {
+      // Still getting delta frames, schedule another keyframe request as if
+      // decode failed.
+      if (frame->FrameType() != kVideoFrameKey) {
+        _scheduleKeyRequest = true;
+        _receiver.ReleaseFrame(frame);
+        return VCM_FRAME_NOT_READY;
+      }
+      drop_frames_until_keyframe_ = false;
+    }
+  }

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

Should we instead make sure the jitter buffer does the right thing (by not
returning delta frames after a flush) and DCHECK here?

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

Not obvious to me how to make the jitter buffer continuously request keyframes
due to additional incoming delta frames, the keyframe request may be dropped, so
we need to keep sending them.

   CriticalSectionScoped cs(_receiveCritSect);
 
   // If this frame was too late, we should adjust the delay accordingly
   _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
                              clock_->TimeInMilliseconds());
 
   if (pre_decode_image_callback_) {
     EncodedImage encoded_image(frame->EncodedImage());
     int qp = -1;
     if (qp_parser_.GetQp(*frame, &qp)) {
@@ skipping 78 matching lines @@
     ret = VCM_OK;
   }
   if (request_key_frame) {
     CriticalSectionScoped cs(process_crit_sect_.get());
     _scheduleKeyRequest = true;
   }
   TRACE_EVENT_ASYNC_END0("webrtc", "Video", frame.TimeStamp());
   return ret;
 }
 
-// Reset the decoder state
-int32_t VideoReceiver::ResetDecoder() {
-  bool reset_key_request = false;
-  {
-    CriticalSectionScoped cs(_receiveCritSect);
-    if (_decoder != NULL) {
-      _receiver.Reset();
-      _timing.Reset();
-      reset_key_request = true;
-      _decoder->Reset();
-    }
-  }
-  if (reset_key_request) {
-    CriticalSectionScoped cs(process_crit_sect_.get());
-    _scheduleKeyRequest = false;
-  }
-  return VCM_OK;
-}
-
 // Register possible receive codecs, can be called multiple times
 int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
                                             int32_t numberOfCores,
                                             bool requireKeyFrame) {
   CriticalSectionScoped cs(_receiveCritSect);
   if (receiveCodec == NULL) {
     return VCM_PARAMETER_ERROR;
   }
   if (!_codecDataBase.RegisterReceiveCodec(receiveCodec, numberOfCores,
                                            requireKeyFrame)) {
@@ skipping 30 matching lines @@
     // without payload.
     // TODO(holmer): We should fix this in the jitter buffer.
     payloadLength = 0;
   }
   const VCMPacket packet(incomingPayload, payloadLength, rtpInfo);
   int32_t ret = _receiver.InsertPacket(packet, rtpInfo.type.Video.width,
                                        rtpInfo.type.Video.height);
   // TODO(holmer): Investigate if this somehow should use the key frame
   // request scheduling to throttle the requests.
   if (ret == VCM_FLUSH_INDICATOR) {
+    {
+      CriticalSectionScoped process_cs(process_crit_sect_.get());
+      drop_frames_until_keyframe_ = true;
+    }
     RequestKeyFrame();
-    ResetDecoder();
   } else if (ret < 0) {
     return ret;
   }
   return VCM_OK;
 }
 
 // Minimum playout delay (used for lip-sync). This is the minimum delay required
 // to sync with audio. Not included in  VideoCodingModule::Delay()
 // Defaults to 0 ms.
 int32_t VideoReceiver::SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) {
@@ skipping 76 matching lines @@
 }
 
 void VideoReceiver::RegisterPreDecodeImageCallback(
     EncodedImageCallback* observer) {
   CriticalSectionScoped cs(_receiveCritSect);
   pre_decode_image_callback_ = observer;
 }
 
 }  // namespace vcm
 }  // namespace webrtc