Replace unused output parameter in VCMReceiver::FrameForDecoding().

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 120 matching lines @@
   }
   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 prefer_late_decoding) {
   const int64_t start_time_ms = clock_->TimeInMilliseconds();
   uint32_t frame_timestamp = 0;
   int min_playout_delay_ms = -1;
   int max_playout_delay_ms = -1;
+  int64_t render_time_ms = 0;
   // Exhaust wait time to get a complete frame for decoding.
   VCMEncodedFrame* found_frame =
       jitter_buffer_.NextCompleteFrame(max_wait_time_ms);
 
   if (found_frame) {
     frame_timestamp = found_frame->TimeStamp();
     min_playout_delay_ms = found_frame->EncodedImage().playout_delay_.min_ms;
     max_playout_delay_ms = found_frame->EncodedImage().playout_delay_.max_ms;
   } else {
     if (!jitter_buffer_.NextMaybeIncompleteTimestamp(&frame_timestamp))
       return nullptr;
   }
 
   if (min_playout_delay_ms >= 0)
     timing_->set_min_playout_delay(min_playout_delay_ms);
 
   if (max_playout_delay_ms >= 0)
     timing_->set_max_playout_delay(max_playout_delay_ms);
 
   // We have a frame - Set timing and render timestamp.
   timing_->SetJitterDelay(jitter_buffer_.EstimatedJitterMs());
   const int64_t now_ms = clock_->TimeInMilliseconds();
   timing_->UpdateCurrentDelay(frame_timestamp);
-  *next_render_time_ms = timing_->RenderTimeMs(frame_timestamp, now_ms);
+  render_time_ms = timing_->RenderTimeMs(frame_timestamp, now_ms);
   // Check render timing.
   bool timing_error = false;
   // Assume that render timing errors are due to changes in the video stream.
-  if (*next_render_time_ms < 0) {
+  if (render_time_ms < 0) {
     timing_error = true;
-  } else if (std::abs(*next_render_time_ms - now_ms) > max_video_delay_ms_) {
-    int frame_delay = static_cast<int>(std::abs(*next_render_time_ms - now_ms));
+  } else if (std::abs(render_time_ms - now_ms) > max_video_delay_ms_) {
+    int frame_delay = static_cast<int>(std::abs(render_time_ms - now_ms));
     LOG(LS_WARNING) << "A frame about to be decoded is out of the configured "
                     << "delay bounds (" << frame_delay << " > "
                     << max_video_delay_ms_
                     << "). Resetting the video jitter buffer.";
     timing_error = true;
   } else if (static_cast<int>(timing_->TargetVideoDelay()) >
              max_video_delay_ms_) {
     LOG(LS_WARNING) << "The video target delay has grown larger than "
                     << max_video_delay_ms_ << " ms. Resetting jitter buffer.";
     timing_error = true;
   }
 
   if (timing_error) {
     // Timing error => reset timing and flush the jitter buffer.
     jitter_buffer_.Flush();
     timing_->Reset();
     return NULL;
   }
 
   if (prefer_late_decoding) {
     // 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());
+    uint32_t wait_time_ms =
+        timing_->MaxWaitingTime(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
       // NULL. Next call to this function might return the frame.
       render_wait_event_->Wait(new_max_wait_time);
       return NULL;
     }
     // Wait until it's time to render.
     render_wait_event_->Wait(wait_time_ms);
   }
 
   // Extract the frame from the jitter buffer and set the render time.
   VCMEncodedFrame* frame = jitter_buffer_.ExtractAndSetDecode(frame_timestamp);
   if (frame == NULL) {
     return NULL;
   }
-  frame->SetRenderTime(*next_render_time_ms);
+  frame->SetRenderTime(render_time_ms);
   TRACE_EVENT_ASYNC_STEP1("webrtc", "Video", frame->TimeStamp(), "SetRenderTS",
-                          "render_time", *next_render_time_ms);
+                          "render_time", frame->RenderTimeMs());
   if (!frame->Complete()) {
     // Update stats for incomplete frames.
     bool retransmitted = false;
     const int64_t last_packet_time_ms =
         jitter_buffer_.LastPacketTime(frame, &retransmitted);
     if (last_packet_time_ms >= 0 && !retransmitted) {
       // We don't want to include timestamps which have suffered from
       // retransmission here, since we compensate with extra retransmission
       // delay within the jitter estimate.
       timing_->IncomingTimestamp(frame_timestamp, last_packet_time_ms);
@@ skipping 59 matching lines @@
   timing_->set_min_playout_delay(desired_delay_ms);
   return 0;
 }
 
 void VCMReceiver::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
   jitter_buffer_.RegisterStatsCallback(callback);
 }
 
 }  // namespace webrtc