Not for submission. fastSeek prototype.

media/base/pipeline_impl.cc

Index: media/base/pipeline_impl.cc
diff --git a/media/base/pipeline_impl.cc b/media/base/pipeline_impl.cc
index 7eb522b67b73106d8f09fb1da642307d4fa1fcfd..488ea56c81e2d57c6572458bfe1714937be4d112 100644
--- a/media/base/pipeline_impl.cc
+++ b/media/base/pipeline_impl.cc
@@ -24,6 +24,7 @@
 #include "media/base/renderer.h"
 #include "media/base/renderer_client.h"
 #include "media/base/serial_runner.h"
+#include "media/base/stream_position.h"
 #include "media/base/text_renderer.h"
 #include "media/base/text_track_config.h"
 #include "media/base/timestamp_constants.h"
@@ -46,7 +47,7 @@ class PipelineImpl::RendererWrapper : public DemuxerHost,
              std::unique_ptr<TextRenderer> text_renderer,
              base::WeakPtr<PipelineImpl> weak_pipeline);
   void Stop(const base::Closure& stop_cb);
-  void Seek(base::TimeDelta time);
+  void Seek(StreamPosition position);
   void Suspend();
   void Resume(std::unique_ptr<Renderer> renderer, base::TimeDelta time);
   void SetPlaybackRate(double playback_rate);
@@ -109,6 +110,7 @@ class PipelineImpl::RendererWrapper : public DemuxerHost,
   void OnError(PipelineStatus error) final;
   void OnEnded() final;
   void OnStatisticsUpdate(const PipelineStatistics& stats) final;
+  void OnFirstVideoFrameTimestampKnown(base::TimeDelta timestamp) final;
   void OnBufferingStateChange(BufferingState state) final;
   void OnWaitingForDecryptionKey() final;
   void OnVideoNaturalSizeChange(const gfx::Size& size) final;
@@ -130,7 +132,7 @@ class PipelineImpl::RendererWrapper : public DemuxerHost,
 
   // State transition tasks.
   void SetState(State next_state);
-  void CompleteSeek(base::TimeDelta seek_time, PipelineStatus status);
+  void CompleteSeek(StreamPosition position, PipelineStatus status);
   void CompleteSuspend(PipelineStatus status);
   void InitializeDemuxer(const PipelineStatusCB& done_cb);
   void InitializeRenderer(const PipelineStatusCB& done_cb);
@@ -249,9 +251,9 @@ void PipelineImpl::RendererWrapper::Start(
   fns.Push(base::Bind(&RendererWrapper::InitializeRenderer, weak_this_));
 
   // Run tasks.
-  pending_callbacks_ =
-      SerialRunner::Run(fns, base::Bind(&RendererWrapper::CompleteSeek,
-                                        weak_this_, base::TimeDelta()));
+  pending_callbacks_ = SerialRunner::Run(
+      fns, base::Bind(&RendererWrapper::CompleteSeek, weak_this_,
+                      StreamPosition::Precise(base::TimeDelta())));
 }
 
 void PipelineImpl::RendererWrapper::Stop(const base::Closure& stop_cb) {
@@ -290,7 +292,7 @@ void PipelineImpl::RendererWrapper::Stop(const base::Closure& stop_cb) {
   media_task_runner_->PostTask(FROM_HERE, stop_cb);
 }
 
-void PipelineImpl::RendererWrapper::Seek(base::TimeDelta time) {
+void PipelineImpl::RendererWrapper::Seek(StreamPosition position) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress seeking if we're not fully started.
@@ -301,7 +303,7 @@ void PipelineImpl::RendererWrapper::Seek(base::TimeDelta time) {
     return;
   }
 
-  base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
+  position.time = std::max(position.time, demuxer_->GetStartTime());
 
   SetState(kSeeking);
   renderer_ended_ = false;
@@ -332,12 +334,12 @@ void PipelineImpl::RendererWrapper::Seek(base::TimeDelta time) {
 
   // Seek demuxer.
   bound_fns.Push(
-      base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
+      base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), position.time));
 
   // Run tasks.
   pending_callbacks_ = SerialRunner::Run(
       bound_fns,
-      base::Bind(&RendererWrapper::CompleteSeek, weak_this_, seek_timestamp));
+      base::Bind(&RendererWrapper::CompleteSeek, weak_this_, position));
 }
 
 void PipelineImpl::RendererWrapper::Suspend() {
@@ -410,9 +412,10 @@ void PipelineImpl::RendererWrapper::Resume(std::unique_ptr<Renderer> renderer,
 
   fns.Push(base::Bind(&RendererWrapper::InitializeRenderer, weak_this_));
 
+  // XXX: Revisit.
   pending_callbacks_ = SerialRunner::Run(
-      fns,
-      base::Bind(&RendererWrapper::CompleteSeek, weak_this_, start_timestamp));
+      fns, base::Bind(&RendererWrapper::CompleteSeek, weak_this_,
+                      StreamPosition::Precise(timestamp)));
 }
 
 void PipelineImpl::RendererWrapper::SetPlaybackRate(double playback_rate) {
@@ -607,7 +610,6 @@ void PipelineImpl::RendererWrapper::OnSelectedVideoTrackChanged(
 
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
-  DVLOG(3) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
@@ -619,6 +621,9 @@ void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
   shared_state_.statistics.video_memory_usage += stats.video_memory_usage;
 }
 
+void PipelineImpl::RendererWrapper::OnFirstVideoFrameTimestampKnown(
+    base::TimeDelta timestamp) {}
+
 void PipelineImpl::RendererWrapper::OnBufferingStateChange(
     BufferingState state) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
@@ -748,7 +753,7 @@ void PipelineImpl::RendererWrapper::SetState(State next_state) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(next_state));
 }
 
