Revert r180578, r180591, and r180604 from 1410 branch.

media/filters/video_renderer_base.cc

 // Copyright (c) 2012 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_base.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop.h"
 #include "base/threading/platform_thread.h"
 #include "media/base/buffers.h"
 #include "media/base/limits.h"
 #include "media/base/pipeline.h"
 #include "media/base/video_frame.h"
 #include "media/filters/decrypting_demuxer_stream.h"
 #include "media/filters/video_decoder_selector.h"
 
 namespace media {
 
 base::TimeDelta VideoRendererBase::kMaxLastFrameDuration() {
   return base::TimeDelta::FromMilliseconds(250);
 }
 
 VideoRendererBase::VideoRendererBase(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
-    const PaintCB& paint_cb,
+    const base::Closure& paint_cb,
     const SetOpaqueCB& set_opaque_cb,
     bool drop_frames)
     : message_loop_(message_loop),
-      weak_factory_(this),
       set_decryptor_ready_cb_(set_decryptor_ready_cb),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(base::kNullThreadHandle),
       pending_read_(false),
+      pending_paint_(false),
+      pending_paint_with_last_available_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
-      set_opaque_cb_(set_opaque_cb),
-      last_timestamp_(kNoTimestamp()) {
+      set_opaque_cb_(set_opaque_cb) {
   DCHECK(!paint_cb_.is_null());
 }
 
-VideoRendererBase::~VideoRendererBase() {
-  base::AutoLock auto_lock(lock_);
-  CHECK(state_ == kUninitialized || state_ == kStopped) << state_;
-  CHECK_EQ(thread_, base::kNullThreadHandle);
-}
-
 void VideoRendererBase::Play(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kPrerolled, state_);
   state_ = kPlaying;
   callback.Run();
 }
 
 void VideoRendererBase::Pause(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ != kUninitialized || state_ == kError);
   state_ = kPaused;
   callback.Run();
 }
 
 void VideoRendererBase::Flush(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
   state_ = kFlushingDecoder;
 
   if (decrypting_demuxer_stream_) {
     decrypting_demuxer_stream_->Reset(base::Bind(
-        &VideoRendererBase::ResetDecoder, weak_this_));
+        &VideoRendererBase::ResetDecoder, this));
     return;
   }
 
-  decoder_->Reset(base::Bind(
-      &VideoRendererBase::OnDecoderResetDone, weak_this_));
+  decoder_->Reset(base::Bind(&VideoRendererBase::OnDecoderResetDone, this));
 }
 
 void VideoRendererBase::ResetDecoder() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
-  decoder_->Reset(base::Bind(
-      &VideoRendererBase::OnDecoderResetDone, weak_this_));
+  decoder_->Reset(base::Bind(&VideoRendererBase::OnDecoderResetDone, this));
 }
 
 void VideoRendererBase::Stop(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
-  base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kStopped) {
     callback.Run();
     return;
   }
 
