Not for submission. fastSeek prototype.

media/base/pipeline_impl.cc

 // Copyright (c) 2012 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/base/pipeline_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/demuxer.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #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"
 #include "media/base/video_decoder_config.h"
 
 static const double kDefaultPlaybackRate = 0.0;
 static const float kDefaultVolume = 1.0f;
 
 namespace media {
 
 class PipelineImpl::RendererWrapper : public DemuxerHost,
                                       public RendererClient {
  public:
   RendererWrapper(scoped_refptr<base::SingleThreadTaskRunner> media_task_runner,
                   scoped_refptr<MediaLog> media_log);
   ~RendererWrapper() final;
 
   void Start(Demuxer* demuxer,
              std::unique_ptr<Renderer> renderer,
              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);
   void SetVolume(float volume);
   base::TimeDelta GetMediaTime() const;
   Ranges<base::TimeDelta> GetBufferedTimeRanges() const;
   bool DidLoadingProgress();
   PipelineStatistics GetStatistics() const;
   void SetCdm(CdmContext* cdm_context, const CdmAttachedCB& cdm_attached_cb);
 
@@ skipping 42 matching lines @@
   void SetDuration(base::TimeDelta duration) final;
   void OnDemuxerError(PipelineStatus error) final;
   void AddTextStream(DemuxerStream* text_stream,
                      const TextTrackConfig& config) final;
   void RemoveTextStream(DemuxerStream* text_stream) final;
 
   // RendererClient implementation.
   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;
   void OnVideoOpacityChange(bool opaque) final;
   void OnDurationChange(base::TimeDelta duration) final;
 
   // TextRenderer tasks and notifications.
   void OnTextRendererEnded();
   void AddTextStreamTask(DemuxerStream* text_stream,
                          const TextTrackConfig& config);
   void RemoveTextStreamTask(DemuxerStream* text_stream);
 
   // Common handlers for notifications from renderers and demuxer.
   void OnPipelineError(PipelineStatus error);
   void OnCdmAttached(const CdmAttachedCB& cdm_attached_cb,
                      CdmContext* cdm_context,
                      bool success);
   void CheckPlaybackEnded();
 
   // 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);
   void DestroyRenderer();
   void ReportMetadata();
 
   const scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const scoped_refptr<MediaLog> media_log_;
 
@@ skipping 98 matching lines @@
   fns.Push(base::Bind(&RendererWrapper::InitializeDemuxer, weak_this_));
 
   // Once the demuxer is initialized successfully, media metadata must be
   // available - report the metadata to client.
   fns.Push(base::Bind(&RendererWrapper::ReportMetadata, weak_this_));
 
   // Initialize renderer.
   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) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(state_ != kStopping && state_ != kStopped);
 
   SetState(kStopping);
 
   if (shared_state_.statistics.video_frames_decoded > 0) {
     UMA_HISTOGRAM_COUNTS("Media.DroppedFrameCount",
@@ skipping 18 matching lines @@
 
   // Post the stop callback to enqueue it after the tasks that may have been
   // posted by Demuxer and Renderer during stopping. Note that in theory the
   // tasks posted by Demuxer/Renderer may post even more tasks that will get
   // enqueued after |stop_cb|. This may be problematic because Demuxer may
   // get destroyed as soon as |stop_cb| is run. In practice this is not a
   // problem, but ideally Demuxer should be destroyed on the media thread.
   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.
   if (state_ != kPlaying) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive seek in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
     return;
   }
 
-  base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
+  position.time = std::max(position.time, demuxer_->GetStartTime());
 
   SetState(kSeeking);
   renderer_ended_ = false;
   text_renderer_ended_ = false;
 
   // Queue asynchronous actions required to start.
   DCHECK(!pending_callbacks_);
   SerialRunner::Queue bound_fns;
 
   // Abort any reads the renderer may be blocked on.
@@ skipping 10 matching lines @@
   bound_fns.Push(base::Bind(&Renderer::Flush,
                             base::Unretained(shared_state_.renderer.get())));
 
   if (text_renderer_) {
     bound_fns.Push(base::Bind(&TextRenderer::Flush,
                               base::Unretained(text_renderer_.get())));
   }
 
   // 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() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   // Suppress suspending if we're not playing.
   if (state_ != kPlaying) {
     DCHECK(state_ == kStopping || state_ == kStopped)
         << "Receive suspend in unexpected state: " << state_;
     OnPipelineError(PIPELINE_ERROR_INVALID_STATE);
@@ skipping 52 matching lines @@
       std::max(timestamp, demuxer_->GetStartTime());
 
   // Queue the asynchronous actions required to start playback.
   SerialRunner::Queue fns;
 
   fns.Push(
       base::Bind(&Demuxer::Seek, base::Unretained(demuxer_), start_timestamp));
 
   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) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   playback_rate_ = playback_rate;
   if (state_ == kPlaying)
     shared_state_.renderer->SetPlaybackRate(playback_rate_);
 }
 
@@ skipping 174 matching lines @@
   DCHECK(shared_state_.renderer);
 
   base::TimeDelta currTime = (state_ == kPlaying)
                                  ? shared_state_.renderer->GetMediaTime()
                                  : demuxer_->GetStartTime();
   demuxer_->OnSelectedVideoTrackChanged(selectedTrackId, currTime);
 }
 
 void PipelineImpl::RendererWrapper::OnStatisticsUpdate(
     const PipelineStatistics& stats) {
-  DVLOG(3) << __func__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(shared_state_lock_);
   shared_state_.statistics.audio_bytes_decoded += stats.audio_bytes_decoded;
   shared_state_.statistics.video_bytes_decoded += stats.video_bytes_decoded;
   shared_state_.statistics.video_frames_decoded += stats.video_frames_decoded;
   shared_state_.statistics.video_frames_dropped += stats.video_frames_dropped;
   shared_state_.statistics.audio_memory_usage += stats.audio_memory_usage;
   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());
   DVLOG(2) << __func__ << "(" << state << ") ";
 
   main_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PipelineImpl::OnBufferingStateChange, weak_pipeline_, state));
 }
 
