Not for submission. fastSeek prototype.

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 <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/audio_renderer.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer_stream_provider.h"
 #include "media/base/media_switches.h"
 #include "media/base/renderer_client.h"
+#include "media/base/stream_position.h"
 #include "media/base/time_source.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_renderer.h"
 #include "media/base/wall_clock_time_source.h"
 
 namespace media {
 
 // See |video_underflow_threshold_|.
 static const int kDefaultVideoUnderflowThresholdMs = 3000;
 
 static const int kAudioRestartUnderflowThresholdMs = 2000;
 
 class RendererImpl::RendererClientInternal : public RendererClient {
  public:
   RendererClientInternal(DemuxerStream::Type type, RendererImpl* renderer)
       : type_(type), renderer_(renderer) {
     DCHECK((type_ == DemuxerStream::AUDIO) || (type_ == DemuxerStream::VIDEO));
   }
 
   void OnError(PipelineStatus error) override { renderer_->OnError(error); }
   void OnEnded() override { renderer_->OnRendererEnded(type_); }
   void OnStatisticsUpdate(const PipelineStatistics& stats) override {
     renderer_->OnStatisticsUpdate(stats);
   }
+  void OnFirstVideoFrameTimestampKnown(base::TimeDelta timestamp) override {
+    renderer_->OnFirstVideoFrameTimestampKnown(timestamp);
+  }
   void OnBufferingStateChange(BufferingState state) override {
     renderer_->OnBufferingStateChange(type_, state);
   }
   void OnWaitingForDecryptionKey() override {
     renderer_->OnWaitingForDecryptionKey();
   }
   void OnVideoNaturalSizeChange(const gfx::Size& size) override {
     DCHECK(type_ == DemuxerStream::VIDEO);
     renderer_->OnVideoNaturalSizeChange(size);
   }
@@ skipping 140 matching lines @@
 
   flush_cb_ = flush_cb;
   state_ = STATE_FLUSHING;
 
   if (time_ticking_)
     PausePlayback();
 
   FlushAudioRenderer();
 }
 
-void RendererImpl::StartPlayingFrom(base::TimeDelta time) {
+void RendererImpl::StartPlayingFrom(StreamPosition position) {
   DVLOG(1) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != STATE_PLAYING) {
     DCHECK_EQ(state_, STATE_ERROR);
     return;
   }
 
-  time_source_->SetMediaTime(time);
+  time_source_->SetMediaTime(position.time);
 
+  // XXX: There's no synchronization b/w the renderers. Is it safe to assume the
+  // demuxers will give us frames close enough to one another? If not we could
+  // start the video renderer, wait until we know the time of the first frame,
+  // and then start the audio renderer.
   if (audio_renderer_)
-    audio_renderer_->StartPlaying();
+    audio_renderer_->StartPlayingFrom(position);
   if (video_renderer_)
-    video_renderer_->StartPlayingFrom(time);
+    video_renderer_->StartPlayingFrom(position);
 }
 
 void RendererImpl::RestartStreamPlayback(DemuxerStream* stream,
                                          bool enabled,
                                          base::TimeDelta time) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(stream);
   bool video = (stream->type() == DemuxerStream::VIDEO);
   DVLOG(1) << __func__ << (video ? " video" : " audio") << " stream=" << stream
            << " enabled=" << stream->enabled() << " time=" << time.InSecondsF();
@@ skipping 23 matching lines @@
         base::Bind(&RendererImpl::RestartAudioRenderer, weak_this_, time));
   }
 }
 
 void RendererImpl::RestartVideoRenderer(base::TimeDelta time) {
   DVLOG(3) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(video_renderer_);
   DCHECK_EQ(state_, STATE_PLAYING);
   video_ended_ = false;
-  video_renderer_->StartPlayingFrom(time);
+  // XXX: Converted without thought.
+  video_renderer_->StartPlayingFrom(StreamPosition::Precise(time));
 }
 
 void RendererImpl::RestartAudioRenderer(base::TimeDelta time) {
   DVLOG(3) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, STATE_PLAYING);
   DCHECK(time_source_);
   DCHECK(audio_renderer_);
   audio_ended_ = false;
-  audio_renderer_->StartPlaying();
+  // XXX: Converted without thought.
+  audio_renderer_->StartPlayingFrom(StreamPosition::Precise(time));
 }
 
 void RendererImpl::SetPlaybackRate(double playback_rate) {
   DVLOG(1) << __func__ << "(" << playback_rate << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Playback rate changes are only carried out while playing.
   if (state_ != STATE_PLAYING)
     return;
 
@@ skipping 50 matching lines @@
       << "Underflow must be disabled for clockless video playback";
 
   clockless_video_playback_enabled_for_testing_ = true;
 }
 
 bool RendererImpl::GetWallClockTimes(
     const std::vector<base::TimeDelta>& media_timestamps,
     std::vector<base::TimeTicks>* wall_clock_times) {
   // 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_) {
     if (media_timestamps.empty()) {
       *wall_clock_times = std::vector<base::TimeTicks>(1,
                                                        base::TimeTicks::Now());
     } else {
       *wall_clock_times = std::vector<base::TimeTicks>();
       for (auto const &media_time : media_timestamps) {
         wall_clock_times->push_back(base::TimeTicks() + media_time);
       }
     }
@@ skipping 196 matching lines @@
   video_ended_ = false;
   state_ = STATE_PLAYING;
   base::ResetAndReturn(&flush_cb_).Run();
 }
 
 void RendererImpl::OnStatisticsUpdate(const PipelineStatistics& stats) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnStatisticsUpdate(stats);
 }
 
+// XXX: Revisit: I don't really like this. I considered letting the video
+// renderer own the wall clock time source and manage this itself, but it didn't
+// work for some reason. Try again.
+void RendererImpl::OnFirstVideoFrameTimestampKnown(base::TimeDelta timestamp) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  LOG(ERROR) << __func__ << " " << timestamp.InMicroseconds();
+  if (wall_clock_time_source_)
+    wall_clock_time_source_->SetMediaTime(timestamp);
+}
+
 namespace {
 
 const char* BufferingStateStr(BufferingState state) {
   switch (state) {
     case BUFFERING_HAVE_NOTHING:
       return "HAVE_NOTHING";
     case BUFFERING_HAVE_ENOUGH:
       return "HAVE_ENOUGH";
   }
   NOTREACHED();
@@ skipping 274 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoNaturalSizeChange(size);
 }
 
 void RendererImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   client_->OnVideoOpacityChange(opaque);
 }
 
 }  // namespace media