media: Lazily reconfigure MediaCodecs in AVDA for JellyBean

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
@@ skipping 391 matching lines @@
 
   NOTIMPLEMENTED();
   NotifyCdmAttached(false);
 
 #endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void AndroidVideoDecodeAccelerator::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
-  if (state_ == ERROR) {
+
+  if (state_ == ERROR || state_ == PENDING_CODEC_REINITIALIZATION)
     return;
-  }
 
   bool did_work = QueueInput();
   while (DequeueOutput())
     did_work = true;
 
   ManageTimer(did_work || start_timer);
 }
 
 bool AndroidVideoDecodeAccelerator::QueueInput() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 350 matching lines @@
   }
 }
 
 void AndroidVideoDecodeAccelerator::DecodeBuffer(
     const media::BitstreamBuffer& bitstream_buffer) {
   pending_bitstream_buffers_.push(
       std::make_pair(bitstream_buffer, base::Time::Now()));
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                  pending_bitstream_buffers_.size());
 
+  if (state_ == PENDING_CODEC_REINITIALIZATION) {
+    base::AutoReset<bool> auto_reset(&defer_errors_, true);
+    if (!ConfigureMediaCodec()) {
+      POST_ERROR(PLATFORM_FAILURE, "Failed to configure MediaCodec.");
+      return;
+    }
+    state_ = NO_ERROR;
+  }
+
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
   client_->ProvidePictureBuffers(kNumPictureBuffers,
                                  strategy_->GetPictureBufferSize(),
                                  strategy_->GetTextureTarget());
 }
 
 void AndroidVideoDecodeAccelerator::AssignPictureBuffers(
@@ skipping 88 matching lines @@
     LOG(ERROR) << "Failed to create MediaCodec instance.";
     return false;
   }
 
   ManageTimer(true);
   return true;
 }
 
 void AndroidVideoDecodeAccelerator::ResetCodecState() {
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (state_ == PENDING_CODEC_REINITIALIZATION)
+    return
+
   bitstream_buffers_in_decoder_.clear();
-
-  // We don't dismiss picture buffers here since we might not get a format
-  // changed message to re-request them, such as during a seek.  In that case,
-  // we want to reuse the existing buffers.  However, we're about to invalidate
-  // all the output buffers, so we must be sure that the strategy no longer
-  // refers to them.
-
   if (pending_input_buf_index_ != -1) {
     // The data for that index exists in the input buffer, but corresponding
     // shm block been deleted. Check that it is safe to flush the coec, i.e.
     // |pending_bitstream_buffers_| is empty.
     // TODO(timav): keep shm block for that buffer and remove this restriction.
     DCHECK(pending_bitstream_buffers_.empty());
     pending_input_buf_index_ = -1;
   }
 
-  if (state_ == WAITING_FOR_KEY)
-    state_ = NO_ERROR;
+  // We don't dismiss picture buffers here since we might not get a format
+  // changed message to re-request them, such as during a seek.  In that case,
+  // we want to reuse the existing buffers.  However, we're about to invalidate
+  // all the output buffers, so we must be sure that the strategy no longer
+  // refers to them.
 
   // We might increment error_sequence_token here to cancel any delayed errors,
   // but right now it's unclear that it's safe to do so.  If we are in an error
   // state because of a codec error, then it would be okay.  Otherwise, it's
   // less obvious that we are exiting the error state.  Since deferred errors
   // are only intended for fullscreen transitions right now, we take the more
   // conservative approach and let the errors post.
   // TODO(liberato): revisit this once we sort out the error state a bit more.
 
   // When codec is not in error state we can quickly reset (internally calls
   // flush()) for JB-MR2 and beyond. Prior to JB-MR2, flush() had several bugs
   // (b/8125974, b/8347958) so we must delete the MediaCodec and create a new
   // one. The full reconfigure is much slower and may cause visible freezing if
   // done mid-stream.
-  if (state_ == NO_ERROR &&
+  if (state_ != ERROR &&
       base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
-    DVLOG(3) << __FUNCTION__ << " Doing fast MediaCodec reset (flush).";
+    DVLOG(3) << __FUNCTION__ << ": flushing the MediaCodec.";
     media_codec_->Reset();
-    // Since we just flushed all the output buffers, make sure that nothing is
-    // using them.
-    strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
+    state_ = NO_ERROR;
   } else {
-    DVLOG(3) << __FUNCTION__
-             << " Deleting the MediaCodec and creating a new one.";
-    g_avda_timer.Pointer()->StopTimer(this);
+    DVLOG(3) << __FUNCTION__ << ": deleting the MediaCodec.";
     media_codec_.reset();
-    // Changing the codec will also notify the strategy to forget about any
-    // output buffers it has currently.
-    state_ = NO_ERROR;
-    if (!ConfigureMediaCodec())
-      POST_ERROR(PLATFORM_FAILURE, "Failed to create MediaCodec.");
+    // The MediaCodec will be initialized lazily on the next Decode().
+    // TODO(liberato): After asynchronous MediaCodec initialization is
+    // implemented, we should choose to eagerly reinitialize the MediaCodec when
+    // we know a Decode() call is coming soon anyway.
+    state_ = PENDING_CODEC_REINITIALIZATION;
   }
+
+  // Notify the strategy that the MediaCodec changed because any output buffers
+  // it owns are now invalid.
+  strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
+  g_avda_timer.Pointer()->StopTimer(this);
 }
 
 void AndroidVideoDecodeAccelerator::DismissPictureBuffers() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << __FUNCTION__;
 
   for (const auto& pb : output_picture_buffers_) {
     strategy_->DismissOnePictureBuffer(pb.second);
     client_->DismissPictureBuffer(pb.first);
     dismissed_picture_ids_.insert(pb.first);
@@ skipping 258 matching lines @@
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
                              NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE |
                          media::VideoDecodeAccelerator::Capabilities::
                              SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
   }
 
   return capabilities;
 }
 
 }  // namespace content