@@ skipping 109 matching lines @@
 
 void PipelineImpl::RendererWrapper::SetState(State next_state) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << PipelineImpl::GetStateString(state_) << " -> "
            << PipelineImpl::GetStateString(next_state);
 
   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);
 
   DCHECK(pending_callbacks_);
   pending_callbacks_.reset();
 
   if (status != PIPELINE_OK) {
     OnPipelineError(status);
     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;
   }
 
   if (text_renderer_)
     text_renderer_->StartPlaying();
 
   shared_state_.renderer->SetPlaybackRate(playback_rate_);
   shared_state_.renderer->SetVolume(volume_);
@@ skipping 189 matching lines @@
   // Reset all callbacks and client handle.
   seek_cb_.Reset();
   suspend_cb_.Reset();
   client_ = nullptr;
 
   // Invalidate self weak pointers effectively canceling all pending
   // notifications in the message queue.
   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());
 
   if (!IsRunning()) {
     DLOG(ERROR) << "Media pipeline isn't running. Ignoring Seek().";
     return;
   }
 
   DCHECK(seek_cb_.is_null());
   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) {
   DVLOG(2) << __func__;
   DCHECK(!suspend_cb.is_null());
 
   DCHECK(IsRunning());
   DCHECK(suspend_cb_.is_null());
   suspend_cb_ = suspend_cb;
 
@@ skipping 68 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::TimeDelta media_time = renderer_wrapper_->GetMediaTime();
 
   // Clamp current media time to the last reported value, this prevents higher
   // level clients from seeing time go backwards based on inaccurate or spurious
   // delay values reported to the AudioClock.
   //
   // 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;
   return last_media_time_;
 }
 
 Ranges<base::TimeDelta> PipelineImpl::GetBufferedTimeRanges() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return renderer_wrapper_->GetBufferedTimeRanges();
 }
@@ skipping 159 matching lines @@
 void PipelineImpl::OnSuspendDone() {
   DVLOG(3) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsRunning());
 
   DCHECK(!suspend_cb_.is_null());
   base::ResetAndReturn(&suspend_cb_).Run(PIPELINE_OK);
 }
 
 }  // namespace media