Not for submission. fastSeek prototype.

media/renderers/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/renderers/video_renderer_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/renderer_client.h"
+#include "media/base/stream_position.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 namespace media {
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     VideoRendererSink* sink,
@@ skipping 10 matching lines @@
                                                media_log)),
       gpu_memory_buffer_pool_(nullptr),
       media_log_(media_log),
       low_delay_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       state_(kUninitialized),
       pending_read_(false),
       drop_frames_(drop_frames),
       buffering_state_(BUFFERING_HAVE_NOTHING),
+      start_rendering_from_first_frame_(false),
       frames_decoded_(0),
       frames_dropped_(0),
       tick_clock_(new base::DefaultTickClock()),
       was_background_rendering_(false),
       time_progressing_(false),
       last_video_memory_usage_(0),
       have_renderered_frames_(false),
       last_frame_opaque_(false),
       weak_factory_(this),
       frame_callback_weak_factory_(this) {
@@ skipping 45 matching lines @@
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
                  weak_factory_.GetWeakPtr()));
 
   // To avoid unnecessary work by VDAs, only delete queued frames after
   // resetting |video_frame_stream_|. If this is done in the opposite order VDAs
   // will get a bunch of ReusePictureBuffer() calls before the Reset(), which
   // they may use to output more frames that won't be used.
   algorithm_->Reset();
 }
 
-void VideoRendererImpl::StartPlayingFrom(base::TimeDelta timestamp) {
-  DVLOG(1) << __func__ << "(" << timestamp.InMicroseconds() << ")";
+void VideoRendererImpl::StartPlayingFrom(StreamPosition position) {
+  DVLOG(1) << __func__ << "(" << ToString(position) << ")";
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kFlushed);
   DCHECK(!pending_read_);
   DCHECK_EQ(buffering_state_, BUFFERING_HAVE_NOTHING);
 
   state_ = kPlaying;
-  start_timestamp_ = timestamp;
+  start_timestamp_ = position.time;
+  start_rendering_from_first_frame_ =
+      position.kind == StreamPosition::Kind::KEY_FRAME_PRECEDING_TIME;
   AttemptRead_Locked();
 }
 
 void VideoRendererImpl::Initialize(
     DemuxerStream* stream,
     CdmContext* cdm_context,
     RendererClient* client,
     const TimeSource::WallClockTimeCB& wall_clock_time_cb,
     const PipelineStatusCB& init_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ skipping 91 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kInitializing);
 
   if (!success) {
     state_ = kUninitialized;
     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  // We're all good!  Consider ourselves flushed. (ThreadMain() should never
-  // see us in the kUninitialized state).
-  // Since we had an initial Preroll(), we consider ourself flushed, because we
-  // have not populated any buffers yet.
+  // We're all good! Consider ourselves flushed because we have not populated
+  // any buffers yet.
   state_ = kFlushed;
 
   algorithm_.reset(new VideoRendererAlgorithm(wall_clock_time_cb_));
   if (!drop_frames_)
     algorithm_->disable_frame_dropping();
 
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
 }
 
 void VideoRendererImpl::OnPlaybackError(PipelineStatus error) {
@@ skipping 103 matching lines @@
 
   // Can happen when demuxers are preparing for a new Seek().
   if (!frame) {
     DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
     return;
   }
 
   if (frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM)) {
     DCHECK(!received_end_of_stream_);
     received_end_of_stream_ = true;
+  } else if (start_rendering_from_first_frame_) {
+    start_timestamp_ = frame->timestamp();
+    start_rendering_from_first_frame_ = false;
+    client_->OnFirstVideoFrameTimestampKnown(frame->timestamp());
+    AddReadyFrame_Locked(frame);
   } else if ((low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) &&
              IsBeforeStartTime(frame->timestamp())) {
     // Don't accumulate frames that are earlier than the start time if we
     // won't have a chance for a better frame, otherwise we could declare
     // HAVE_ENOUGH_DATA and start playback prematurely.
     AttemptRead_Locked();
     return;
   } else {
     // If the sink hasn't been started, we still have time to release less
     // than ideal frames prior to startup.  We don't use IsBeforeStartTime()
     // here since it's based on a duration estimate and we can be exact here.
-    if (!sink_started_ && frame->timestamp() <= start_timestamp_)
+    if (!sink_started_ && frame->timestamp() <= start_timestamp_) {
       algorithm_->Reset();
+    }
 
     AddReadyFrame_Locked(frame);
   }
 
   // Attempt to purge bad frames in case of underflow or backgrounding.
   RemoveFramesForUnderflowOrBackgroundRendering();
 
   // We may have removed all frames above and have reached end of stream.
   MaybeFireEndedCallback_Locked(time_progressing_);
 
   // Update statistics here instead of during Render() when the sink is stopped.
   if (!sink_started_)
     UpdateStats_Locked();
 
   // Paint the first frame if possible and necessary. PaintSingleFrame() will
   // ignore repeated calls for the same frame. Paint ahead of HAVE_ENOUGH_DATA
   // to ensure the user sees the frame as early as possible.
   if (!sink_started_ && algorithm_->frames_queued()) {
     // We want to paint the first frame under two conditions: Either (1) we have
     // enough frames to know it's definitely the first frame or (2) there may be
     // no more frames coming (sometimes unless we paint one of them).
     //
-    // For the first condition, we need at least two frames or the first frame
-    // must have a timestamp >= |start_timestamp_|, since otherwise we may be
-    // prerolling frames before the actual start time that will be dropped.
     if (algorithm_->frames_queued() > 1 || received_end_of_stream_ ||
         algorithm_->first_frame()->timestamp() >= start_timestamp_ ||
         low_delay_ || !video_frame_stream_->CanReadWithoutStalling()) {
       scoped_refptr<VideoFrame> frame = algorithm_->first_frame();
       CheckForMetadataChanges(frame->format(), frame->natural_size());
       sink_->PaintSingleFrame(frame);
     }
   }
 
   // Signal buffering state if we've met our conditions.
   if (buffering_state_ == BUFFERING_HAVE_NOTHING && HaveEnoughData_Locked())
     TransitionToHaveEnough_Locked();
 
