Make painting a single frame a permanent API on VideoRendererSink.

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 39 matching lines @@
       state_(kUninitialized),
       sequence_token_(0),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       frames_decoded_(0),
       frames_dropped_(0),
       tick_clock_(new base::DefaultTickClock()),
       was_background_rendering_(false),
       time_progressing_(false),
-      render_first_frame_and_stop_(false),
-      posted_maybe_stop_after_first_paint_(false),
       last_video_memory_usage_(0),
       have_renderered_frames_(false),
       last_frame_opaque_(false),
       weak_factory_(this) {
   if (gpu_factories &&
       gpu_factories->ShouldUseGpuMemoryBuffersForVideoFrames()) {
     gpu_memory_buffer_pool_.reset(new GpuMemoryBufferVideoFramePool(
         media_task_runner, worker_task_runner, gpu_factories));
   }
 }
@@ skipping 60 matching lines @@
     RendererClient* client,
     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
     const PipelineStatusCB& init_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!wall_clock_time_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
-  DCHECK(!render_first_frame_and_stop_);
-  DCHECK(!posted_maybe_stop_after_first_paint_);
   DCHECK(!was_background_rendering_);
   DCHECK(!time_progressing_);
   DCHECK(!have_renderered_frames_);
 
   low_delay_ = (stream->liveness() == DemuxerStream::LIVENESS_LIVE);
   UMA_HISTOGRAM_BOOLEAN("Media.VideoRenderer.LowDelay", low_delay_);
   if (low_delay_)
     MEDIA_LOG(DEBUG, media_log_) << "Video rendering in low delay mode.";
 
   // Always post |init_cb_| because |this| could be destroyed if initialization
@@ skipping 21 matching lines @@
   DCHECK_EQ(state_, kPlaying);
 
   size_t frames_dropped = 0;
   scoped_refptr<VideoFrame> result =
       algorithm_->Render(deadline_min, deadline_max, &frames_dropped);
 
   // Due to how the |algorithm_| holds frames, this should never be null if
   // we've had a proper startup sequence.
   DCHECK(result);
 
-  // Notify client of size and opacity changes if this is the first frame
-  // or if those have changed from the last frame.
-  if (!have_renderered_frames_ ||
-      (last_frame_natural_size_ != result->natural_size())) {
-    last_frame_natural_size_ = result->natural_size();
-    task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&VideoRendererImpl::OnVideoNaturalSizeChange,
-                   weak_factory_.GetWeakPtr(), last_frame_natural_size_));
-  }
-  if (!have_renderered_frames_ ||
-      (last_frame_opaque_ != IsOpaque(result->format()))) {
-    last_frame_opaque_ = IsOpaque(result->format());
-    task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VideoRendererImpl::OnVideoOpacityChange,
-                              weak_factory_.GetWeakPtr(), last_frame_opaque_));
-  }
-
   // Declare HAVE_NOTHING if we reach a state where we can't progress playback
   // any further.  We don't want to do this if we've already done so, reached
   // end of stream, or have frames available.  We also don't want to do this in
   // background rendering mode unless this isn't the first background render
   // tick and we haven't seen any decoded frames since the last one.
-  //
-  // We use the inverse of |render_first_frame_and_stop_| as a proxy for the
-  // value of |time_progressing_| here since we can't access it from the
-  // compositor thread.  If we're here (in Render()) the sink must have been
-  // started -- but if it was started only to render the first frame and stop,
-  // then |time_progressing_| is likely false.  If we're still in Render() when
-  // |render_first_frame_and_stop_| is false, then |time_progressing_| is true.
-  // If |time_progressing_| is actually true when |render_first_frame_and_stop_|
-  // is also true, then the ended callback will be harmlessly delayed until
-  // MaybeStopSinkAfterFirstPaint() runs and the next Render() call comes in.
-  MaybeFireEndedCallback_Locked(!render_first_frame_and_stop_);
+  MaybeFireEndedCallback_Locked(true);
   if (buffering_state_ == BUFFERING_HAVE_ENOUGH && !received_end_of_stream_ &&
       !algorithm_->effective_frames_queued() &&
       (!background_rendering ||
        (!frames_decoded_ && was_background_rendering_))) {
     // Do not set |buffering_state_| here as the lock in FrameReady() may be
     // held already and it fire the state changes in the wrong order.
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoRendererImpl::TransitionToHaveNothing,
                               weak_factory_.GetWeakPtr()));
   }
 
   // We don't count dropped frames in the background to avoid skewing the count
   // and impacting JavaScript visible metrics used by web developers.
   //
   // Just after resuming from background rendering, we also don't count the
   // dropped frames since they are likely just dropped due to being too old.
   if (!background_rendering && !was_background_rendering_)
     frames_dropped_ += frames_dropped;
   UpdateStats_Locked();
   was_background_rendering_ = background_rendering;
 
