MediaCodecPlayer implementation (stage 3 - browser seek and surface change)

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"
@@ skipping 57 matching lines @@
 void MediaCodecVideoDecoder::ReleaseDecoderResources() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__;
 
   MediaCodecDecoder::ReleaseDecoderResources();
   surface_ = gfx::ScopedJavaSurface();
   delayed_buffers_.clear();
 }
 
-void MediaCodecVideoDecoder::SetPendingSurface(gfx::ScopedJavaSurface surface) {
+void MediaCodecVideoDecoder::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
+  DVLOG(1) << class_name() << "::" << __FUNCTION__
+           << (surface.IsEmpty() ? " empty" : " non-empty");
+
   surface_ = surface.Pass();
 
-  if (surface_.IsEmpty()) {
-    // Synchronously stop decoder thread and release MediaCodec
-    ReleaseDecoderResources();
-  }
+  needs_reconfigure_ = true;
 }
 
-bool MediaCodecVideoDecoder::HasPendingSurface() const {
+bool MediaCodecVideoDecoder::HasVideoSurface() const {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   return !surface_.IsEmpty();
 }
 
 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) {
@@ skipping 13 matching lines @@
 }
 
 MediaCodecDecoder::ConfigStatus MediaCodecVideoDecoder::ConfigureInternal() {
   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_.RewindToLastKeyFrame()) {
     DVLOG(1) << class_name() << "::" << __FUNCTION__ << " key frame required";
+    return kConfigKeyFrameRequired;
+  }
 
-    // The processing of CONFIG_KEY_FRAME_REQUIRED is not implemented yet,
-    // return error for now.
-    // TODO(timav): Replace this with the following line together with
-    // implementing the browser seek:
-    // return CONFIG_KEY_FRAME_REQUIRED;
-    return CONFIG_FAILURE;
+  if (configs_.video_codec == kUnknownVideoCodec) {
+    DVLOG(0) << class_name() << "::" << __FUNCTION__
+             << " configuration parameters are required";
+    return kConfigFailure;
   }
 
   // TODO(timav): implement DRM.
   // bool is_secure = is_content_encrypted() && drm_bridge() &&
   //    drm_bridge()->IsProtectedSurfaceRequired();
 
   bool is_secure = false;  // DRM is not implemented
 
   if (surface_.IsEmpty()) {
     DVLOG(0) << class_name() << "::" << __FUNCTION__ << " surface required";
-    return CONFIG_FAILURE;
+    return kConfigFailure;
   }
 
   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;
+    return kConfigFailure;
   }
 
   DVLOG(1) << class_name() << "::" << __FUNCTION__ << " succeeded";
 
   media_task_runner_->PostTask(FROM_HERE, codec_created_cb_);
 
-  return CONFIG_OK;
+  return kConfigOk;
 }
 
 void MediaCodecVideoDecoder::SynchronizePTSWithTime(
     base::TimeDelta current_time) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
 
   start_time_ticks_ = base::TimeTicks::Now();
   start_pts_ = current_time;
   last_seen_pts_ = current_time;
 }
@@ skipping 59 matching lines @@
                             size, do_render, eos_encountered),
       time_to_render);
 }
 
 int MediaCodecVideoDecoder::NumDelayedRenderTasks() const {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   return delayed_buffers_.size();
 }
 
-void MediaCodecVideoDecoder::ReleaseDelayedBuffers() {
+void MediaCodecVideoDecoder::ClearDelayedBuffers(bool release) {
   // Media thread
   // Called when there is no decoder thread
-  for (int index : delayed_buffers_)
-    media_codec_bridge_->ReleaseOutputBuffer(index, false);
+  if (release) {
+    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();
   DCHECK(stand_alone_eos || unit->is_key_frame);
@@ skipping 17 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