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 { kMaxOutstandingCodecAutodetections = 4 };
+
+static inline const base::TimeDelta CodecConstructionTimeout() {
+  return base::TimeDelta::FromSeconds(1);
+}
+
 static inline void RecordFormatChangedMetric(FormatChangedValue value) {
   UMA_HISTOGRAM_BOOLEAN("Media.AVDA.MissingFormatChanged", !!value);
 }
 
 // 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.
@@ skipping 50 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()) {
+    // The thread might already be started even if there are no avda instances,

[DaleCurtis, 2016/06/21 21:17:56]

remove ,

[liberato (no reviews please), 2016/06/22 17:56:13]

i restructured the sentence a litt.e

+    // if we chose not to shut it down due to pending codec constructions.
+    // 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();
   }
 
+  scoped_refptr<base::SingleThreadTaskRunner> BackupTaskRunner() {

[DaleCurtis, 2016/06/21 21:17:56]

Instead of this, should we just stop using async codec creation when it's hung?
I.e. use the main thread and let gpu hang monitor solve our problems if it
becomes an issue? We'd definitely want a UMA for hung thread status then.
Similar to what is done in AudioManager::AudioHangMonitor which tracks okay,
hung, and recovered states.

[liberato (no reviews please), 2016/06/22 17:56:13]

Done, except the UMA stat.  i'm still trying to figure out exactly what we want
to measure.

+    DCHECK(thread_checker_.CalledOnValidThread());
+    // Try to start the backup thread if needed.  Note that we never bother to
+    // stop this once it starts.
+    if (!backup_thread_.IsRunning())

[DaleCurtis, 2016/06/21 21:17:56]

Collapse to ternary if not deleting.

[liberato (no reviews please), 2016/06/22 17:56:13]

Done.

+      if (!backup_thread_.Start())
+        return nullptr;
+    return backup_thread_.task_runner();
+  }
+
+  // Called on the main thread when codec autodetection starts.  There may be

[DaleCurtis, 2016/06/21 21:17:56]

I think this is a bit more complicated than necessary and TimeTicks can be
dangerous in the world of suspend/resume (see AudioManager::AudioHangMonitor,
dunno how that works on Android though).

How about instead posting a delayed task with a timeout which completes codec
initialization with an error? You can then just have a simple integer in
AVDATimerManager which tracks timeout counts and once x is hit force software.
If the real codec initialization ever comes back you decrement the timeout
count.

This avoids needing the additional locking mechanism and TimeTicks based
comparison mechanism.

[liberato (no reviews please), 2016/06/22 17:56:13]

keeping codec construction off the main thread is generally a good thing to do.

anyway, i removed the backup thread.  as i thought more about this, i'm not sure
that the PostDelayedTask really buys us much.  the next CL just counts the total
number of pending codec constructions, and switches to main thread + software if
we're trying to get more than four.

it's bad in that it switches to the main thread for construction more often than
it needs to, but only if lots of video elements are on the page.

PS2 has the advantage of keeping things off the main thread always, and allowing
a single video element to fail over all future allocations to software.  as in,
a single page refresh can fail over rather than needing 4 / # video elements.

i doubt that matters.

the UMA stat gets more complicated, since it's no longer clear exactly when
we've timed out.  i'll figure something out.

+  // several calls to this before any call to OnAnyThread.
+  void OnAsyncCodecAutodetectionStarted() {
+    base::AutoLock _l(autodetection_info_.lock_);
+    if (!autodetection_info_.outstanding_)
+      autodetection_info_.current_start_ = base::TimeTicks::Now();
+    ++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);
+    --autodetection_info_.outstanding_;
+
+    // The next request, if any, will start approximately now.
+    autodetection_info_.current_start_ = base::TimeTicks::Now();
+  }
+
+  // Return a hint about whether autodetecting the codec type is safe or not.
+  bool IsCodecAutodetectionProbablySafe() {
+    base::AutoLock _l(autodetection_info_.lock_);
+
+    // If there are no outstanding autodetections, then assume that it's okay
+    // to try one.
+    if (autodetection_info_.outstanding_ == 0)
+      return true;
+
+    // Hard-limit the number of outstanding autodetections, to try to prevent
+    // falling back to software on an autodetect.  This seems to be when
+    // things start to cause problems.  While this doesn't limit the number of
+    // hardware decoders that are in use concurrently, it might help during
+    // initial page load if there are a lot of tags.
+    if (autodetection_info_.outstanding_ >= kMaxOutstandingCodecAutodetections)
+      return false;
+
+    // Make sure that we've made progress recently.
+    base::TimeTicks now = base::TimeTicks::Now();
+    return (now - autodetection_info_.current_start_) <
+           CodecConstructionTimeout();
+  }
+
   // |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 41 matching lines @@
 
     // Promote |waiter| to be the owner.
     iter->second.owner = waiter;
     iter->second.waiter = nullptr;
     waiter->OnSurfaceAvailable(true);
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDATimerManager>;
 
-  AVDATimerManager() : construction_thread_("AVDAThread") {}
+  AVDATimerManager()
+      : construction_thread_("AVDAThread"),
+        backup_thread_("AVDABackupThread") {}
   ~AVDATimerManager() { NOTREACHED(); }
 
   void RunTimer() {
     {
       // Call out to all AVDA instances, some of which may attempt to remove
       // themselves from the list during this operation; those removals will be
       // deferred until after all iterations are complete.
       base::AutoReset<bool> scoper(&timer_running_, true);
       for (auto* avda : timer_avda_instances_)
         avda->DoIOTask(false);
@@ skipping 23 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;
+
+    // Time at which the most recent autodetection started.
+    base::TimeTicks current_start_;
+  } autodetection_info_;
+
   base::Thread construction_thread_;
+  base::Thread backup_thread_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::CodecConfig::CodecConfig() {}
@@ skipping 672 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 also use the backup thread.  The
+  // main one might be blocked.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      g_avda_timer.Pointer()->ConstructionTaskRunner();
-  CHECK(task_runner);
+      codec_config_->allow_autodetection_
+          ? g_avda_timer.Pointer()->ConstructionTaskRunner()
+          : g_avda_timer.Pointer()->BackupTaskRunner();
+  if (!task_runner) {
+    // If we don't have a thread, then just fail.
+    OnCodecConfigured(nullptr);
+    return;
+  }
 
   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 555 matching lines @@
     if (MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media