-  // After painting the first frame, if playback hasn't started, we post a
-  // delayed task to request that the sink be stopped.  The task is delayed to
-  // give videos with autoplay time to start.
-  //
-  // OnTimeStateChanged() will clear this flag if time starts before we get here
-  // and MaybeStopSinkAfterFirstPaint() will ignore this request if time starts
-  // before the call executes.
-  if (render_first_frame_and_stop_ && !posted_maybe_stop_after_first_paint_) {
-    posted_maybe_stop_after_first_paint_ = true;
-    task_runner_->PostDelayedTask(
-        FROM_HERE, base::Bind(&VideoRendererImpl::MaybeStopSinkAfterFirstPaint,
-                              weak_factory_.GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(250));
-  }
-
   // Always post this task, it will acquire new frames if necessary and since it
   // happens on another thread, even if we don't have room in the queue now, by
   // the time it runs (may be delayed up to 50ms for complex decodes!) we might.
-  task_runner_->PostTask(FROM_HERE, base::Bind(&VideoRendererImpl::AttemptRead,
-                                               weak_factory_.GetWeakPtr()));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoRendererImpl::AttemptReadAndCheckForMetadataChanges,
+                 weak_factory_.GetWeakPtr(), result->format(),
+                 result->natural_size()));
 
-  have_renderered_frames_ = true;
   return result;
 }
 
 void VideoRendererImpl::OnFrameDropped() {
   base::AutoLock auto_lock(lock_);
   algorithm_->OnLastFrameDropped();
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 37 matching lines @@
 void VideoRendererImpl::OnBufferingStateChange(BufferingState state) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnBufferingStateChange(state);
 }
 
 void VideoRendererImpl::OnWaitingForDecryptionKey() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnWaitingForDecryptionKey();
 }
 
-void VideoRendererImpl::OnVideoNaturalSizeChange(const gfx::Size& size) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  client_->OnVideoNaturalSizeChange(size);
-}
-
-void VideoRendererImpl::OnVideoOpacityChange(bool opaque) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  client_->OnVideoOpacityChange(opaque);
-}
-
 void VideoRendererImpl::SetTickClockForTesting(
     std::unique_ptr<base::TickClock> tick_clock) {
   tick_clock_.swap(tick_clock);
 }
 
 void VideoRendererImpl::SetGpuMemoryBufferVideoForTesting(
     std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool) {
   gpu_memory_buffer_pool_.swap(gpu_memory_buffer_pool);
 }
 
@@ skipping 44 matching lines @@
   DCHECK(frame);
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       frame, base::Bind(&VideoRendererImpl::FrameReady,
                         weak_factory_.GetWeakPtr(), sequence_token_, status));
 }
 
 void VideoRendererImpl::FrameReady(uint32_t sequence_token,
                                    VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  bool start_sink = false;
-  {
-    base::AutoLock auto_lock(lock_);
-    // Stream has been reset and this VideoFrame was decoded before the reset
-    // but the async copy finished after.
-    if (sequence_token != sequence_token_)
-      return;
+  base::AutoLock auto_lock(lock_);
 
-    DCHECK_NE(state_, kUninitialized);
-    DCHECK_NE(state_, kFlushed);
+  // Stream has been reset and this VideoFrame was decoded before the reset
+  // but the async copy finished after.
+  if (sequence_token != sequence_token_)
+    return;
 
-    CHECK(pending_read_);
-    pending_read_ = false;
+  DCHECK_NE(state_, kUninitialized);
+  DCHECK_NE(state_, kFlushed);
 
-    if (status == VideoFrameStream::DECODE_ERROR) {
-      DCHECK(!frame);
-      task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&VideoRendererImpl::OnPlaybackError,
-                     weak_factory_.GetWeakPtr(), PIPELINE_ERROR_DECODE));
-      return;
-    }
+  CHECK(pending_read_);
+  pending_read_ = false;
 
