Paint first frame faster, don't crash with no frames during EOS.

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 356 matching lines @@
 
   // 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();
+  // We may have removed all frames above and have reached end of stream.
+  MaybeFireEndedCallback_Locked(time_progressing_);
 
-    // Paint the first frame if necessary.
-    if (!rendered_end_of_stream_ && !sink_started_) {
-      DCHECK(algorithm_->frames_queued());
+  // 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()) {
+    // 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

[xhwang, 2016/05/24 21:46:29]

Could you please explain more about why when we see two frame we know a frame is
definitely the first frame?

[DaleCurtis, 2016/05/24 22:58:24]

Done. Also fixed this such that it will also consider the start timestamp. So
either we have two frames which straddle the start timestamp or the first frame
is >= the start timestamp.

+    // no more frames coming (sometimes unless we paint one of them).
+    if (algorithm_->frames_queued() > 1 || received_end_of_stream_ ||
+        low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) {
       scoped_refptr<VideoFrame> frame = algorithm_->first_frame();
       CheckForMetadataChanges(frame->format(), frame->natural_size());
       sink_->PaintSingleFrame(frame);
     }
   }
 
+  // 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. 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();
@@ skipping 254 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