Implement accurate seeking by decoding audio/video until we reach our desired timestamp.

media/filters/video_renderer_base.cc

 // Copyright (c) 2010 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 "base/callback.h"
 #include "media/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/base/video_frame.h"
 #include "media/filters/video_renderer_base.h"
 
@@ skipping 133 matching lines @@
   AutoLock auto_lock(lock_);
   playback_rate_ = playback_rate;
 }
 
 void VideoRendererBase::Seek(base::TimeDelta time, FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   DCHECK_EQ(kPaused, state_);
   DCHECK_EQ(0u, pending_reads_) << "Pending reads should have completed";
   state_ = kSeeking;
   seek_callback_.reset(callback);
+  seek_timestamp_ = time;
 
   // Throw away everything and schedule our reads.
   // TODO(jiesun): this should be guaranteed by pause/flush before seek happen.
   frames_queue_ready_.clear();
   frames_queue_done_.clear();
   for (size_t i = 0; i < kMaxFrames; ++i) {
     // TODO(jiesun): this is dummy read for ffmpeg path until we truely recycle
     // in that path.
     scoped_refptr<VideoFrame> null_frame;
     frames_queue_done_.push_back(null_frame);
@@ skipping 219 matching lines @@
   if (state_ == kStopped) {
     // TODO(jiesun): Remove this when flush before stop landed!
     return;
   }
 
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
          state_ == kEnded);
   DCHECK_GT(pending_reads_, 0u);
   --pending_reads_;
 
-  // Enqueue the frame.
-  frames_queue_ready_.push_back(frame);
-  DCHECK_LE(frames_queue_ready_.size(), kMaxFrames);
-  frame_available_.Signal();
+  // Discard frames until we reach our desired seek timestamp.
+  if (state_ == kSeeking && !frame->IsEndOfStream() &&
+      (frame->GetTimestamp() + frame->GetDuration()) < seek_timestamp_) {
+    frames_queue_done_.push_back(frame);
+    ScheduleRead_Locked();
+  } else {
+    frames_queue_ready_.push_back(frame);
+    DCHECK_LE(frames_queue_ready_.size(), kMaxFrames);
+    frame_available_.Signal();
+  }
 
   // Check for our preroll complete condition.
   if (state_ == kSeeking) {
     DCHECK(seek_callback_.get());
     if (frames_queue_ready_.size() == kMaxFrames) {
       // We're paused, so make sure we update |current_frame_| to represent
       // our new location.
       state_ = kPaused;
 
       // Because we might remain paused (i.e., we were not playing before we
@@ skipping 70 matching lines @@
     previous_time_ = now;
   }
 
   // Scale our sleep based on the playback rate.
   // TODO(scherkus): floating point badness and degrade gracefully.
   return base::TimeDelta::FromMicroseconds(
       static_cast<int64>(sleep.InMicroseconds() / playback_rate));
 }
 
 }  // namespace media