Drop idle MediaCodec instances after a few seconds within AVDA.

media/gpu/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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 91 matching lines @@
   return base::TimeDelta::FromSeconds(1);
 }
 
 // Time between when we notice an error, and when we actually notify somebody.
 // This is to prevent codec errors caused by SurfaceView fullscreen transitions
 // from breaking the pipeline, if we're about to be reset anyway.
 static inline const base::TimeDelta ErrorPostingDelay() {
   return base::TimeDelta::FromSeconds(2);
 }
 
+// Time allowed to elapse between codec configuration completion and the first
+// Decode() callback. Unless a site is intentionally stalling after providing
+// initialization information, this timeout should never be hit.
+constexpr base::TimeDelta kNoDecodeIdleTimeout =
+    base::TimeDelta::FromSeconds(1);
+
 // For RecordFormatChangedMetric.
 enum FormatChangedValue {
   CodecInitialized = false,
   MissingFormatChanged = true
 };
 
 // Maximum number of concurrent, incomplete codec creations that we'll allow
 // before turning off autodection of codec type.
 enum { kMaxConcurrentCodecAutodetections = 4 };
 
@@ skipping 834 matching lines @@
   NotifyPictureReady(picture);
 
   // Connect the PictureBuffer to the decoded frame, via whatever mechanism the
   // strategy likes.
   strategy_->UseCodecBufferForPictureBuffer(codec_buffer_index, i->second);
 }
 
 void AndroidVideoDecodeAccelerator::Decode(
     const BitstreamBuffer& bitstream_buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  no_decode_timeout_.Stop();
 
   // If we previously deferred a codec restart, take care of it now. This can
   // happen on older devices where configuration changes require a codec reset.
   if (codec_needs_reset_) {
     DCHECK_EQ(drain_type_, DRAIN_TYPE_NONE);
     ResetCodecState();
   }
 
   if (bitstream_buffer.id() >= 0 && bitstream_buffer.size() > 0) {
     DecodeBuffer(bitstream_buffer);
@@ skipping 219 matching lines @@
 
   DCHECK(!media_codec_);
   media_codec_ = std::move(media_codec);
   strategy_->CodecChanged(media_codec_.get());
   if (!media_codec_) {
     POST_ERROR(PLATFORM_FAILURE, "Failed to create MediaCodec.");
     return;
   }
 
   state_ = NO_ERROR;
-
+  no_decode_timeout_.Start(FROM_HERE, kNoDecodeIdleTimeout, this,
+                           &AndroidVideoDecodeAccelerator::CloseIdleCodec);
   ManageTimer(true);
 }
 
 void AndroidVideoDecodeAccelerator::StartCodecDrain(DrainType drain_type) {
   DVLOG(2) << __FUNCTION__ << " drain_type:" << drain_type;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // We assume that DRAIN_FOR_FLUSH and DRAIN_FOR_RESET cannot come while
   // another drain request is present, but DRAIN_FOR_DESTROY can.
   DCHECK_NE(drain_type, DRAIN_TYPE_NONE);
@@ skipping 88 matching lines @@
   // 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 the codec is not in error state we can 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 (!did_codec_error_happen &&
+  if (!did_codec_error_happen && media_codec_ &&
       base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
     DVLOG(3) << __FUNCTION__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     strategy_->CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __FUNCTION__
              << " Deleting the MediaCodec and creating a new one.";
     g_avda_timer.Pointer()->StopTimer(this);
@@ skipping 339 matching lines @@
   if (should_be_running)
     g_avda_timer.Pointer()->StartTimer(this);
   else
     g_avda_timer.Pointer()->StopTimer(this);
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseMediaCodec() {
   if (!media_codec_)
     return;
 
+  no_decode_timeout_.Stop();
+
   // If codec construction is broken, then we can't release this codec if it's
   // backed by hardware, else it may hang too.  Post it to the construction
   // thread, and it'll get freed if things start working.  If things are
   // already working, then it'll be freed soon.
   //
   // We require software codecs when |allow_autodetection_| is false, so use
   // the stored value as a proxy for whether the MediaCodec is software backed
   // or not.
   if (!codec_config_->allow_autodetection_) {
     media_codec_.reset();
@@ skipping 95 matching lines @@
 }
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted && (codec_config_->codec_ == media::kCodecVP8 ||
                                    codec_config_->codec_ == media::kCodecVP9);
 }
 
+void AndroidVideoDecodeAccelerator::CloseIdleCodec() {
+  if (!media_codec_)
+    return;
+
+  ReleaseMediaCodec();
+  codec_needs_reset_ = true;

[watk, 2016/07/13 22:38:25]

Do we need to call strategy_->CodecChanged(nullptr)?

I feel like the answer is no, but just wanted to double check you'd thought
about it.

[liberato (no reviews please), 2016/07/14 15:33:57]

i don't think that we do, since no decode has been issued => no frames
outstanding.  however, it's probably a good idea since it's safe to call
CodecChanged here, and more robust.

good catch.

+}
+
 }  // namespace media