VideoRendererImpl: Delay report of BUFFERING_HAVE_NOTHING.

media/filters/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/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 21 matching lines @@
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
       paint_cb_(paint_cb),
       last_timestamp_(kNoTimestamp()),
+      last_painted_timestamp_(kNoTimestamp()),
       frames_decoded_(0),
       frames_dropped_(0),
       is_shutting_down_(false),
       weak_factory_(this) {
   DCHECK(!paint_cb_.is_null());
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
@@ skipping 125 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.
   //
   // TODO(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);
 
+  // If we have no frames and haven't painted any frame for certain amount of
+  // time, declare BUFFERING_HAVE_NOTHING.
+  const base::TimeDelta kTimeToDeclareHaveNothing =
+      base::TimeDelta::FromSeconds(3);
+
   for (;;) {
     base::AutoLock auto_lock(lock_);
 
     // Thread exit condition.
     if (is_shutting_down_)
       return;
 
     // Remain idle as long as we're not playing.
     if (state_ != kPlaying || buffering_state_ != BUFFERING_HAVE_ENOUGH) {
       UpdateStatsAndWait_Locked(kIdleTimeDelta);
       continue;
     }
 
+    base::TimeDelta now = get_time_cb_.Run();

[scherkus (not reviewing), 2014/08/22 01:40:59]

did we mean to use *media* time instead of wall clock time?

if so ... I think we've made it impossible for that condition to evaluate to
true in the video-only case since media time is controlled via running
max_time_cb_ inside this class.

we might need to have a quick pow-wow with everyone in the office on Friday --
my brain is hurting thinking about these edge cases.

+
     // Remain idle until we have the next frame ready for rendering.
     if (ready_frames_.empty()) {
       if (received_end_of_stream_) {
         if (!rendered_end_of_stream_) {
           rendered_end_of_stream_ = true;
           task_runner_->PostTask(FROM_HERE, ended_cb_);
         }
-      } else {
+      } else if (last_painted_timestamp_ != kNoTimestamp() &&
+                 now - last_painted_timestamp_ >= kTimeToDeclareHaveNothing) {
         buffering_state_ = BUFFERING_HAVE_NOTHING;
         task_runner_->PostTask(
             FROM_HERE, base::Bind(buffering_state_cb_, BUFFERING_HAVE_NOTHING));
       }
 
       UpdateStatsAndWait_Locked(kIdleTimeDelta);
       continue;
     }
 
-    base::TimeDelta now = get_time_cb_.Run();
     base::TimeDelta target_paint_timestamp = ready_frames_.front()->timestamp();
     base::TimeDelta latest_paint_timestamp;
 
     // Deadline is defined as the duration between this frame and the next
     // frame, using the delta between this frame and the previous frame as the
     // assumption for frame duration.
     //
     // TODO(scherkus): This can be vastly improved. Use a histogram to measure
     // the accuracy of our frame timing code. http://crbug.com/149829
     if (last_timestamp_ == kNoTimestamp()) {
@@ skipping 23 matching lines @@
 }
 
 void VideoRendererImpl::PaintNextReadyFrame_Locked() {
   lock_.AssertAcquired();
 
   scoped_refptr<VideoFrame> next_frame = ready_frames_.front();
   ready_frames_.pop_front();
   frames_decoded_++;
 
   last_timestamp_ = next_frame->timestamp();
+  last_painted_timestamp_ = next_frame->timestamp();
 
   paint_cb_.Run(next_frame);
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::DropNextReadyFrame_Locked() {
   TRACE_EVENT0("media", "VideoRendererImpl:frameDropped");
@@ skipping 165 matching lines @@
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(kFlushing, state_);
   DCHECK(!pending_read_);
   DCHECK(ready_frames_.empty());
   DCHECK(!received_end_of_stream_);
   DCHECK(!rendered_end_of_stream_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kFlushed;
   last_timestamp_ = kNoTimestamp();
+  last_painted_timestamp_ = kNoTimestamp();
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void VideoRendererImpl::UpdateStatsAndWait_Locked(
     base::TimeDelta wait_duration) {
   lock_.AssertAcquired();
   DCHECK_GE(frames_decoded_, 0);
   DCHECK_LE(frames_dropped_, frames_decoded_);
 
   if (frames_decoded_) {
     PipelineStatistics statistics;
     statistics.video_frames_decoded = frames_decoded_;
     statistics.video_frames_dropped = frames_dropped_;
     task_runner_->PostTask(FROM_HERE, base::Bind(statistics_cb_, statistics));
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media