preparation for recycling buffer, patch 2

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/callback.h"
 #include "media/base/filter_host.h"
 #include "media/base/video_frame.h"
 #include "media/filters/video_renderer_base.h"
 
 namespace media {
 
 // Limit our read ahead to at least 3 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
@@ skipping 66 matching lines @@
     return false;
   if (!media_format.GetAsInteger(MediaFormat::kHeight, &height))
     return false;
   if (width_out) *width_out = width;
   if (height_out) *height_out = height;
   return true;
 }
 
 void VideoRendererBase::Play(FilterCallback* callback) {
   AutoLock auto_lock(lock_);
-  DCHECK_EQ(kPaused, state_);
+  DCHECK(kPaused == state_ || kFlushing == state_);
   scoped_ptr<FilterCallback> c(callback);
   state_ = kPlaying;
   callback->Run();
 }
 
 void VideoRendererBase::Pause(FilterCallback* callback) {
   AutoLock auto_lock(lock_);
   DCHECK(state_ == kPlaying || state_ == kEnded);
-  pause_callback_.reset(callback);
+  AutoCallbackRunner done_runner(callback);
   state_ = kPaused;
+}
 
-  // TODO(jiesun): currently we use Pause() to fulfill Flush().
+void VideoRendererBase::Flush(FilterCallback* callback) {
+  DCHECK(state_ == kPaused);
+
+  AutoLock auto_lock(lock_);
+  flush_callback_.reset(callback);
+  state_ = kFlushing;
+
   // Filter is considered paused when we've finished all pending reads, which
   // implies all buffers are returned to owner in Decoder/Renderer. Renderer
   // is considered paused with one more contingency that |pending_paint_| is
   // false, such that no client of us is holding any reference to VideoFrame.
   if (pending_reads_ == 0 && pending_paint_ == false) {
-    pause_callback_->Run();
-    pause_callback_.reset();
+    flush_callback_->Run();
+    flush_callback_.reset();
     FlushBuffers();
   }
 }
 
 void VideoRendererBase::Stop(FilterCallback* callback) {
   {
     AutoLock auto_lock(lock_);
     state_ = kStopped;
 
     // TODO(jiesun): move this to flush.
@@ skipping 17 matching lines @@
   OnStop(callback);
 }
 
 void VideoRendererBase::SetPlaybackRate(float playback_rate) {
   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(kPaused == state_ || kFlushing == 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) {
@@ skipping 74 matching lines @@
 
   for (;;) {
     AutoLock auto_lock(lock_);
 
     const base::TimeDelta kIdleTimeDelta =
         base::TimeDelta::FromMilliseconds(kIdleMilliseconds);
 
     if (state_ == kStopped)
       return;
 
-    if (state_ == kPaused || state_ == kSeeking || state_ == kEnded ||
-        playback_rate_ == 0) {
+    if (state_ != kPlaying || playback_rate_ == 0) {
       remaining_time = kIdleTimeDelta;
     } else if (frames_queue_ready_.empty() ||
                frames_queue_ready_.front()->IsEndOfStream()) {
       if (current_frame_.get())
         remaining_time = CalculateSleepDuration(NULL, playback_rate_);
       else
         remaining_time = kIdleTimeDelta;
     } else {
       // Calculate how long until we should advance the frame, which is
       // typically negative but for playback rates < 1.0f may be long enough
@@ skipping 86 matching lines @@
   DCHECK(!pending_paint_);
 
   if (state_ == kStopped || !current_frame_.get() ||
       current_frame_->IsEndOfStream()) {
     *frame_out = NULL;
     return;
   }
 
   // We should have initialized and have the current frame.
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
-         state_ == kEnded);
+         state_ == kFlushing || state_ == kEnded);
   *frame_out = current_frame_;
   pending_paint_ = true;
 }
 
 void VideoRendererBase::PutCurrentFrame(scoped_refptr<VideoFrame> frame) {
   AutoLock auto_lock(lock_);
 
   // Note that we do not claim |pending_paint_| when we return NULL frame, in
   // that case, |current_frame_| could be changed before PutCurrentFrame.
   DCHECK(pending_paint_ || frame.get() == NULL);
   DCHECK(current_frame_.get() == frame.get() || frame.get() == NULL);
 
   pending_paint_ = false;
   // We had cleared the |pending_paint_| flag, there are chances that current
   // frame is timed-out. We will wake up our main thread to advance the current
   // frame when this is true.
   frame_available_.Signal();
-  if (state_ == kPaused && pending_reads_ == 0 && pause_callback_.get()) {
+  if (state_ == kFlushing && pending_reads_ == 0 && flush_callback_.get()) {
     // No more pending reads!  We're now officially "paused".
     FlushBuffers();
-    pause_callback_->Run();
-    pause_callback_.reset();
+    flush_callback_->Run();
+    flush_callback_.reset();
   }
 }
 
 void VideoRendererBase::OnFillBufferDone(scoped_refptr<VideoFrame> frame) {
   AutoLock auto_lock(lock_);
 
   // TODO(ajwong): Work around cause we don't synchronize on stop. Correct
   // fix is to resolve http://crbug.com/16059.
   if (state_ == kStopped) {
     // TODO(jiesun): Remove this when flush before stop landed!
     return;
   }
 
   DCHECK(state_ == kPaused || state_ == kSeeking || state_ == kPlaying ||
-         state_ == kEnded);
+         state_ == kFlushing || state_ == kEnded);
   DCHECK_GT(pending_reads_, 0u);
   --pending_reads_;
 
   // 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) {
+    if (frames_queue_ready_.size() == kMaxFrames || frame->IsEndOfStream()) {
       // 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
       // received a seek), we can't rely on ThreadMain() to notify the subclass
       // the frame has been updated.
-      current_frame_ = frames_queue_ready_.front();
-      frames_queue_ready_.pop_front();
+      scoped_refptr<VideoFrame> first_frame;
+      first_frame = frames_queue_ready_.front();
+      if (!first_frame->IsEndOfStream()) {
+        frames_queue_ready_.pop_front();
+        current_frame_ = first_frame;
+      }
       OnFrameAvailable();
 
       seek_callback_->Run();
       seek_callback_.reset();
     }
-  } else if (state_ == kPaused && pending_reads_ == 0 && !pending_paint_) {
+  } else if (state_ == kFlushing && pending_reads_ == 0 && !pending_paint_) {
     // No more pending reads!  We're now officially "paused".
-    if (pause_callback_.get()) {
-      pause_callback_->Run();
-      pause_callback_.reset();
+    if (flush_callback_.get()) {
+      flush_callback_->Run();
+      flush_callback_.reset();
     }
   }
 }
 
 void VideoRendererBase::ScheduleRead_Locked() {
   lock_.AssertAcquired();
   DCHECK_NE(kEnded, state_);
   // TODO(jiesun): We use dummy buffer to feed decoder to let decoder to
   // provide buffer pools. In the future, we may want to implement real
   // buffer pool to recycle buffers.
   while (!frames_queue_done_.empty()) {
     scoped_refptr<VideoFrame> video_frame = frames_queue_done_.front();
     frames_queue_done_.pop_front();
     decoder_->FillThisBuffer(video_frame);
     DCHECK_LT(pending_reads_, kMaxFrames);
     ++pending_reads_;
   }
 }
 
 void VideoRendererBase::FlushBuffers() {
   DCHECK(!pending_paint_);
 
   // We should never put EOF frame into "done queue".
   while (!frames_queue_ready_.empty()) {
     scoped_refptr<VideoFrame> video_frame = frames_queue_ready_.front();
-    if (video_frame->IsEndOfStream()) {
+    if (!video_frame->IsEndOfStream()) {
       frames_queue_done_.push_back(video_frame);
     }
     frames_queue_ready_.pop_front();
   }
   if (current_frame_.get() && !current_frame_->IsEndOfStream()) {
     frames_queue_done_.push_back(current_frame_);
   }
   current_frame_ = NULL;
 }
 
@@ skipping 20 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