Fix perf and paint issues with VRI::PaintSingleFrame.

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 41 matching lines @@
       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),
       last_video_memory_usage_(0),
       have_renderered_frames_(false),
       last_frame_opaque_(false),
+      painted_first_frame_(false),
       weak_factory_(this),
       frame_callback_weak_factory_(this) {
   if (gpu_factories &&
       gpu_factories->ShouldUseGpuMemoryBuffersForVideoFrames()) {
     gpu_memory_buffer_pool_.reset(new GpuMemoryBufferVideoFramePool(
         media_task_runner, worker_task_runner, gpu_factories));
   }
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 
   if (sink_started_)
     StopSink();
 }
 
 void VideoRendererImpl::Flush(const base::Closure& callback) {

[chcunningham, 2016/10/21 20:27:22]

should you reset painted_first_frame_ here?

[DaleCurtis, 2016/10/21 21:51:17]

Yup, done.

   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (sink_started_)
     StopSink();
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPlaying);
   flush_cb_ = callback;
   state_ = kFlushing;
@@ skipping 24 matching lines @@
 void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
   DVLOG(1) << __func__ << "(" << timestamp.InMicroseconds() << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kPlaying;
   start_timestamp_ = timestamp;
+  painted_first_frame_ = false;
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
     CdmContext* cdm_context,
     RendererClient* client,
     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
     const PipelineStatusCB& init_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 254 matching lines @@
   // Attempt to purge bad frames in case of underflow or backgrounding.
   RemoveFramesForUnderflowOrBackgroundRendering();
 
   // We may have removed all frames above and have reached end of stream.
   MaybeFireEndedCallback_Locked(time_progressing_);
 
   // Update statistics here instead of during Render() when the sink is stopped.
   if (!sink_started_)
     UpdateStats_Locked();
 
-  // Paint the first frame if possible and necessary. PaintSingleFrame() will
-  // ignore repeated calls for the same frame. Paint ahead of HAVE_ENOUGH_DATA
-  // to ensure the user sees the frame as early as possible.
-  if (!sink_started_ && algorithm_->frames_queued()) {
+  // Paint the first frame if possible and necessary. Paint ahead of
+  // HAVE_ENOUGH_DATA to ensure the user sees the frame as early as possible.
+  if (!sink_started_ && algorithm_->frames_queued() && !painted_first_frame_) {
     // We want to paint the first frame under two conditions: Either (1) we have
     // enough frames to know it's definitely the first frame or (2) there may be
     // no more frames coming (sometimes unless we paint one of them).
     //
     // For the first condition, we need at least two frames or the first frame
     // must have a timestamp >= |start_timestamp_|, since otherwise we may be
     // prerolling frames before the actual start time that will be dropped.
     if (algorithm_->frames_queued() > 1 || received_end_of_stream_ ||
-        algorithm_->first_frame()->timestamp() >= start_timestamp_ ||
-        low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) {
-      scoped_refptr<VideoFrame> frame = algorithm_->first_frame();
-      CheckForMetadataChanges(frame->format(), frame->natural_size());
-      sink_->PaintSingleFrame(frame);
+        frame->timestamp() >= start_timestamp_ || low_delay_ ||
+        !video_frame_stream_->CanReadWithoutStalling()) {
+      scoped_refptr<VideoFrame> first_frame =
+          algorithm_->Render(base::TimeTicks(), base::TimeTicks(), nullptr);
+      CheckForMetadataChanges(first_frame->format(),
+                              first_frame->natural_size());
+      sink_->PaintSingleFrame(first_frame);
+      painted_first_frame_ = true;
     }
   }
 
   // Signal buffering state if we've met our conditions.
   if (buffering_state_ == BUFFERING_HAVE_NOTHING && HaveEnoughData_Locked())
     TransitionToHaveEnough_Locked();
 
   // Always request more decoded video if we have capacity.
   AttemptRead_Locked();
 }
@@ skipping 236 matching lines @@
   frames_dropped_ += algorithm_->RemoveExpiredFrames(
       current_time + algorithm_->average_frame_duration());
 
   // 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);
+    painted_first_frame_ = false;

[chcunningham, 2016/10/21 20:27:22]

to be sure I follow, the idea of resetting here is that, once the queue starts
to get even a single frame in it again, we'd like to go ahead and paint that
first frame (while still waiting for the queue to completely fill to resume
playback)?

[DaleCurtis, 2016/10/21 21:51:17]

Correct.

 
     // It's possible in the background rendering case for us to expire enough
     // frames that we need to transition from HAVE_ENOUGH => HAVE_NOTHING. Just
     // calling this function will check if we need to transition or not.
     if (buffering_state_ == BUFFERING_HAVE_ENOUGH)
       TransitionToHaveNothing_Locked();
   }
 }
 
 void VideoRendererImpl::CheckForMetadataChanges(VideoPixelFormat pixel_format,
@@ skipping 18 matching lines @@
 
 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