-    // Already-queued VideoFrameStream ReadCB's can fire after various state
-    // transitions have happened; in that case just drop those frames
-    // immediately.
-    if (state_ == kFlushing)
-      return;
-
-    DCHECK_EQ(state_, kPlaying);
-
-    // Can happen when demuxers are preparing for a new Seek().
-    if (!frame) {
-      DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
-      return;
-    }
-
-    if (frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM)) {
-      DCHECK(!received_end_of_stream_);
-      received_end_of_stream_ = true;
-
-      // See if we can fire EOS immediately instead of waiting for Render().
-      MaybeFireEndedCallback_Locked(time_progressing_);
-    } else if ((low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) &&
-               IsBeforeStartTime(frame->timestamp())) {
-      // Don't accumulate frames that are earlier than the start time if we
-      // won't have a chance for a better frame, otherwise we could declare
-      // HAVE_ENOUGH_DATA and start playback prematurely.
-      AttemptRead_Locked();
-      return;
-    } else {
-      // If the sink hasn't been started, we still have time to release less
-      // than ideal frames prior to startup.  We don't use IsBeforeStartTime()
-      // here since it's based on a duration estimate and we can be exact here.
-      if (!sink_started_ && frame->timestamp() <= start_timestamp_)
-        algorithm_->Reset();
-
-      AddReadyFrame_Locked(frame);
-    }
-
-    // Attempt to purge bad frames in case of underflow or backgrounding.
-    RemoveFramesForUnderflowOrBackgroundRendering();
-
-    // Signal buffering state if we've met our conditions.
-    if (buffering_state_ == BUFFERING_HAVE_NOTHING && HaveEnoughData_Locked()) {
-      TransitionToHaveEnough_Locked();
-      if (!sink_started_ && !rendered_end_of_stream_) {
-        start_sink = true;
-        render_first_frame_and_stop_ = true;
-        posted_maybe_stop_after_first_paint_ = false;
-      }
-    }
-
-    // Always request more decoded video if we have capacity. This serves two
-    // purposes:
-    //   1) Prerolling while paused
-    //   2) Keeps decoding going if video rendering thread starts falling behind
-    AttemptRead_Locked();
+  if (status == VideoFrameStream::DECODE_ERROR) {
+    DCHECK(!frame);
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoRendererImpl::OnPlaybackError,
+                   weak_factory_.GetWeakPtr(), PIPELINE_ERROR_DECODE));
+    return;
   }
 
-  // If time is progressing, the sink has already been started; this may be true
-  // if we have previously underflowed, yet weren't stopped because of audio.
-  if (start_sink) {
-    DCHECK(!sink_started_);
-    StartSink();
+  // Already-queued VideoFrameStream ReadCB's can fire after various state
+  // transitions have happened; in that case just drop those frames
+  // immediately.
+  if (state_ == kFlushing)
+    return;
+
+  DCHECK_EQ(state_, kPlaying);
+
+  // Can happen when demuxers are preparing for a new Seek().
+  if (!frame) {
+    DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
+    return;
   }
+
+  if (frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM)) {
+    DCHECK(!received_end_of_stream_);
+    received_end_of_stream_ = true;
+
+    // See if we can fire EOS immediately instead of waiting for Render().
+    MaybeFireEndedCallback_Locked(time_progressing_);
+  } else if ((low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) &&
+             IsBeforeStartTime(frame->timestamp())) {
+    // Don't accumulate frames that are earlier than the start time if we
+    // won't have a chance for a better frame, otherwise we could declare
+    // HAVE_ENOUGH_DATA and start playback prematurely.
+    AttemptRead_Locked();
+    return;
+  } else {
+    // If the sink hasn't been started, we still have time to release less
+    // than ideal frames prior to startup.  We don't use IsBeforeStartTime()
+    // here since it's based on a duration estimate and we can be exact here.
+    if (!sink_started_ && frame->timestamp() <= start_timestamp_)
+      algorithm_->Reset();
+
+    AddReadyFrame_Locked(frame);
+  }
+
+  // Attempt to purge bad frames in case of underflow or backgrounding.
+  RemoveFramesForUnderflowOrBackgroundRendering();
+
+  // Signal buffering state if we've met our conditions.
+  if (buffering_state_ == BUFFERING_HAVE_NOTHING && HaveEnoughData_Locked()) {
+    TransitionToHaveEnough_Locked();
+
+    // Paint the first frame if necessary.
+    if (!rendered_end_of_stream_ && !sink_started_) {
+      DCHECK(algorithm_->frames_queued());
+      scoped_refptr<VideoFrame> frame = algorithm_->first_frame();
+      CheckForMetadataChanges(frame->format(), frame->natural_size());
+      sink_->PaintSingleFrame(frame);
+    }
+  }
+
+  // Always request more decoded video if we have capacity. This serves two
+  // purposes:
+  //   1) Prerolling while paused
+  //   2) Keeps decoding going if video rendering thread starts falling behind
+  AttemptRead_Locked();
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
   lock_.AssertAcquired();
 
   if (received_end_of_stream_)
     return true;
 
   if (HaveReachedBufferingCap())
