MediaCodecPlayer implementation (stage 4 - preroll)

media/base/android/media_codec_video_decoder.cc

 // Copyright 2015 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/android/media_codec_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/buffers.h"
 #include "media/base/demuxer_stream.h"
 
 namespace media {
 
 namespace {
 const int kDelayForStandAloneEOS = 2;  // milliseconds
 }
 
 MediaCodecVideoDecoder::MediaCodecVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const base::Closure& request_data_cb,
     const base::Closure& starvation_cb,
+    const base::Closure& preroll_done_cb,
     const base::Closure& stop_done_cb,
     const base::Closure& error_cb,
     const SetTimeCallback& update_current_time_cb,
     const VideoSizeChangedCallback& video_size_changed_cb,
     const base::Closure& codec_created_cb)
     : MediaCodecDecoder(media_task_runner,
                         request_data_cb,
                         starvation_cb,
+                        preroll_done_cb,
                         stop_done_cb,
                         error_cb,
                         "VideoDecoder"),
       update_current_time_cb_(update_current_time_cb),
       video_size_changed_cb_(video_size_changed_cb),
       codec_created_cb_(codec_created_cb) {
 }
 
 MediaCodecVideoDecoder::~MediaCodecVideoDecoder() {
   DVLOG(1) << "VideoDecoder::~VideoDecoder()";
@@ skipping 24 matching lines @@
   }
 }
 
 void MediaCodecVideoDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   MediaCodecDecoder::ReleaseDecoderResources();
   surface_ = gfx::ScopedJavaSurface();
+}
+
+void MediaCodecVideoDecoder::ReleaseMediaCodec() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  MediaCodecDecoder::ReleaseMediaCodec();
   delayed_buffers_.clear();
 }
 
 void MediaCodecVideoDecoder::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__
            << (surface.IsEmpty() ? " empty" : " non-empty");
 
   surface_ = surface.Pass();
@@ skipping 67 matching lines @@
     return kConfigFailure;
   }
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " succeeded";
 
   media_task_runner_->PostTask(FROM_HERE, codec_created_cb_);
 
   return kConfigOk;
 }
 
-void MediaCodecVideoDecoder::SynchronizePTSWithTime(
-    base::TimeDelta current_time) {
+void MediaCodecVideoDecoder::AssociateCurrentTimeWithPTS(base::TimeDelta pts) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   start_time_ticks_ = base::TimeTicks::Now();
-  start_pts_ = current_time;
-  last_seen_pts_ = current_time;
+  start_pts_ = pts;
+  last_seen_pts_ = pts;
+}
+
+void MediaCodecVideoDecoder::DissociatePTSFromTime() {
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  start_pts_ = last_seen_pts_ = kNoTimestamp();
 }
 
 void MediaCodecVideoDecoder::OnOutputFormatChanged() {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   gfx::Size prev_size = video_size_;
 
   // See b/18224769. The values reported from MediaCodecBridge::GetOutputFormat
   // correspond to the actual video frame size, but this is not necessarily the
   // size that should be output.
   video_size_ = configs_.video_size;
   if (video_size_ != prev_size) {
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(video_size_changed_cb_, video_size_));
   }
 }
 
 void MediaCodecVideoDecoder::Render(int buffer_index,
                                     size_t size,
-                                    bool render_output,
+                                    RenderMode render_mode,
                                     base::TimeDelta pts,
                                     bool eos_encountered) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" << pts
            << " index:" << buffer_index << " size:" << size
            << (eos_encountered ? " EOS" : "");
 
   // Normally EOS comes as a separate access unit that does not have data,
   // the corresponding |size| will be 0.
   if (!size && eos_encountered) {
     // Stand-alone EOS
     // Discard the PTS that comes with it and ensure it is released last.
     pts = last_seen_pts_ +
           base::TimeDelta::FromMilliseconds(kDelayForStandAloneEOS);
   } else {
     // Keep track of last seen PTS
     last_seen_pts_ = pts;
   }
 
-  if (!render_output) {
+  // For video we simplify the preroll operation and render the first frame
+  // after preroll during the preroll phase, i.e. without waiting for audio
+  // stream to finish prerolling.
+  const bool render_output = (render_mode != kRenderSkip);
+
+  if (!render_output || start_pts_ == kNoTimestamp()) {
     ReleaseOutputBuffer(buffer_index, pts, size, false, eos_encountered);
     return;
   }
 
   base::TimeDelta time_to_render =
       pts - (base::TimeTicks::Now() - start_time_ticks_ + start_pts_);
 
   if (time_to_render < base::TimeDelta()) {
     // Skip late frames
     ReleaseOutputBuffer(buffer_index, pts, size, false, eos_encountered);
     return;
   }
 
   delayed_buffers_.insert(buffer_index);
 
   bool do_render = size > 0;
   decoder_thread_.task_runner()->PostDelayedTask(
       FROM_HERE, base::Bind(&MediaCodecVideoDecoder::ReleaseOutputBuffer,
                             base::Unretained(this), buffer_index, pts,
                             size, do_render, eos_encountered),
       time_to_render);
 }
 
 int MediaCodecVideoDecoder::NumDelayedRenderTasks() const {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   return delayed_buffers_.size();
 }
 
-void MediaCodecVideoDecoder::ClearDelayedBuffers(bool release) {
+void MediaCodecVideoDecoder::ReleaseDelayedBuffers() {
   // Media thread
   // Called when there is no decoder thread
-  if (release) {
-    for (int index : delayed_buffers_)
-      media_codec_bridge_->ReleaseOutputBuffer(index, false);
-  }
+  for (int index : delayed_buffers_)
+    media_codec_bridge_->ReleaseOutputBuffer(index, false);
 
   delayed_buffers_.clear();
 }
 
 #ifndef NDEBUG
 void MediaCodecVideoDecoder::VerifyUnitIsKeyFrame(
     const AccessUnit* unit) const {
   // The first video frame in a sequence must be a key frame or stand-alone EOS.
   DCHECK(unit);
   bool stand_alone_eos = unit->is_end_of_stream && unit->data.empty();
@@ skipping 18 matching lines @@
 
   // |update_current_time_cb_| might be null if there is audio stream.
   // Do not update current time for stand-alone EOS frames.
   if (!update_current_time_cb_.is_null() && !(eos_encountered && !size)) {
     media_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(update_current_time_cb_, pts, pts));
   }
 }
 
 }  // namespace media