Make AVDA fall back to software decoding if needed.

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 97 matching lines @@
 static inline const base::TimeDelta ErrorPostingDelay() {
   return base::TimeDelta::FromSeconds(2);
 }
 
 // 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 };
+
 static inline void RecordFormatChangedMetric(FormatChangedValue value) {
   UMA_HISTOGRAM_BOOLEAN("Media.AVDA.MissingFormatChanged", !!value);
 }
 
+static void delete_codec_helper(std::unique_ptr<VideoCodecBridge> codec) {
+  // Do nothing with codec.  It will be deleted / released on destruction.
+}
+
 // Handle OnFrameAvailable callbacks safely.  Since they occur asynchronously,
 // we take care that the AVDA that wants them still exists.  A WeakPtr to
 // the AVDA would be preferable, except that OnFrameAvailable callbacks can
 // occur off the gpu main thread.  We also can't guarantee when the
 // SurfaceTexture will quit sending callbacks to coordinate with the
 // destruction of the AVDA, so we have a separate object that the cb can own.
 class AndroidVideoDecodeAccelerator::OnFrameAvailableHandler
     : public base::RefCountedThreadSafe<OnFrameAvailableHandler> {
  public:
   // We do not retain ownership of |owner|.  It must remain valid until
@@ skipping 46 matching lines @@
 // buffer to MediaCodec).  This is inherently a race, since we don't know if
 // MediaCodec is broken or just slow.  Since the MediaCodec API doesn't let
 // us wait on MediaCodec state changes prior to L, we more or less have to
 // time out or keep polling forever in some common cases.
 class AVDATimerManager {
  public:
   // Make sure that the construction thread is started for |avda_instance|.
   bool StartThread(AndroidVideoDecodeAccelerator* avda_instance) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
-    if (thread_avda_instances_.empty()) {
+    // If we chose not to shut it down due to pending codec constructions, then
+    // the thread might already be started even if there are no avda instances.
+    // Plus, sometimes we just fail to start the thread.
+    if (!construction_thread_.IsRunning()) {
       if (!construction_thread_.Start()) {
         LOG(ERROR) << "Failed to start construction thread.";
         return false;
       }
     }
 
     thread_avda_instances_.insert(avda_instance);
     return true;
   }
 
   // |avda_instance| will no longer need the construction thread.  Stop the
   // thread if this is the last instance.
   void StopThread(AndroidVideoDecodeAccelerator* avda_instance) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     thread_avda_instances_.erase(avda_instance);
-    if (thread_avda_instances_.empty())
-      construction_thread_.Stop();
+    if (!thread_avda_instances_.empty())
+      return;
+
+    // Don't stop the thread if there are outstanding requests, since they
+    // might be hung.  They also might simply be incomplete, and the thread
+    // will stay running until we try to shut it down again.
+    base::AutoLock _l(autodetection_info_.lock_);
+    if (autodetection_info_.outstanding_)
+      return;
+
+    construction_thread_.Stop();
   }
 
   // Request periodic callback of |avda_instance|->DoIOTask(). Does nothing if
   // the instance is already registered and the timer started. The first request
   // will start the repeating timer on an interval of DecodePollDelay().
   void StartTimer(AndroidVideoDecodeAccelerator* avda_instance) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     timer_avda_instances_.insert(avda_instance);
 
@@ skipping 25 matching lines @@
       io_timer_.Stop();
   }
 
   // Eventually, we should run the timer on this thread.  For now, we just keep
   // it as a convenience for construction.
   scoped_refptr<base::SingleThreadTaskRunner> ConstructionTaskRunner() {
     DCHECK(thread_checker_.CalledOnValidThread());
     return construction_thread_.task_runner();
   }
 
+  // Called on the main thread when codec autodetection starts.  There may be
+  // several calls to this before any call to OnAnyThread.
+  void OnAsyncCodecAutodetectionStarted() {
+    base::AutoLock _l(autodetection_info_.lock_);

[DaleCurtis, 2016/06/22 19:13:49]

Chose something other than _l :)

[liberato (no reviews please), 2016/06/22 20:44:12]

done.  that's a habit from android native code.

