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 auto_lock(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.

[watk, 2016/06/22 22:39:46]

Can you clarify what OnAnyThread is?

[liberato (no reviews please), 2016/06/23 15:18:20]

meant "OnAsync...Complete", thanks.

+  void OnAsyncCodecAutodetectionStarted() {
+    base::AutoLock auto_lock(autodetection_info_.lock_);
+    ++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 auto_lock_l(autodetection_info_.lock_);
+    DCHECK_GT(autodetection_info_.outstanding_, 0);
+    --autodetection_info_.outstanding_;
+  }
+
+  // Return a hint about whether autodetecting the codec type is safe or not.

[watk, 2016/06/22 22:39:46]

I feel like we're too focused on autodetection as the key concept we're worried
about.

To me the key concept is: is the AVDA thread hung? If it is, we shouldn't use it
any more, and we should use software codecs on the main thread because they
probably don't hang.

Anyway, my 2c. I'm fine with how it is if you choose to leave it.

[liberato (no reviews please), 2016/06/23 15:18:19]

yeah, i can see that.  i chose 'autodetection' because it's the action that one
must avoid, but you're right - one must also avoid posting onto the codec
construction thread if it's hung up.

hrm.  i'll pick whichever name is shorter.  :)

+  bool IsCodecAutodetectionProbablySafe() {
+    base::AutoLock auto_lock_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.
+  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

[watk, 2016/06/22 22:39:46]

"reset the timer" feels like a misleading way to say what we're doing :P

[liberato (no reviews please), 2016/06/23 15:18:20]

Done.

+  // 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();

[watk, 2016/06/22 22:39:46]

Move variable closer to usage.

[liberato (no reviews please), 2016/06/23 15:18:19]

Done.

+
   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(

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

Can you just use DeleteSoon() ?

[liberato (no reviews please), 2016/06/22 21:43:55]

ooh, shiny.

+          FROM_HERE,
+          base::Bind(delete_codec_helper, base::Passed(&media_codec_)));

[watk, 2016/06/22 22:39:46]

We might consider incrementing outstanding_ while a destruction is pending
because it might hang too. Making outstanding_ the number of tasks on the AVDA
thread. i.e., the number of tasks that may never complete.

It's a shame TaskRunner doesn't have a way to query the number of queued tasks.

+    }
   }
   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