Implementation of MediaCodecPlayer stage 1

media/base/android/media_codec_video_decoder.cc

Index: media/base/android/media_codec_video_decoder.cc
diff --git a/media/base/android/media_codec_video_decoder.cc b/media/base/android/media_codec_video_decoder.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f20aa1ab286d61b2224416d41cbd68589812ac2d
--- /dev/null
+++ b/media/base/android/media_codec_video_decoder.cc
@@ -0,0 +1,263 @@
+// 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 DELAY_FOR_STAND_ALONE_EOS = 2; // milliseconds
+}
+
+MediaCodecVideoDecoder::MediaCodecVideoDecoder(
+    const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner,
+    const base::Closure& request_data_cb,
+    const base::Closure& starvation_cb,
+    const base::Closure& stop_done_cb,
+    const base::Closure& error_cb,
+    const MetadataChangedCallback& metadata_changed_cb,
+    const base::Closure& request_resources_cb)
+    : MediaCodecDecoder(media_task_runner,
+                        ui_task_runner,
+                        request_data_cb,
+                        starvation_cb,
+                        stop_done_cb,
+                        error_cb,
+                        "VideoDecoder"),
+      metadata_changed_cb_(metadata_changed_cb),
+      request_resources_cb_(request_resources_cb)
+{}
+
+MediaCodecVideoDecoder::~MediaCodecVideoDecoder()
+{
+  DVLOG(1) << "VideoDecoder::~VideoDecoder()";
+}
+
+void MediaCodecVideoDecoder::SetPendingSurface(gfx::ScopedJavaSurface surface) {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  surface_ = surface.Pass();
+
+  if (surface_.IsEmpty()) {
+    // Synchronously stop decoder thread and release MediaCodec
+    ReleaseDecoderResources();
+  }
+}
+
+bool MediaCodecVideoDecoder::HasPendingSurface() const {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  return !surface_.IsEmpty();
+}
+
+bool MediaCodecVideoDecoder::HasStream() const {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  return configs_.video_codec != kUnknownVideoCodec;
+}
+
+void MediaCodecVideoDecoder::SetDemuxerConfigs(const DemuxerConfigs& configs) {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+
+  configs_ = configs;
+
+  if (video_size_.IsEmpty()) {
+    video_size_ = configs_.video_size;
+    ui_task_runner_->PostTask(

[qinmin, 2015/05/26 00:49:20]

remove reliance on ui task runner in decoders. this can be done by returning a
boolean back to MediaCodecPlayer, and let MediaCodecPlayer post a task to ui
thread if SetDemuxerConfigs returns true.

[Tima Vaisburd, 2015/05/28 02:00:34]

ui_task_runner_ is removed. Here I posted the new callback the same way I did in
OnOutputFormatChanged().

+        FROM_HERE,
+        base::Bind(metadata_changed_cb_, kNoTimestamp(), video_size_));
+  }
+}
+
+bool MediaCodecVideoDecoder::IsCodecReconfigureNeeded(
+    const DemuxerConfigs& curr, const DemuxerConfigs& next) const {
+
+  if (curr.video_codec != next.video_codec ||
+      curr.is_video_encrypted != next.is_video_encrypted)
+    return true;
+
+  // Only size changes below this point
+
+  if (curr.video_size.width() == next.video_size.width() &&
+      curr.video_size.height() == next.video_size.height())
+    return false; // i.e. curr == next
+
+  return !static_cast<VideoCodecBridge*>(media_codec_bridge_.get())->
+      IsAdaptivePlaybackSupported(next.video_size.width(),
+                                  next.video_size.height());
+}
+
+MediaCodecDecoder::ConfigStatus
+MediaCodecVideoDecoder::ConfigureInternal() {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+
+  // If we cannot find a key frame in cache, the browser seek is needed.
+  if (!au_queue_.SkipToKeyFrame()) {

[qinmin, 2015/05/26 00:49:19]

This will still skip  frames that are not rendered, which is bad.
Each time we enqueue an AU, AccessUnitQueue.PopFront() is called. So we always
lose the key frame that we should roll back to.
The current implementation doesn't clean up the vector immediately after
rendering.

[Tima Vaisburd, 2015/05/28 02:00:34]

Changed the AccessUnitQueue implementation. Now it uses the list of pointers to
DemuxerData chunks, so we can search back (search is implemented only within one
chunk). Because we store pointers in the queue the copying happens outside of
the lock.

+    DVLOG(1) << class_name() << "::" << __FUNCTION__ << " key frame required";
+
+    // The processing of CONFIG_KEY_FRAME_REQUIRED is not implemented yet,
+    // return error for now
+    //return CONFIG_KEY_FRAME_REQUIRED;
+    return CONFIG_FAILURE;
+  }
+
+  //bool is_secure = is_content_encrypted() && drm_bridge() &&
+  //    drm_bridge()->IsProtectedSurfaceRequired();
+
+  bool is_secure = false; // DRM is not implemented
+
+  DCHECK(!surface_.IsEmpty());
+
+  media_codec_bridge_.reset(VideoCodecBridge::CreateDecoder(
+      configs_.video_codec,
+      is_secure,
+      configs_.video_size,
+      surface_.j_surface().obj(),
+      GetMediaCrypto().obj()));
+
+  if (!media_codec_bridge_) {
+    DVLOG(1) << class_name() << "::" << __FUNCTION__ << " failed";
+    return CONFIG_FAILURE;
+  }
+
+  DVLOG(1) << class_name() << "::" << __FUNCTION__ << " succeeded";
+
+  // This callback requests resources by releasing other players,
+  // post it to the UI thread.
+  ui_task_runner_->PostTask(FROM_HERE, request_resources_cb_);
+
+  return CONFIG_OK;
+}
+
+void MediaCodecVideoDecoder::ReleaseDecoderResources() {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  DVLOG(1) << class_name() << "::" << __FUNCTION__;
+
+  MediaCodecDecoder::ReleaseDecoderResources();
+  surface_ = gfx::ScopedJavaSurface();
+  delayed_buffers_.clear();
+}
+
+void MediaCodecVideoDecoder::SynchronizePTSWithTime(
+    base::TimeDelta current_time) {
+  // Media thread
+  DCHECK(media_task_runner_->BelongsToCurrentThread());
+
+  start_time_ticks_ = base::TimeTicks::Now();
+  start_pts_ = current_time;
+  last_seen_pts_ = current_time;
+}
+
+void MediaCodecVideoDecoder::OnOutputFormatChanged() {
+  // Decoder thread
+  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)
+    ui_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(metadata_changed_cb_, kNoTimestamp(), video_size_));
+}
+
+void MediaCodecVideoDecoder::Render(int buffer_index,
+                                    size_t size,
+                                    bool render_output,
+                                    base::TimeDelta pts,
+                                    bool eos_encountered) {
+  // Decoder thread
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
+  DVLOG(2) << class_name() << "::" << __FUNCTION__ << " pts:" <<  pts
+           << " index:" << buffer_index << (eos_encountered ? " EOS" : "");
+
+  // EOS might come as a stand-alone frame with zero size
+  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(DELAY_FOR_STAND_ALONE_EOS);
+  } else {
+    // Keep track of last seen PTS
+    last_seen_pts_ = pts;
+  }
+
+  if (!render_output) {
+    ReleaseOutputBuffer(buffer_index, 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, 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, do_render, eos_encountered),
+      time_to_render);
+}
+
+void MediaCodecVideoDecoder::ReleaseOutputBuffer(
+    int buffer_index, bool render, bool eos_encountered) {
+  // Decoder thread
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
+  DVLOG(2) << class_name() << "::" << __FUNCTION__;
+
+  media_codec_bridge_->ReleaseOutputBuffer(buffer_index, render);
+
+  delayed_buffers_.erase(buffer_index);
+
+  CheckLastFrame(eos_encountered, !delayed_buffers_.empty());
+}
+
+int MediaCodecVideoDecoder::NumDelayedRenderTasks() const {
+  // Decoder thread
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
+  return delayed_buffers_.size();
+}
+
+void MediaCodecVideoDecoder::ReleaseDelayedBuffers() {
+  // Media thread
+  // Called when there is no decoder thread
+  for (int index : delayed_buffers_)
+    media_codec_bridge_->ReleaseOutputBuffer(index, false);
+  delayed_buffers_.clear();
+}
+
+}  // namespace media