Change the TimeSource interface to return wallclock time for video.

media/renderers/renderer_impl.cc

 // Copyright 2014 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/renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
@@ skipping 184 matching lines @@
 void RendererImpl::EnableClocklessVideoPlaybackForTesting() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   DCHECK(underflow_disabled_for_testing_)
       << "Underflow must be disabled for clockless video playback";
 
   clockless_video_playback_enabled_for_testing_ = true;
 }
 
-base::TimeDelta RendererImpl::GetMediaTimeForSyncingVideo() {
+base::TimeTicks RendererImpl::GetWallclockTimeForMediaTime(
+    base::TimeDelta time) {
   // No BelongsToCurrentThread() checking because this can be called from other
   // threads.
   //
   // TODO(scherkus): Currently called from VideoRendererImpl's internal thread,
   // which should go away at some point http://crbug.com/110814
   if (clockless_video_playback_enabled_for_testing_)
-    return base::TimeDelta::Max();
+    return base::TimeTicks::Now();
 
-  return time_source_->CurrentMediaTimeForSyncingVideo();
+  return time_source_->GetWallclockTimeForMediaTime(time);
 }
 
 void RendererImpl::SetDecryptorReadyCallback(
     const DecryptorReadyCB& decryptor_ready_cb) {
   // Cancels the previous decryptor request.
   if (decryptor_ready_cb.is_null()) {
     if (!decryptor_ready_cb_.is_null()) {
       base::ResetAndReturn(&decryptor_ready_cb_)
           .Run(nullptr, base::Bind(IgnoreCdmAttached));
     }
@@ skipping 78 matching lines @@
 
   video_renderer_->Initialize(
       demuxer_stream_provider_->GetStream(DemuxerStream::VIDEO), done_cb,
       base::Bind(&RendererImpl::SetDecryptorReadyCallback, weak_this_),
       base::Bind(&RendererImpl::OnUpdateStatistics, weak_this_),
       base::Bind(&RendererImpl::OnBufferingStateChanged, weak_this_,
                  &video_buffering_state_),
       base::ResetAndReturn(&paint_cb_),
       base::Bind(&RendererImpl::OnVideoRendererEnded, weak_this_),
       base::Bind(&RendererImpl::OnError, weak_this_),
-      base::Bind(&RendererImpl::GetMediaTimeForSyncingVideo,
+      base::Bind(&RendererImpl::GetWallclockTimeForMediaTime,
                  base::Unretained(this)),
       waiting_for_decryption_key_cb_);
 }
 
 void RendererImpl::OnVideoRendererInitializeDone(PipelineStatus status) {
   DVLOG(1) << __FUNCTION__ << ": " << status;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // OnError() may be fired at any time by the renderers, even if they thought
   // they initialized successfully (due to delayed output device setup).
@@ skipping 125 matching lines @@
     StartPlayback();
     buffering_state_cb_.Run(BUFFERING_HAVE_ENOUGH);
     return;
   }
 }
 
 bool RendererImpl::WaitingForEnoughData() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != STATE_PLAYING)
     return false;
+  // If playback has started and we have both an audio and video renderer,
+  // prefer the buffering state of the audio renderer.
+  if (time_ticking_ && audio_renderer_ && video_renderer_ &&
+      audio_buffering_state_ == BUFFERING_HAVE_ENOUGH) {
+    return false;
+  }

[xhwang, 2015/03/23 22:20:14]

So for a audio/video content, if the video is way way behind, we will still not
trigger underflow. Is this expected?

[DaleCurtis, 2015/03/25 00:31:45]

Correct, though in a meeting yesterday strobe@ brought up the desire to  run a
finch experiment on the "time to declare have nothing" value. +strobe to get his
thoughts on this change.

[xhwang, 2015/03/25 04:10:50]

I can think of some corner cases where we want to rebuffer when video lag
behind. For example, video decoding speed can just keep up with the speed of
playback. Then for some reason CPU gets busy and video decoding starts to fall
behind. If we don't rebuffer, it'll take long (or forever in the theoretical
case) for video to catch up. If we can declare have nothing and rebuffer, we can
easily recover. It sounds a good idea to  design some finch experiment to
measure the performance in both cases....

[DaleCurtis, 2015/03/26 18:32:56]

Actually it turns out I misunderstood the code here, this is now a pure
mechanical change, we'll continue to use media time for determining underflow.

That said, per our discussions yesterday, we're okay with using wallclock time
for underflow, so I'll upload a separate CL which resolves
http://crbug.com/423801 and moves us to using wallclock time within the
RendererImpl.

   if (audio_renderer_ && audio_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   if (video_renderer_ && video_buffering_state_ != BUFFERING_HAVE_ENOUGH)
     return true;
   return false;
 }
 
 void RendererImpl::PausePlayback() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 103 matching lines @@
   }
 
   // After OnError() returns, the pipeline may destroy |this|.
   base::ResetAndReturn(&error_cb_).Run(error);
 
   if (!flush_cb_.is_null())
     base::ResetAndReturn(&flush_cb_).Run();
 }
 
 }  // namespace media