-void PipelineImpl::RendererWrapper::CompleteSeek(base::TimeDelta seek_time,
+void PipelineImpl::RendererWrapper::CompleteSeek(StreamPosition position,
                                                  PipelineStatus status) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kStarting || state_ == kSeeking || state_ == kResuming);
@@ -761,8 +766,9 @@ void PipelineImpl::RendererWrapper::CompleteSeek(base::TimeDelta seek_time,
     return;
   }
 
-  shared_state_.renderer->StartPlayingFrom(
-      std::max(seek_time, demuxer_->GetStartTime()));
+  position.time = std::max(position.time, demuxer_->GetStartTime());
+  shared_state_.renderer->StartPlayingFrom(position);
+
   {
     base::AutoLock auto_lock(shared_state_lock_);
     shared_state_.suspend_timestamp = kNoTimestamp;
@@ -972,8 +978,9 @@ void PipelineImpl::Stop() {
   weak_factory_.InvalidateWeakPtrs();
 }
 
-void PipelineImpl::Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb) {
-  DVLOG(2) << __func__ << " to " << time.InMicroseconds();
+void PipelineImpl::Seek(StreamPosition position,
+                        const PipelineStatusCB& seek_cb) {
+  DVLOG(2) << __func__ << "(" << ToString(position) << ")";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!seek_cb.is_null());
 
@@ -986,8 +993,9 @@ void PipelineImpl::Seek(base::TimeDelta time, const PipelineStatusCB& seek_cb) {
   seek_cb_ = seek_cb;
   last_media_time_ = base::TimeDelta();
   media_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RendererWrapper::Seek,
-                            base::Unretained(renderer_wrapper_.get()), time));
+      FROM_HERE,
+      base::Bind(&RendererWrapper::Seek,
+                 base::Unretained(renderer_wrapper_.get()), position));
 }
 
 void PipelineImpl::Suspend(const PipelineStatusCB& suspend_cb) {
@@ -1076,11 +1084,15 @@ base::TimeDelta PipelineImpl::GetMediaTime() const {
   //
   // It is expected that such events are transient and will be recovered as
   // rendering continues over time.
+
+  // XXX: Revisit. Do we even need this logic?
+  /*
   if (media_time < last_media_time_) {
     DVLOG(2) << __func__ << ": actual=" << media_time
              << " clamped=" << last_media_time_;
     return last_media_time_;
   }
+  */
 
   DVLOG(3) << __FUNCTION__ << ": " << media_time.InMilliseconds() << " ms";
   last_media_time_ = media_time;