-  // Always request more decoded video if we have capacity. This serves two
-  // purposes:
-  //   1) Prerolling while paused
-  //   2) Keeps decoding going if video rendering thread starts falling behind
+  // Always request more decoded video if we have capacity.
   AttemptRead_Locked();
 }
 
 bool VideoRendererImpl::HaveEnoughData_Locked() {
   DCHECK_EQ(state_, kPlaying);
   lock_.AssertAcquired();
 
   if (received_end_of_stream_)
     return true;
 
@@ skipping 184 matching lines @@
   return wall_clock_times[0];
 }
 
 base::TimeTicks VideoRendererImpl::GetCurrentMediaTimeAsWallClockTime() {
   std::vector<base::TimeTicks> current_time;
   wall_clock_time_cb_.Run(std::vector<base::TimeDelta>(), &current_time);
   return current_time[0];
 }
 
 bool VideoRendererImpl::IsBeforeStartTime(base::TimeDelta timestamp) {
+  if (start_rendering_from_first_frame_)
+    return false;
   return timestamp + video_frame_stream_->AverageDuration() < start_timestamp_;
 }
 
 void VideoRendererImpl::RemoveFramesForUnderflowOrBackgroundRendering() {
   // Nothing to do if we're not underflowing, background rendering, or frame
   // dropping is disabled (test only).
   const bool have_nothing = buffering_state_ == BUFFERING_HAVE_NOTHING;
   if (!was_background_rendering_ && !have_nothing && !drop_frames_)
     return;
 
@@ skipping 62 matching lines @@
 
 void VideoRendererImpl::AttemptReadAndCheckForMetadataChanges(
     VideoPixelFormat pixel_format,
     const gfx::Size& natural_size) {
   base::AutoLock auto_lock(lock_);
   CheckForMetadataChanges(pixel_format, natural_size);
   AttemptRead_Locked();
 }
 
 }  // namespace media