Release MediaCodec on another thread more often.

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 1070 matching lines @@
   DCHECK_NE(state_, WAITING_FOR_CODEC);
 
   state_ = WAITING_FOR_CODEC;
 
   // Tell the strategy that we're changing codecs.  The codec itself could be
   // used normally, since we don't replace it until we're back on the main
   // thread.  However, if we're using an output surface, then the incoming codec
   // might access that surface while the main thread is drawing.  Telling the
   // strategy to forget the codec avoids this.
   if (media_codec_) {
-    media_codec_.reset();
+    ReleaseMediaCodec();
     strategy_->CodecChanged(nullptr);
   }
 
-  // Choose whether to autodetect the codec type.
+  // Choose whether to autodetect the codec type.  Note that we do this after
+  // releasing any outgoing codec, so that |codec_config_| still matches the
+  // outgoing codec for ReleaseMediaCodec().
   codec_config_->allow_autodetection_ =
       g_avda_timer.Pointer()->IsCodecAutodetectionProbablySafe();
   codec_config_->notify_completion_ = codec_config_->allow_autodetection_;
   if (codec_config_->allow_autodetection_)
     g_avda_timer.Pointer()->OnAsyncCodecAutodetectionStarted();
 
   // If we're not trying autodetection, then use the main thread.  The original
   // might be blocked.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       codec_config_->allow_autodetection_
@@ skipping 13 matching lines @@
   state_ = WAITING_FOR_CODEC;
 
   // Decide whether to allow autodetection or not.  Since we're on the main
   // thread, and this request is unordered with respect to pending async config
   // attempts, don't record it.  It may break book-keeping, and there's not
   // much we can do anyway.
   codec_config_->allow_autodetection_ =
       g_avda_timer.Pointer()->IsCodecAutodetectionProbablySafe();
   codec_config_->notify_completion_ = false;
 
+  ReleaseMediaCodec();
   std::unique_ptr<VideoCodecBridge> media_codec =
       ConfigureMediaCodecOnAnyThread(codec_config_);
   OnCodecConfigured(std::move(media_codec));
   return !!media_codec_;
 }
 
 std::unique_ptr<VideoCodecBridge>
 AndroidVideoDecodeAccelerator::ConfigureMediaCodecOnAnyThread(
     scoped_refptr<CodecConfig> codec_config) {
   TRACE_EVENT0("media", "AVDA::ConfigureMediaCodec");
@@ skipping 37 matching lines @@
     NotifyInitializationComplete(state_ == SURFACE_DESTROYED ? true
                                                              : !!media_codec);
     deferred_initialization_pending_ = false;
   }
 
   // If |state_| changed to SURFACE_DESTROYED while we were configuring a codec,
   // then the codec is already invalid so we return early and drop it.
   if (state_ == SURFACE_DESTROYED)
     return;
 
+  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;
 
   ManageTimer(true);
@@ skipping 209 matching lines @@
   // We no longer care about |surface_id|, in case we did before.  It's okay
   // if we have no surface and/or weren't the owner or a waiter.
   manager->DeallocateSurface(config_.surface_id, this);
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
   if (media_codec_) {
     manager->StopTimer(this);
-    // 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();
-    } else {
-      manager->ConstructionTaskRunner()->DeleteSoon(FROM_HERE,
-                                                    media_codec_.release());
-    }
+    ReleaseMediaCodec();
   }
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
@@ skipping 67 matching lines @@
   DVLOG(1) << __FUNCTION__ << " surface_id: " << surface_id;
 
   if (surface_id != config_.surface_id)
     return;
 
   // If we're currently asynchronously configuring a codec, it will be destroyed
   // when configuration completes and it notices that |state_| has changed to
   // SURFACE_DESTROYED.
   state_ = SURFACE_DESTROYED;
   if (media_codec_) {
-    media_codec_.reset();
+    ReleaseMediaCodec();
     strategy_->CodecChanged(media_codec_.get());
   }
   // If we're draining, signal completion now because the drain can no longer
   // proceed.
   if (drain_type_ != DRAIN_TYPE_NONE)
     OnDrainCompleted();
 }
 
 void AndroidVideoDecodeAccelerator::OnFrameAvailable() {
   // Remember: this may be on any thread.
@@ skipping 135 matching lines @@
   } else {
     most_recent_work_ = now;
   }
 
   if (should_be_running)
     g_avda_timer.Pointer()->StartTimer(this);
   else
     g_avda_timer.Pointer()->StopTimer(this);
 }
 
+void AndroidVideoDecodeAccelerator::ReleaseMediaCodec() {
+  if (!media_codec_)
+    return;
+
+  // 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();
+  } else {
+    g_avda_timer.Pointer()->ConstructionTaskRunner()->DeleteSoon(
+        FROM_HERE, media_codec_.release());
+  }
+}
+
 // static
 bool AndroidVideoDecodeAccelerator::UseDeferredRenderingStrategy(
     const gpu::GpuPreferences& gpu_preferences) {
   return true;
 }
 
 // static
 bool AndroidVideoDecodeAccelerator::UseTextureCopyForDeferredStrategy(
     const gpu::GpuPreferences& gpu_preferences) {
   // http://crbug.com/582170
@@ skipping 72 matching lines @@
       // http://crbug.com/582170
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media