Fix underflow and av/sync issues in low delay and stall presence.

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 285 matching lines @@
   if (sink_started_ == time_progressing_)
     return;
 
   if (time_progressing_) {
     // If only an EOS frame came in after a seek, the renderer may not have
     // received the ended event yet though we've posted it.
     if (!rendered_end_of_stream_)
       StartSink();
   } else {
     StopSink();
+
+    // Make sure we expire everything we can if we can't read anymore currently,
+    // otherwise playback may hang indefinitely.  Note: There are no effective
+    // frames queued at this point, otherwise FrameReady() would have canceled
+    // the underflow state before reaching this point.
+    if (buffering_state_ == BUFFERING_HAVE_NOTHING)
+      RemoveFramesForUnderflowOrBackgroundRendering();
   }
 }
 
 void VideoRendererImpl::FrameReadyForCopyingToGpuMemoryBuffers(
     VideoFrameStream::Status status,
     const scoped_refptr<VideoFrame>& frame) {
   if (status != VideoFrameStream::OK || IsBeforeStartTime(frame->timestamp())) {
     VideoRendererImpl::FrameReady(sequence_token_, status, frame);
     return;
   }
@@ skipping 59 matching lines @@
     } 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);
     }
 
-    // Background rendering updates may not be ticking fast enough by itself to
-    // remove expired frames, so give it a boost here by ensuring we don't exit
-    // the decoding cycle too early.
-    //
-    // Similarly, if we've paused for underflow, remove all frames which are
-    // before the current media time.
-    //
-    // If we're paused for prerolling (current time is 0), don't expire any
-    // frames. It's possible that during preroll |have_nothing_and_paused| is
-    // false while |was_background_rendering_| is true. We differentiate this
-    // from actual background rendering by checking if current time is 0.
-    const bool have_nothing = buffering_state_ != BUFFERING_HAVE_ENOUGH;
-    const bool have_nothing_and_paused = have_nothing && !sink_started_;
-    if (was_background_rendering_ ||
-        (have_nothing_and_paused && drop_frames_)) {
-      base::TimeTicks current_time = GetCurrentMediaTimeAsWallClockTime();
-      if (!current_time.is_null()) {
-        if (have_nothing_and_paused) {
-          // Use the current media wall clock time plus the frame duration since
-          // RemoveExpiredFrames() is expecting the end point of an interval (it
-          // will subtract from the given value).
-          frames_dropped_ += algorithm_->RemoveExpiredFrames(
-              current_time + algorithm_->average_frame_duration());
-        } else {
-          // Don't count dropped frames when background rendering.
-          algorithm_->RemoveExpiredFrames(tick_clock_->NowTicks());
-        }
-      }
-    }
+    // Attempt to purge bad frames in case of underflow or backgrounding.
+    RemoveFramesForUnderflowOrBackgroundRendering();
 
-    // Signal buffering state if we've met our conditions for having enough
-    // data.
-    if (have_nothing && HaveEnoughData_Locked()) {
+    // 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_) {
+      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 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();
   }
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
+  lock_.AssertAcquired();
 
-  if (received_end_of_stream_ || !video_frame_stream_->CanReadWithoutStalling())
+  if (received_end_of_stream_)
     return true;
 
   if (HaveReachedBufferingCap())
     return true;
 
-  if (was_background_rendering_ && frames_decoded_) {
+  if (was_background_rendering_ && frames_decoded_)
     return true;
-  }
 
-  if (!low_delay_)
+  if (!low_delay_ && video_frame_stream_->CanReadWithoutStalling())
     return false;
 
-  return algorithm_->frames_queued() > 0;
+  return algorithm_->effective_frames_queued() > 0;
 }
 
 void VideoRendererImpl::TransitionToHaveEnough_Locked() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
+  lock_.AssertAcquired();
 
   buffering_state_ = BUFFERING_HAVE_ENOUGH;
   buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
 }
 
 void VideoRendererImpl::TransitionToHaveNothing() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
   if (buffering_state_ != BUFFERING_HAVE_ENOUGH || HaveEnoughData_Locked())
@@ skipping 158 matching lines @@
 base::TimeTicks VideoRendererImpl::GetCurrentMediaTimeAsWallClockTime() {
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
+void VideoRendererImpl::RemoveFramesForUnderflowOrBackgroundRendering() {
+  // Nothing to do if we're not underflowing, background rendering, or frame
+  // dropping is disabled (test only).
+  const bool have_nothing = buffering_state_ == BUFFERING_HAVE_NOTHING;
+  if (!was_background_rendering_ && !have_nothing && !drop_frames_)
+    return;
+
+  // If there are no frames to remove, nothing can be done.
+  if (!algorithm_->frames_queued())
+    return;
+
+  // If we're paused for prerolling (current time is 0), don't expire any
+  // frames. It's possible that during preroll |have_nothing| is false while
+  // |was_background_rendering_| is true. We differentiate this from actual
+  // background rendering by checking if current time is 0.
+  const base::TimeTicks current_time = GetCurrentMediaTimeAsWallClockTime();
+  if (current_time.is_null())
+    return;
+
+  // Background rendering updates may not be ticking fast enough to remove
+  // expired frames, so provide a boost here by ensuring we don't exit the
+  // decoding cycle too early. Dropped frames are not counted in this case.
+  if (was_background_rendering_) {
+    algorithm_->RemoveExpiredFrames(tick_clock_->NowTicks());
+    return;
+  }
+
+  // Use the current media wall clock time plus the frame duration since
+  // RemoveExpiredFrames() is expecting the end point of an interval (it will
+  // subtract from the given value). It's important to always call this so
+  // that frame statistics are updated correctly.
+  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);
+  }
+}
+
 }  // namespace media