Remove media::VideoRenderer::SetPlaybackRate().

media/filters/video_renderer_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 16 matching lines @@
     : task_runner_(task_runner),
       video_frame_stream_(task_runner, decoders.Pass(), set_decryptor_ready_cb),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
-      playback_rate_(0),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       paint_cb_(paint_cb),
       last_timestamp_(kNoTimestamp()),
       frames_decoded_(0),
       frames_dropped_(0),
       weak_factory_(this) {
   DCHECK(!paint_cb_.is_null());
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
@@ skipping 51 matching lines @@
   }
 
   if (!thread_to_join.is_null()) {
     base::AutoUnlock auto_unlock(lock_);
     base::PlatformThread::Join(thread_to_join);
   }
 
   video_frame_stream_.Stop(callback);
 }
 
-void VideoRendererImpl::SetPlaybackRate(float playback_rate) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  base::AutoLock auto_lock(lock_);
-  playback_rate_ = playback_rate;
-}
-
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK(ready_frames_.empty());
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kPlaying;
   start_timestamp_ = timestamp;
@@ skipping 89 matching lines @@
       base::TimeDelta::FromMilliseconds(10);
 
   for (;;) {
     base::AutoLock auto_lock(lock_);
 
     // Thread exit condition.
     if (state_ == kStopped)
       return;
 
     // Remain idle as long as we're not playing.
-    if (state_ != kPlaying || playback_rate_ == 0 ||
-        buffering_state_ != BUFFERING_HAVE_ENOUGH) {
+    if (state_ != kPlaying || buffering_state_ != BUFFERING_HAVE_ENOUGH) {
       UpdateStatsAndWait_Locked(kIdleTimeDelta);
       continue;
     }
 
     // Remain idle until we have the next frame ready for rendering.
     if (ready_frames_.empty()) {
       if (received_end_of_stream_ && !rendered_end_of_stream_) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       }
 
       UpdateStatsAndWait_Locked(kIdleTimeDelta);
       continue;
     }
 
-    base::TimeDelta remaining_time =
-        CalculateSleepDuration(ready_frames_.front(), playback_rate_);
+    // Determine the current and next presentation timestamps.
+    base::TimeDelta now = get_time_cb_.Run();
+    base::TimeDelta remaining_time = ready_frames_.front()->timestamp() - now;
 
     // Sleep up to a maximum of our idle time until we're within the time to
     // render the next frame.
     if (remaining_time.InMicroseconds() > 0) {
       remaining_time = std::min(remaining_time, kIdleTimeDelta);

[xhwang, 2014/07/10 23:54:05]

Does it make a big difference if you always use kIdleTimeDelta? The calculation
of l.235 isn't correct now in theory. What's the value of keeping remaining_time
here? I can imagine it's useful in some cases, but this kinda makes things
messy...

[scherkus (not reviewing), 2014/07/11 00:01:03]

I thought about it and we can certainly play around with this code! For example:
  1) Always use kIdleTimeDelta, like you suggested
  2) Tweak value of kIdleTimeDelta (maybe to 5ms?!)

Perhaps it's worth doing to simplify this code a bit more.

       UpdateStatsAndWait_Locked(remaining_time);
       continue;
     }
 
     // Deadline is defined as the midpoint between this frame and the next
     // frame, using the delta between this frame and the previous frame as the
     // assumption for frame duration.
     //
     // TODO(scherkus): An improvement over midpoint might be selecting the
     // minimum and/or maximum between the midpoint and some constants. As a
     // thought experiment, consider what would be better than the midpoint
     // for both the 1fps case and 120fps case.
     //
     // TODO(scherkus): This can be vastly improved. Use a histogram to measure
     // the accuracy of our frame timing code. http://crbug.com/149829
     if (drop_frames_ && last_timestamp_ != kNoTimestamp()) {
-      base::TimeDelta now = get_time_cb_.Run();
       base::TimeDelta deadline = ready_frames_.front()->timestamp() +
           (ready_frames_.front()->timestamp() - last_timestamp_) / 2;
 
       if (now > deadline) {
         DropNextReadyFrame_Locked();
         continue;
       }
     }
 
     // Congratulations! You've made it past the video frame timing gauntlet.
@@ skipping 195 matching lines @@
   DCHECK(ready_frames_.empty());
   DCHECK(!received_end_of_stream_);
   DCHECK(!rendered_end_of_stream_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kFlushed;
   last_timestamp_ = kNoTimestamp();
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
-base::TimeDelta VideoRendererImpl::CalculateSleepDuration(
-    const scoped_refptr<VideoFrame>& next_frame,
-    float playback_rate) {
-  // Determine the current and next presentation timestamps.
-  base::TimeDelta now = get_time_cb_.Run();
-  base::TimeDelta next_pts = next_frame->timestamp();
-
-  // Scale our sleep based on the playback rate.
-  base::TimeDelta sleep = next_pts - now;
-  return base::TimeDelta::FromMicroseconds(
-      static_cast<int64>(sleep.InMicroseconds() / playback_rate));
-}
-
 void VideoRendererImpl::DoStopOrError_Locked() {
   lock_.AssertAcquired();
   last_timestamp_ = kNoTimestamp();
   ready_frames_.clear();
 }
 
 void VideoRendererImpl::UpdateStatsAndWait_Locked(
     base::TimeDelta wait_duration) {
   lock_.AssertAcquired();
   DCHECK_GE(frames_decoded_, 0);
   DCHECK_LE(frames_dropped_, frames_decoded_);
 
   if (frames_decoded_) {
     PipelineStatistics statistics;
     statistics.video_frames_decoded = frames_decoded_;
     statistics.video_frames_dropped = frames_dropped_;
     statistics_cb_.Run(statistics);
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media