Add VideoCodec::PreferDecodeLate

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 217 matching lines @@
   return VCM_OK;
 }
 
 int32_t VideoReceiver::RegisterDecoderTimingCallback(
     VCMDecoderTimingCallback* decoderTiming) {
   CriticalSectionScoped cs(process_crit_sect_.get());
   _decoderTimingCallback = decoderTiming;
   return VCM_OK;
 }
 
-// Register an externally defined decoder/render object.
-// Can be a decoder only or a decoder coupled with a renderer.
+// Register an externally defined decoder object.
 void VideoReceiver::RegisterExternalDecoder(VideoDecoder* externalDecoder,
-                                               uint8_t payloadType,
-                                               bool internalRenderTiming) {
+                                            uint8_t payloadType) {
   CriticalSectionScoped cs(_receiveCritSect);
   if (externalDecoder == NULL) {
     // Make sure the VCM updates the decoder next time it decodes.
     _decoder = NULL;
     RTC_CHECK(_codecDataBase.DeregisterExternalDecoder(payloadType));
     return;
   }
-  _codecDataBase.RegisterExternalDecoder(externalDecoder, payloadType,
-                                         internalRenderTiming);
+  _codecDataBase.RegisterExternalDecoder(externalDecoder, payloadType);
 }
 
 // Register a frame type request callback.
 int32_t VideoReceiver::RegisterFrameTypeCallback(
     VCMFrameTypeCallback* frameTypeCallback) {
   CriticalSectionScoped cs(process_crit_sect_.get());
   _frameTypeCallback = frameTypeCallback;
   return VCM_OK;
 }
 
@@ skipping 12 matching lines @@
 }
 
 void VideoReceiver::TriggerDecoderShutdown() {
   _receiver.TriggerDecoderShutdown();
 }
 
 // Decode next frame, blocking.
 // Should be called as often as possible to get the most out of the decoder.
 int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
   int64_t nextRenderTimeMs;
-  bool supports_render_scheduling;
+  bool prefer_late_decoding = false;
   {
     CriticalSectionScoped cs(_receiveCritSect);
-    supports_render_scheduling = _codecDataBase.SupportsRenderScheduling();
+    prefer_late_decoding = _codecDataBase.PrefersLateDecoding();
   }
 
   VCMEncodedFrame* frame = _receiver.FrameForDecoding(
-      maxWaitTimeMs, nextRenderTimeMs, supports_render_scheduling);
+      maxWaitTimeMs, nextRenderTimeMs, prefer_late_decoding);
 
   if (frame == NULL) {
     return VCM_FRAME_NOT_READY;
   } else {
     CriticalSectionScoped cs(_receiveCritSect);
 
     // If this frame was too late, we should adjust the delay accordingly
     _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
                                clock_->TimeInMilliseconds());
 
@@ skipping 60 matching lines @@
 
 // Must be called from inside the receive side critical section.
 int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
   TRACE_EVENT_ASYNC_STEP1("webrtc",
                           "Video",
                           frame.TimeStamp(),
                           "Decode",
                           "type",
                           frame.FrameType());
   // Change decoder if payload type has changed
-  const bool renderTimingBefore = _codecDataBase.SupportsRenderScheduling();
   _decoder = _codecDataBase.GetDecoder(frame, &_decodedFrameCallback);
-  if (renderTimingBefore != _codecDataBase.SupportsRenderScheduling()) {
-    // Make sure we reset the decode time estimate since it will
-    // be zero for codecs without render timing.
-    _timing.ResetDecodeTime();
-  }
   if (_decoder == NULL) {
     return VCM_NO_CODEC_REGISTERED;
   }
   // Decode a frame
   int32_t ret = _decoder->Decode(frame, clock_->TimeInMilliseconds());
 
   // Check for failed decoding, run frame type request callback if needed.
   bool request_key_frame = false;
   if (ret < 0) {
     if (ret == VCM_ERROR_REQUEST_SLI) {
@@ skipping 178 matching lines @@
 }
 
 void VideoReceiver::RegisterPreDecodeImageCallback(
     EncodedImageCallback* observer) {
   CriticalSectionScoped cs(_receiveCritSect);
   pre_decode_image_callback_ = observer;
 }
 
 }  // namespace vcm
 }  // namespace webrtc