-  // TODO(scherkus): Consider invalidating |weak_factory_| and replacing
-  // task-running guards that check |state_| with DCHECK().
+  base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
+  {
+    base::AutoLock auto_lock(lock_);
+    state_ = kStopped;
 
-  state_ = kStopped;
+    statistics_cb_.Reset();
+    max_time_cb_.Reset();
+    if (!pending_paint_ && !pending_paint_with_last_available_)
+      DoStopOrError_Locked();
 
-  statistics_cb_.Reset();
-  max_time_cb_.Reset();
-  DoStopOrError_Locked();
-
-  // Clean up our thread if present.
-  base::PlatformThreadHandle thread_to_join = base::kNullThreadHandle;
-  if (thread_ != base::kNullThreadHandle) {
-    // Signal the thread since it's possible to get stopped with the video
-    // thread waiting for a read to complete.
-    frame_available_.Signal();
-    std::swap(thread_, thread_to_join);
+    // Clean up our thread if present.
+    if (thread_ != base::kNullThreadHandle) {
+      // Signal the thread since it's possible to get stopped with the video
+      // thread waiting for a read to complete.
+      frame_available_.Signal();
+      thread_to_join = thread_;
+      thread_ = base::kNullThreadHandle;
+    }
   }
-
-  if (thread_to_join != base::kNullThreadHandle) {
-    base::AutoUnlock auto_unlock(lock_);
+  if (thread_to_join != base::kNullThreadHandle)
     base::PlatformThread::Join(thread_to_join);
-  }
 
   if (decrypting_demuxer_stream_) {
     decrypting_demuxer_stream_->Reset(base::Bind(
-        &VideoRendererBase::StopDecoder, weak_this_, callback));
+        &VideoRendererBase::StopDecoder, this, callback));
     return;
   }
 
   decoder_->Stop(callback);
 }
 
 void VideoRendererBase::StopDecoder(const base::Closure& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   decoder_->Stop(callback);
@@ skipping 37 matching lines @@
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_time_cb.is_null());
   DCHECK(!size_changed_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!get_time_cb.is_null());
   DCHECK(!get_duration_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
 
-  weak_this_ = weak_factory_.GetWeakPtr();
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_time_cb;
   size_changed_cb_ = size_changed_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   get_time_cb_ = get_time_cb;
   get_duration_cb_ = get_duration_cb;
 
   scoped_ptr<VideoDecoderSelector> decoder_selector(
       new VideoDecoderSelector(base::MessageLoopProxy::current(),
                                decoders,
                                set_decryptor_ready_cb_));
 
   // To avoid calling |decoder_selector| methods and passing ownership of
   // |decoder_selector| in the same line.
   VideoDecoderSelector* decoder_selector_ptr = decoder_selector.get();
 
   decoder_selector_ptr->SelectVideoDecoder(
       stream,
       statistics_cb,
-      base::Bind(&VideoRendererBase::OnDecoderSelected, weak_this_,
+      base::Bind(&VideoRendererBase::OnDecoderSelected, this,
                  base::Passed(&decoder_selector)));
 }
 
 void VideoRendererBase::OnDecoderSelected(
     scoped_ptr<VideoDecoderSelector> decoder_selector,
     const scoped_refptr<VideoDecoder>& selected_decoder,
     const scoped_refptr<DecryptingDemuxerStream>& decrypting_demuxer_stream) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
 
@@ skipping 40 matching lines @@
 
   // 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.
   //
   // TOOD(scherkus): switch to pure event-driven frame timing instead of this
   // kIdleTimeDelta business http://crbug.com/106874
   const base::TimeDelta kIdleTimeDelta =
       base::TimeDelta::FromMilliseconds(10);
 
+  uint32 frames_dropped = 0;
+
   for (;;) {
     base::AutoLock auto_lock(lock_);
 
     // Thread exit condition.
     if (state_ == kStopped)
       return;
 
+    if (frames_dropped > 0) {
+      PipelineStatistics statistics;
+      statistics.video_frames_dropped = frames_dropped;
+      statistics_cb_.Run(statistics);
+
+      frames_dropped = 0;
+    }
+
     // Remain idle as long as we're not playing.
     if (state_ != kPlaying || playback_rate_ == 0) {
       frame_available_.TimedWait(kIdleTimeDelta);
       continue;
     }
 
     // Remain idle until we have the next frame ready for rendering.
     if (ready_frames_.empty()) {
       frame_available_.TimedWait(kIdleTimeDelta);
       continue;
     }
 
-    // We've reached the end!
-    if (ready_frames_.front()->IsEndOfStream()) {
-      state_ = kEnded;
-      ready_frames_.clear();
-      ended_cb_.Run();
+    // Remain idle until we've initialized |current_frame_| via prerolling.
+    if (!current_frame_) {
+      // This can happen if our preroll only contains end of stream frames.
+      if (ready_frames_.front()->IsEndOfStream()) {
+        state_ = kEnded;
+        ended_cb_.Run();
+        ready_frames_.clear();
 
-      // No need to sleep here as we idle when |state_ != kPlaying|.
+        // No need to sleep here as we idle when |state_ != kPlaying|.
+        continue;
+      }
+
+      frame_available_.TimedWait(kIdleTimeDelta);
       continue;
     }
 
+    // Calculate how long until we should advance the frame, which is
+    // typically negative but for playback rates < 1.0f may be long enough
+    // that it makes more sense to idle and check again.
     base::TimeDelta remaining_time =
         CalculateSleepDuration(ready_frames_.front(), playback_rate_);
 
     // 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);
       frame_available_.TimedWait(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.
+
+    // We're almost there!
     //
-    // 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.
+    // At this point we've rendered |current_frame_| for the proper amount
+    // of time and also have the next frame that ready for rendering.
+
+
+    // If the next frame is end of stream then we are truly at the end of the
+    // video stream.
     //
-    // 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()->GetTimestamp() +
-          (ready_frames_.front()->GetTimestamp() - last_timestamp_) / 2;
+    // TODO(scherkus): deduplicate this end of stream check after we get rid of
+    // |current_frame_|.
+    if (ready_frames_.front()->IsEndOfStream()) {
+      state_ = kEnded;
+      ended_cb_.Run();
+      ready_frames_.clear();
 
-      if (now > deadline) {
-        DropNextReadyFrame_Locked();
-        continue;
+      // No need to sleep here as we idle when |state_ != kPlaying|.
+      continue;
+    }
+
+    // We cannot update |current_frame_| until we've completed the pending
+    // paint. Furthermore, the pending paint might be really slow: check to
+    // see if we have any ready frames that we can drop if they've already
+    // expired.
+    if (pending_paint_) {
+      while (!ready_frames_.empty()) {
+        // Can't drop anything if we're at the end.
+        if (ready_frames_.front()->IsEndOfStream())
+          break;
+
+        base::TimeDelta remaining_time =
+            ready_frames_.front()->GetTimestamp() - get_time_cb_.Run();
+
+        // Still a chance we can render the frame!
+        if (remaining_time.InMicroseconds() > 0)
+          break;
+
+        if (!drop_frames_)
+          break;
+
+        // Frame dropped: read again.
+        ++frames_dropped;
+        ready_frames_.pop_front();
+        message_loop_->PostTask(FROM_HERE, base::Bind(
+            &VideoRendererBase::AttemptRead, this));
       }
+      // Continue waiting for the current paint to finish.
+      frame_available_.TimedWait(kIdleTimeDelta);
+      continue;
     }
 
+
     // Congratulations! You've made it past the video frame timing gauntlet.
     //
-    // At this point enough time has passed that the next frame that ready for
-    // rendering.
-    PaintNextReadyFrame_Locked();
+    // We can now safely update the current frame, request another frame, and
+    // signal to the client that a new frame is available.
+    DCHECK(!pending_paint_);
+    DCHECK(!ready_frames_.empty());
+    SetCurrentFrameToNextReadyFrame();
+    message_loop_->PostTask(FROM_HERE, base::Bind(
+        &VideoRendererBase::AttemptRead, this));
+
+    base::AutoUnlock auto_unlock(lock_);
+    paint_cb_.Run();
   }
 }
 
-void VideoRendererBase::PaintNextReadyFrame_Locked() {
-  lock_.AssertAcquired();
-
-  scoped_refptr<VideoFrame> next_frame = ready_frames_.front();
+void VideoRendererBase::SetCurrentFrameToNextReadyFrame() {
+  current_frame_ = ready_frames_.front();
   ready_frames_.pop_front();
 
-  last_timestamp_ = next_frame->GetTimestamp();
+  // Notify the pipeline of natural_size() changes.
+  const gfx::Size& natural_size = current_frame_->natural_size();
+  if (natural_size != last_natural_size_) {
+    size_changed_cb_.Run(natural_size);
+    last_natural_size_ = natural_size;
+  }
+}
 
-  const gfx::Size& natural_size = next_frame->natural_size();
-  if (natural_size != last_natural_size_) {
-    last_natural_size_ = natural_size;
-    size_changed_cb_.Run(natural_size);
+void VideoRendererBase::GetCurrentFrame(scoped_refptr<VideoFrame>* frame_out) {
+  base::AutoLock auto_lock(lock_);
+  DCHECK(!pending_paint_ && !pending_paint_with_last_available_);
+
+  if ((!current_frame_ || current_frame_->IsEndOfStream()) &&
+      (!last_available_frame_ || last_available_frame_->IsEndOfStream())) {
+    *frame_out = NULL;
+    return;
   }
 
-  paint_cb_.Run(next_frame);
+  // We should have initialized and have the current frame.
+  DCHECK_NE(state_, kUninitialized);
+  DCHECK_NE(state_, kStopped);
+  DCHECK_NE(state_, kError);
 
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &VideoRendererBase::AttemptRead, weak_this_));
+  if (current_frame_) {
+    *frame_out = current_frame_;
+    last_available_frame_ = current_frame_;
+    pending_paint_ = true;
+  } else {
+    DCHECK(last_available_frame_);
+    *frame_out = last_available_frame_;
+    pending_paint_with_last_available_ = true;
+  }
 }
 
-void VideoRendererBase::DropNextReadyFrame_Locked() {
-  lock_.AssertAcquired();
+void VideoRendererBase::PutCurrentFrame(scoped_refptr<VideoFrame> frame) {
+  base::AutoLock auto_lock(lock_);
 
-  last_timestamp_ = ready_frames_.front()->GetTimestamp();
-  ready_frames_.pop_front();
+  // Note that we do not claim |pending_paint_| when we return NULL frame, in
+  // that case, |current_frame_| could be changed before PutCurrentFrame.
+  if (pending_paint_) {
+    DCHECK_EQ(current_frame_, frame);
+    DCHECK(!pending_paint_with_last_available_);
+    pending_paint_ = false;
+  } else if (pending_paint_with_last_available_) {
+    DCHECK_EQ(last_available_frame_, frame);
+    DCHECK(!pending_paint_);
+    pending_paint_with_last_available_ = false;
+  } else {
+    DCHECK(!frame);
+  }
 
-  PipelineStatistics statistics;
-  statistics.video_frames_dropped = 1;
-  statistics_cb_.Run(statistics);
+  // 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_ == kFlushingDecoder)
+    return;
 
-  message_loop_->PostTask(FROM_HERE, base::Bind(
-      &VideoRendererBase::AttemptRead, weak_this_));
+  if (state_ == kFlushing) {
+    AttemptFlush_Locked();
+    return;
+  }
+
+  if (state_ == kError || state_ == kStopped) {
+    DoStopOrError_Locked();
+  }
+}
+
+VideoRendererBase::~VideoRendererBase() {
+  base::AutoLock auto_lock(lock_);
+  CHECK(state_ == kUninitialized || state_ == kStopped) << state_;
+  CHECK_EQ(thread_, base::kNullThreadHandle);
 }
 
 void VideoRendererBase::FrameReady(VideoDecoder::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
 
   CHECK(pending_read_);
   pending_read_ = false;
 
@@ skipping 58 matching lines @@
   // purposes:
   //   1) Prerolling while paused
   //   2) Keeps decoding going if video rendering thread starts falling behind
   if (NumFrames_Locked() < limits::kMaxVideoFrames && !frame->IsEndOfStream()) {
     AttemptRead_Locked();
     return;
   }
 
   // If we're at capacity or end of stream while prerolling we need to
   // transition to prerolled.
-  if (state_ != kPrerolling)
-    return;
+  if (state_ == kPrerolling) {
+    DCHECK(!current_frame_);
+    state_ = kPrerolled;
 
-  state_ = kPrerolled;
+    // Because we might remain in the prerolled state for an undetermined amount
+    // of time (i.e., we were not playing before we started prerolling), we'll
+    // manually update the current frame and notify the subclass below.
+    if (!ready_frames_.front()->IsEndOfStream())
+      SetCurrentFrameToNextReadyFrame();
 
-  // Because we might remain in the prerolled state for an undetermined amount
-  // of time (e.g., we seeked while paused), we'll paint the first prerolled
-  // frame.
-  if (!ready_frames_.front()->IsEndOfStream())
-    PaintNextReadyFrame_Locked();
+    // ...and we're done prerolling!
+    DCHECK(!preroll_cb_.is_null());
+    base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
 
-  base::ResetAndReturn(&preroll_cb_).Run(PIPELINE_OK);
+    base::AutoUnlock ul(lock_);
+    paint_cb_.Run();
+  }
 }
 
 void VideoRendererBase::AddReadyFrame(const scoped_refptr<VideoFrame>& frame) {
   // Adjust the incoming frame if its rendering stop time is past the duration
   // of the video itself. This is typically the last frame of the video and
   // occurs if the container specifies a duration that isn't a multiple of the
   // frame rate.  Another way for this to happen is for the container to state a
   // smaller duration than the largest packet timestamp.
   base::TimeDelta duration = get_duration_cb_.Run();
   if (frame->IsEndOfStream()) {
     base::TimeDelta end_timestamp = kNoTimestamp();
     if (!ready_frames_.empty()) {
       end_timestamp = std::min(
           duration,
           ready_frames_.back()->GetTimestamp() + kMaxLastFrameDuration());
-    } else if (last_timestamp_ != kNoTimestamp()) {
+    } else if (current_frame_) {
       end_timestamp =
-          std::min(duration, last_timestamp_ + kMaxLastFrameDuration());
+          std::min(duration,
+                   current_frame_->GetTimestamp() + kMaxLastFrameDuration());
     }
     frame->SetTimestamp(end_timestamp);
   } else if (frame->GetTimestamp() > duration) {
     frame->SetTimestamp(duration);
   }
 
   ready_frames_.push_back(frame);
   DCHECK_LE(NumFrames_Locked(), limits::kMaxVideoFrames);
 
   base::TimeDelta max_clock_time =
@@ skipping 18 matching lines @@
       (!ready_frames_.empty() && ready_frames_.back()->IsEndOfStream())) {
     return;
   }
 
   switch (state_) {
     case kPaused:
     case kFlushing:
     case kPrerolling:
     case kPlaying:
       pending_read_ = true;
-      decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, weak_this_));
+      decoder_->Read(base::Bind(&VideoRendererBase::FrameReady, this));
       return;
 
     case kUninitialized:
     case kPrerolled:
     case kFlushingDecoder:
     case kFlushed:
     case kEnded:
     case kStopped:
     case kError:
       return;
   }
 }
 
 void VideoRendererBase::OnDecoderResetDone() {
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kFlushingDecoder, state_);
   DCHECK(!pending_read_);
 
   state_ = kFlushing;
   AttemptFlush_Locked();
 }
 
 void VideoRendererBase::AttemptFlush_Locked() {
   lock_.AssertAcquired();
   DCHECK_EQ(kFlushing, state_);
 
   prerolling_delayed_frame_ = NULL;
   ready_frames_.clear();
 
-  if (pending_read_)
-    return;
-
-  state_ = kFlushed;
-  last_timestamp_ = kNoTimestamp();
-  base::ResetAndReturn(&flush_cb_).Run();
+  if (!pending_paint_ && !pending_read_) {
+    state_ = kFlushed;
+    current_frame_ = NULL;
+    base::ResetAndReturn(&flush_cb_).Run();
+  }
 }
 
 base::TimeDelta VideoRendererBase::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->GetTimestamp();
 
   // 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 VideoRendererBase::DoStopOrError_Locked() {
+  DCHECK(!pending_paint_);
+  DCHECK(!pending_paint_with_last_available_);
   lock_.AssertAcquired();
-  last_timestamp_ = kNoTimestamp();
+  current_frame_ = NULL;
+  last_available_frame_ = NULL;
   ready_frames_.clear();
 }
 
 int VideoRendererBase::NumFrames_Locked() const {
   lock_.AssertAcquired();
-  return ready_frames_.size();
+  int outstanding_frames =
+      (current_frame_ ? 1 : 0) + (last_available_frame_ ? 1 : 0) +
+      (current_frame_ && (current_frame_ == last_available_frame_) ? -1 : 0);
+  return ready_frames_.size() + outstanding_frames;
 }
 
 }  // namespace media