Implemented a proper clock for audio/video synchronization.

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;
 
-// Sleeping for negative amounts actually hangs your thread on Windows!
-static const int64 kMinSleepMilliseconds = 0;
-
-// This equates to ~13.33 fps, which is just under the typical 15 fps that
-// lower quality cameras or shooting modes usually use for video encoding.
-static const int64 kMaxSleepMilliseconds = 75;
+// 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;
 
 VideoRendererBase::VideoRendererBase()
     : width_(0),
       height_(0),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(NULL),
       pending_reads_(0),
       playback_rate_(0) {
 }
@@ skipping 189 matching lines @@
         continue;
       }
 
       // Update our current frame and attempt to grab the next frame.
       current_frame_ = frames_.front();
       if (frames_.size() >= 2) {
         next_frame = frames_[1];
       }
     }
 
+    // Calculate our sleep duration.
+    base::TimeDelta sleep = CalculateSleepDuration(next_frame, playback_rate);
+    int sleep_ms = static_cast<int>(sleep.InMilliseconds());
+
+    // If we're too far behind to catch up, simply drop the frame.
+    //
+    // This has the effect of potentially dropping a few frames when playback
+    // resumes after being paused.  The alternative (sleeping for 0 milliseconds
+    // and trying to catch up) looks worse.
+    if (sleep_ms < 0)
+      continue;
+
+    // To be safe, limit our sleep duration.
+    // TODO(scherkus): handle seeking gracefully.. right now we tend to hit
+    // kMaxSleepMilliseconds a lot when we seek backwards.
+    if (sleep_ms > kMaxSleepMilliseconds)
+      sleep_ms = kMaxSleepMilliseconds;
+
     // Notify subclass that |current_frame_| has been updated.
     OnFrameAvailable();
 
-    // Calculate our sleep duration.
-    base::TimeDelta sleep = CalculateSleepDuration(next_frame, playback_rate);
-
-    // To be safe, limit our sleep duration.
-    // TODO(scherkus): handle seeking gracefully.. right now a seek backwards
-    // will hit kMinSleepMilliseconds whereas a seek forward will hit
-    // kMaxSleepMilliseconds.
-    int sleep_ms = static_cast<int>(sleep.InMilliseconds());
-    if (sleep_ms < kMinSleepMilliseconds)
-      sleep_ms = kMinSleepMilliseconds;
-    else if (sleep_ms > kMaxSleepMilliseconds)
-      sleep_ms = kMaxSleepMilliseconds;
-
     PlatformThread::Sleep(sleep_ms);
   }
 }
 
 void VideoRendererBase::GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out) {
   AutoLock auto_lock(lock_);
   // We should have initialized and have the current frame.
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying);
   DCHECK(current_frame_);
   *frame_out = current_frame_;
@@ skipping 112 matching lines @@
     surface.data[VideoSurface::kVPlane]
         += surface.strides[VideoSurface::kVPlane];
   }
   frame->Unlock();
 
   // Success!
   *frame_out = frame;
 }
 
 }  // namespace media