@@ skipping 36 matching lines @@
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
   DCHECK(!frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM));
 
   frames_decoded_++;
 
   algorithm_->EnqueueFrame(frame);
 }
 
-void VideoRendererImpl::AttemptRead() {
-  base::AutoLock auto_lock(lock_);
-  AttemptRead_Locked();
-}
-
 void VideoRendererImpl::AttemptRead_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   lock_.AssertAcquired();
 
   if (pending_read_ || received_end_of_stream_)
     return;
 
   if (HaveReachedBufferingCap())
     return;
 
@@ skipping 47 matching lines @@
 
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&VideoRendererImpl::OnStatisticsUpdate,
                                       weak_factory_.GetWeakPtr(), statistics));
     frames_decoded_ = 0;
     frames_dropped_ = 0;
     last_video_memory_usage_ = memory_usage;
   }
 }
 
-void VideoRendererImpl::MaybeStopSinkAfterFirstPaint() {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-
-  if (!time_progressing_ && sink_started_)
-    StopSink();
-
-  base::AutoLock auto_lock(lock_);
-  render_first_frame_and_stop_ = false;
-}
-
 bool VideoRendererImpl::HaveReachedBufferingCap() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   const size_t kMaxVideoFrames = limits::kMaxVideoFrames;
 
   // When the display rate is less than the frame rate, the effective frames
   // queued may be much smaller than the actual number of frames queued.  Here
   // we ensure that frames_queued() doesn't get excessive.
   return algorithm_->effective_frames_queued() >= kMaxVideoFrames ||
          algorithm_->frames_queued() >= 3 * kMaxVideoFrames;
 }
@@ skipping 97 matching lines @@
   // If we've paused for underflow, and still have no effective frames, clear
   // the entire queue.  Note: this may cause slight inaccuracies in the number
   // of dropped frames since the frame may have been rendered before.
   if (!sink_started_ && !algorithm_->effective_frames_queued()) {
     frames_dropped_ += algorithm_->frames_queued();
     algorithm_->Reset(
         VideoRendererAlgorithm::ResetFlag::kPreserveNextFrameEstimates);
   }
 }
 
+void VideoRendererImpl::CheckForMetadataChanges(VideoPixelFormat pixel_format,
+                                                const gfx::Size& natural_size) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  // Notify client of size and opacity changes if this is the first frame
+  // or if those have changed from the last frame.
+  if (!have_renderered_frames_ || last_frame_natural_size_ != natural_size) {
+    last_frame_natural_size_ = natural_size;
+    client_->OnVideoNaturalSizeChange(last_frame_natural_size_);
+  }
+
+  const bool is_opaque = IsOpaque(pixel_format);
+  if (!have_renderered_frames_ || last_frame_opaque_ != is_opaque) {
+    last_frame_opaque_ = is_opaque;
+    client_->OnVideoOpacityChange(last_frame_opaque_);
+  }
+
+  have_renderered_frames_ = true;
+}
+
+void VideoRendererImpl::AttemptReadAndCheckForMetadataChanges(
+    VideoPixelFormat pixel_format,
+    const gfx::Size& natural_size) {
+  base::AutoLock auto_lock(lock_);
+  CheckForMetadataChanges(pixel_format, natural_size);
+  AttemptRead_Locked();
+}
+
 }  // namespace media