Add VideoCodec::PreferDecodeLate

webrtc/modules/video_coding/receiver.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 76 matching lines @@
     timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
   }
   return VCM_OK;
 }
 
 void VCMReceiver::TriggerDecoderShutdown() {
   jitter_buffer_.Stop();
   render_wait_event_->Set();
 }
 
-VCMEncodedFrame* VCMReceiver::FrameForDecoding(uint16_t max_wait_time_ms,
-                                               int64_t& next_render_time_ms,
-                                               bool render_timing) {
+VCMEncodedFrame* VCMReceiver::FrameForDecoding(
+    uint16_t max_wait_time_ms,
+    int64_t& next_render_time_ms,
+    bool prefer_decode_late) {
   const int64_t start_time_ms = clock_->TimeInMilliseconds();
   uint32_t frame_timestamp = 0;
   // Exhaust wait time to get a complete frame for decoding.
   bool found_frame = jitter_buffer_.NextCompleteTimestamp(
       max_wait_time_ms, &frame_timestamp);
 
   if (!found_frame)
     found_frame = jitter_buffer_.NextMaybeIncompleteTimestamp(&frame_timestamp);
 
   if (!found_frame)
@@ skipping 23 matching lines @@
     timing_error = true;
   }
 
   if (timing_error) {
     // Timing error => reset timing and flush the jitter buffer.
     jitter_buffer_.Flush();
     timing_->Reset();
     return NULL;
   }
 
-  if (!render_timing) {
+  if (prefer_decode_late) {
     // Decode frame as close as possible to the render timestamp.
     const int32_t available_wait_time = max_wait_time_ms -
         static_cast<int32_t>(clock_->TimeInMilliseconds() - start_time_ms);
     uint16_t new_max_wait_time = static_cast<uint16_t>(
         VCM_MAX(available_wait_time, 0));
     uint32_t wait_time_ms = timing_->MaxWaitingTime(
         next_render_time_ms, clock_->TimeInMilliseconds());
     if (new_max_wait_time < wait_time_ms) {
       // We're not allowed to wait until the frame is supposed to be rendered,
       // waiting as long as we're allowed to avoid busy looping, and then return
@@ skipping 105 matching lines @@
   uint32_t render_end = timing_->RenderTimeMs(timestamp_end, now_ms);
   return render_end - render_start;
 }
 
 void VCMReceiver::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
   jitter_buffer_.RegisterStatsCallback(callback);
 }
 
 }  // namespace webrtc