Fix video sync error when framerate or playback rate is low...

media/filters/video_renderer_base.cc

 // Copyright (c) 2009 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/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/video_frame_impl.h"
 #include "media/filters/video_renderer_base.h"
 
 namespace media {
 
 // Limit our read ahead to three frames.  One frame is typically in flux at all
 // times, as in frame n is discarded at the top of ThreadMain() while frame
 // (n + kMaxFrames) is being asynchronously fetched.  The remaining two frames
 // allow us to advance the current frame as well as read the timestamp of the
 // following frame for more accurate timing.
 //
 // Increasing this number beyond 3 simply creates a larger buffer to work with
 // at the expense of memory (~0.5MB and ~1.3MB per frame for 480p and 720p
 // resolutions, respectively).  This can help on lower-end systems if there are
 // difficult sections in the movie and decoding slows down.
 static const size_t kMaxFrames = 3;
 
 // This equates to ~16.67 fps, which is just slow enough to be tolerable when
 // our video renderer is ahead of the audio playback.
 //
 // A higher value will be a slower frame rate, which looks worse but allows the
 // audio renderer to catch up faster.  A lower value will be a smoother frame
 // rate, but results in the video being out of sync for longer.
-//
-// TODO(scherkus): what if the native frame rate is 15 or 10 fps?
 static const int64 kMaxSleepMilliseconds = 60;
 
+// The number of milliseconds to idle when we do not have anything to do.
+// Nothing special about the value, other than we're being more OS-friendly
+// than sleeping for 1 millisecond.
+static const int kIdleMilliseconds = 10;
+
 VideoRendererBase::VideoRendererBase()
     : width_(0),
       height_(0),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(NULL),
       pending_reads_(0),
       playback_rate_(0) {
 }
 
@@ skipping 142 matching lines @@
     float playback_rate;
     {
       AutoLock auto_lock(lock_);
       state = state_;
       playback_rate = playback_rate_;
     }
     if (state == kStopped) {
       return;
     }
 
-    // Sleep for 10 milliseconds while paused.  Nothing special about the value,
-    // other than we're being more OS-friendly than sleeping for 1 millisecond.
+    // Sleep while paused or seeking.
     if (state == kPaused || state == kSeeking || playback_rate == 0) {
-      PlatformThread::Sleep(10);
+      PlatformThread::Sleep(kIdleMilliseconds);
       continue;
     }
 
     // Advance |current_frame_| and try to determine |next_frame|.  Note that
     // this loop executes our "playing" logic.
     DCHECK_EQ(kPlaying, state);
     scoped_refptr<VideoFrame> next_frame;
     {
       AutoLock auto_lock(lock_);
       // Check the actual state to see if we're trying to stop playing.
       if (state_ != kPlaying) {
         continue;
       }
 
+      // Idle if the next frame is too far ahead.
+      base::TimeDelta diff = current_frame_->GetTimestamp() - host()->GetTime();
+      if (diff.InMilliseconds() > kIdleMilliseconds) {
+        PlatformThread::Sleep(kIdleMilliseconds);
+        continue;
+      }
+
       // Otherwise we're playing, so advance the frame and keep reading from the
       // decoder.  |frames_| might be empty if we seeked to the very end of the
       // media where no frames were available.
       if (!frames_.empty()) {
         DCHECK_EQ(current_frame_, frames_.front());
         frames_.pop_front();
         ScheduleRead_Locked();
       }
 
       // While playing, we'll wait until a new frame arrives before updating
@@ skipping 161 matching lines @@
     surface.data[VideoSurface::kVPlane]
         += surface.strides[VideoSurface::kVPlane];
   }
   frame->Unlock();
 
   // Success!
   *frame_out = frame;
 }
 
 }  // namespace media