+    ++autodetection_info_.outstanding_;
+  }
+
+  // Called on any thread when a codec is constructed with autodetection.  This
+  // assumes that requests are ordered, so please don't mix sync and async codec
+  // construction here.  This may be called on any thread.
+  void OnAsyncCodecAutodetectionComplete() {
+    base::AutoLock _l(autodetection_info_.lock_);
+    DCHECK(autodetection_info_.outstanding_ > 0);

[DaleCurtis, 2016/06/22 19:13:49]

DCHECK_GT()

[liberato (no reviews please), 2016/06/22 20:44:12]

Done.

+    --autodetection_info_.outstanding_;
+  }
+
+  // Return a hint about whether autodetecting the codec type is safe or not.
+  bool IsCodecAutodetectionProbablySafe() {
+    base::AutoLock _l(autodetection_info_.lock_);
+
+    return autodetection_info_.outstanding_ < kMaxConcurrentCodecAutodetections;
+  }
+
   // |avda| would like to use |surface_id|.  If it is not busy, then mark it
   // as busy and return true.  If it is busy, then replace any existing waiter,
   // make |avda| the current waiter, and return false.  Any existing waiter
   // is assumed to be on the way out, so we fail its allocation request.
   bool AllocateSurface(int surface_id, AndroidVideoDecodeAccelerator* avda) {
     // Nobody has to wait for no surface.
     if (surface_id == AndroidVideoDecodeAccelerator::Config::kNoSurfaceID)
       return true;
 
     auto iter = surface_waiter_map_.find(surface_id);
@@ skipping 85 matching lines @@
   SurfaceWaiterMap surface_waiter_map_;
 
   // Since we can't delete while iterating when using a set, defer erasure until
   // after iteration complete.
   bool timer_running_ = false;
   std::set<AndroidVideoDecodeAccelerator*> pending_erase_;
 
   // Repeating timer responsible for draining pending IO to the codecs.
   base::RepeatingTimer io_timer_;
 
+  // Data for determining if codec creation is hanging.

[DaleCurtis, 2016/06/22 19:13:49]

Doesn't seem like this is necessary anymore? Can't you tick the count on the
main thread? and count it as pending until it returns?

[liberato (no reviews please), 2016/06/22 20:44:12]

unfortunately, not safely.  we'd lose the increment if the avda instance was
destroyed.

[DaleCurtis, 2016/06/22 20:56:49]

What do you mean? Just have a bool pending_initialize_ and decrement if it
hasn't completed right?

[liberato (no reviews please), 2016/06/22 21:07:58]

OnCodecInitialized is weakptr'd in the callback.

is there some custom callback magic that can happen if the weak ptr doesn't
promote, that we could take advantage of?

[DaleCurtis, 2016/06/22 21:11:50]

Sure, but if you get to destruction with pending_initialize_ = true you can
decrement the outstanding count, right?

[liberato (no reviews please), 2016/06/22 21:13:28]

wouldn't we get to destruction with pending_initialize_==true in the case where
it's broken, too?

[DaleCurtis, 2016/06/22 21:20:10]

Ah, yeah, sorry I didn't think that through.

+  struct {
+    // Lock that protects other members of this struct.
+    base::Lock lock_;
+
+    // Number of currently pending autodetection requests.
+    int outstanding_ = 0;
+  } autodetection_info_;
+
   base::Thread construction_thread_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 673 matching lines @@
   // 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();
     strategy_->CodecChanged(nullptr);
   }
 
+  // Choose whether to autodetect the codec type.
+  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 =
-      g_avda_timer.Pointer()->ConstructionTaskRunner();
+      codec_config_->allow_autodetection_
+          ? g_avda_timer.Pointer()->ConstructionTaskRunner()
+          : base::ThreadTaskRunnerHandle::Get();
   CHECK(task_runner);
 
   base::PostTaskAndReplyWithResult(
       task_runner.get(), FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::ConfigureMediaCodecOnAnyThread,
                  codec_config_),
       base::Bind(&AndroidVideoDecodeAccelerator::OnCodecConfigured,
                  weak_this_factory_.GetWeakPtr()));
 }
 
 bool AndroidVideoDecodeAccelerator::ConfigureMediaCodecSynchronously() {
   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;
+
   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");
 
   jobject media_crypto = codec_config->media_crypto_
                              ? codec_config->media_crypto_->obj()
                              : nullptr;
 
   // |needs_protected_surface_| implies encrypted stream.
   DCHECK(!codec_config->needs_protected_surface_ || media_crypto);
 
-  return std::unique_ptr<VideoCodecBridge>(VideoCodecBridge::CreateDecoder(
+  const bool require_software = !codec_config->allow_autodetection_;
+
+  std::unique_ptr<VideoCodecBridge> codec(VideoCodecBridge::CreateDecoder(
       codec_config->codec_, codec_config->needs_protected_surface_,
       codec_config->initial_expected_coded_size_,
-      codec_config->surface_.j_surface().obj(), media_crypto, true));
+      codec_config->surface_.j_surface().obj(), media_crypto, true,
+      require_software));
+
+  // If we successfully completed after an autodetect, then reset the timer so
+  // that other instances know that autodetection is okay.
+  if (codec_config->notify_completion_)
+    g_avda_timer.Pointer()->OnAsyncCodecAutodetectionComplete();
+
+  return codec;
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // Record one instance of the codec being initialized.
   RecordFormatChangedMetric(FormatChangedValue::CodecInitialized);
 
@@ skipping 214 matching lines @@
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  AVDATimerManager* manager = g_avda_timer.Pointer();
+
   if (!on_destroying_surface_cb_.is_null()) {
     AVDASurfaceTracker::GetInstance()->UnregisterOnDestroyingSurfaceCallback(
         on_destroying_surface_cb_);
   }
 
   // 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.
-  g_avda_timer.Pointer()->DeallocateSurface(config_.surface_id, this);
+  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_) {
-    g_avda_timer.Pointer()->StopTimer(this);
-    media_codec_.reset();
+    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.
+    if (media_codec_->IsSoftwareCodec()) {
+      media_codec_.reset();
+    } else {
+      manager->ConstructionTaskRunner()->PostTask(
+          FROM_HERE,
+          base::Bind(delete_codec_helper, base::Passed(&media_codec_)));
+    }
   }
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
@@ skipping 305 matching lines @@
     if (MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media