media: Do a TimedWait() for video surface teardown in AVDA

media/gpu/avda_codec_allocator.cc

 // Copyright 2016 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/avda_codec_allocator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
+#include "media/base/android/sdk_media_codec_bridge.h"
 #include "media/base/limits.h"
 #include "media/base/media.h"
 #include "media/base/timestamp_constants.h"
+#include "media/gpu/android_video_decode_accelerator.h"
 
 namespace media {
 
 namespace {
 
-// Give tasks on the construction thread 800ms before considering them hung.
-// MediaCodec.configure() calls typically take 100-200ms on a N5, so 800ms is
-// expected to very rarely result in false positives. Also, false positives have
-// low impact because we resume using the thread if its apparently hung task
-// completes.
+base::LazyInstance<AVDACodecAllocator>::Leaky g_avda_codec_allocator =
+    LAZY_INSTANCE_INITIALIZER;
+
+// Give tasks 800ms before considering them hung. MediaCodec.configure() calls
+// typically take 100-200ms on a N5, so 800ms is expected to very rarely result
+// in false positives. Also, false positives have low impact because we resume
+// using the thread when the task completes.
 constexpr base::TimeDelta kHungTaskDetectionTimeout =
     base::TimeDelta::FromMilliseconds(800);
 
+// Delete |codec| and signal |done_event| if it's not null.
+void DeleteMediaCodecAndSignal(std::unique_ptr<VideoCodecBridge> codec,
+                               base::WaitableEvent* done_event) {
+  codec.reset();
+  if (done_event)
+    done_event->Signal();
+}
+
 }  // namespace
 
+CodecConfig::CodecConfig() {}
+CodecConfig::~CodecConfig() {}
+
 AVDACodecAllocator::TestInformation::TestInformation() {}
 AVDACodecAllocator::TestInformation::~TestInformation() {}
 
 AVDACodecAllocator::HangDetector::HangDetector(base::TickClock* tick_clock)
     : tick_clock_(tick_clock) {}
 
 void AVDACodecAllocator::HangDetector::WillProcessTask(
     const base::PendingTask& pending_task) {
   base::AutoLock l(lock_);
   task_start_time_ = tick_clock_->NowTicks();
 }
 
 void AVDACodecAllocator::HangDetector::DidProcessTask(
     const base::PendingTask& pending_task) {
   base::AutoLock l(lock_);
   task_start_time_ = base::TimeTicks();
 }
 
 bool AVDACodecAllocator::HangDetector::IsThreadLikelyHung() {
   base::AutoLock l(lock_);
   if (task_start_time_.is_null())
     return false;
 
   return (tick_clock_->NowTicks() - task_start_time_) >
          kHungTaskDetectionTimeout;
 }
 
-// Make sure the construction threads are started for |avda|.
-bool AVDACodecAllocator::StartThread(AndroidVideoDecodeAccelerator* avda) {
+// static
+AVDACodecAllocator& AVDACodecAllocator::Get() {
+  return g_avda_codec_allocator.Get();
+}
+
+// Make sure the construction threads are started for |client|.
+bool AVDACodecAllocator::StartThread(AVDACodecAllocatorClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Cancel any pending StopThreadTask()s because we need the threads now.
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Try to start all threads if they haven't been started.  Remember that
   // threads fail to start fairly often.
   for (size_t i = 0; i < threads_.size(); i++) {
     if (threads_[i]->thread.IsRunning())
       continue;
 
     if (!threads_[i]->thread.Start())
       continue;
 
     // Register the hang detector to observe the thread's MessageLoop.
     threads_[i]->thread.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&base::MessageLoop::AddTaskObserver,
                    base::Unretained(threads_[i]->thread.message_loop()),
                    &threads_[i]->hang_detector));
   }
 
   // Make sure that the construction thread started, else refuse to run.
   // If other threads fail to start, then we'll post to the GPU main thread for
   // those cases.  SW allocation failures are much less rare, so this usually
   // just costs us the latency of doing the codec allocation on the main thread.
   if (!threads_[TaskType::AUTO_CODEC]->thread.IsRunning())
     return false;
 
-  thread_avda_instances_.insert(avda);
-  UMA_HISTOGRAM_ENUMERATION("Media.AVDA.NumAVDAInstances",
-                            thread_avda_instances_.size(),
+  clients_.insert(client);
+  UMA_HISTOGRAM_ENUMERATION("Media.AVDA.NumAVDAInstances", clients_.size(),
                             31);  // PRESUBMIT_IGNORE_UMA_MAX
   return true;
 }
 
-void AVDACodecAllocator::StopThread(AndroidVideoDecodeAccelerator* avda) {
+void AVDACodecAllocator::StopThread(AVDACodecAllocatorClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  thread_avda_instances_.erase(avda);
+  clients_.erase(client);
   // Post a task to stop the thread through the thread's task runner and back
   // to this thread. This ensures that all pending tasks are run first. If the
   // thread is hung we don't post a task to avoid leaking an unbounded number
   // of tasks on its queue. If the thread is not hung, but appears to be, it
   // will stay alive until next time an AVDA tries to stop it. We're
   // guaranteed to not run StopThreadTask() when the thread is hung because if
   // an AVDA queues tasks after DoNothing(), the StopThreadTask() reply will
   // be canceled by invalidating its weak pointer.
   base::WaitableEvent* event =
       (test_info_ ? test_info_->stop_event_.get() : nullptr);
-  if (!thread_avda_instances_.empty()) {
+  if (!clients_.empty()) {
     // If we aren't stopping, then signal immediately.
     if (event)
       event->Signal();
     return;
   }
 
   for (size_t i = 0; i < threads_.size(); i++) {
     if (threads_[i]->thread.IsRunning() &&
         !threads_[i]->hang_detector.IsThreadLikelyHung()) {
       threads_[i]->thread.task_runner()->PostTaskAndReply(
@@ skipping 15 matching lines @@
   // Fail over to the main thread if this thread failed to start.  Note that
   // if the AUTO_CODEC thread fails to start, then AVDA init will fail.
   // We won't fall back autodetection to the main thread, even without a
   // special case here.
   if (!thread.IsRunning())
     return base::ThreadTaskRunnerHandle::Get();
 
   return thread.task_runner();
 }
 
+bool AVDACodecAllocator::AllocateSurface(AVDACodecAllocatorClient* client,
+                                         int surface_id) {
+  DVLOG(1) << __func__ << ": " << surface_id;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (surface_id == SurfaceManager::kNoSurfaceID)
+    return true;
+
+  if (!surface_owners_.count(surface_id) &&
+      !codec_release_tasks_.count(surface_id)) {
+    surface_owners_[surface_id].owner = client;
+    return true;
+  }
+
+  // The surface is already owned or being released. |client| replaces the
+  // previous waiter if any.
+  OwnerRecord& record = surface_owners_[surface_id];
+  if (record.waiter)
+    record.waiter->OnSurfaceAvailable(false);
+  record.waiter = client;
+  return false;
+}
+
+void AVDACodecAllocator::DeallocateSurface(AVDACodecAllocatorClient* client,
+                                           int surface_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (surface_id == SurfaceManager::kNoSurfaceID ||
+      !surface_owners_.count(surface_id)) {
+    return;
+  }
+
+  OwnerRecord& record = surface_owners_[surface_id];
+  if (record.owner == client)
+    record.owner = nullptr;
+  else if (record.waiter == client)
+    record.waiter = nullptr;
+
+  if (record.waiter && !record.owner &&
+      !codec_release_tasks_.count(surface_id)) {
+    record.owner = record.waiter;
+    record.waiter = nullptr;
+    record.owner->OnSurfaceAvailable(true);
+    return;
+  }
+
+  if (!record.owner && !record.waiter)
+    surface_owners_.erase(surface_id);
+}
+
+// During surface teardown we have to handle the following cases.
+// 1) No AVDA has acquired the surface, or the surface has already been
+//    completely released.
+// 2) No AVDA owns the surface, but a MediaCodec is currently being configured

[liberato (no reviews please), 2016/11/17 07:28:19]

is this the case where async construction is pending while the avda is
destroyed?  as in, own surface => start async => destroy => deallocate surface
=> OnSurfaceDestroyed happens (here) =(some time in the future)=> async
completes

[watk, 2016/11/17 20:37:05]

Yeah exactly. Whether the AVDA is alive or not the result should be the same:
the codec will be released (on the main thread) when the OnCodecConfigured task
is dropped because the avda weak ptr is invalidated.

So we'll do two scary things in that case: release on main thread, and release a
MC with destroyed surface. But I'm assuming they're safe because we haven't seen
any reports of that failing I don't think. And it kinda makes sense that an
unused MC hasn't had a chance to get into any crashy state. 

I initially wrote a much more ambitious change that also tracked the allocations
and waited for them too. But it got too complicated and I realized it probably
doesn't matter.. I guess we'll see.

+//    with it on another thread. In this case we assume it's safe for the the
+//    AVDA is expected to drop the MediaCodec when it receives it.
+// 3) An AVDA owns the surface and it responds to OnSurfaceDestroyed() by:
+//     a) Replacing the destroyed surface by calling MediaCodec#setSurface() and
+//        releasing it immediately.
+//     b) Releasing the MediaCodec it's attached to.
+// 4) No AVDA owns the surface, but the MediaCodec it's attached to is currently
+//    being destroyed on another thread.
+void AVDACodecAllocator::OnSurfaceDestroyed(int surface_id) {
+  DVLOG(1) << __func__ << ": " << surface_id;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (surface_owners_.count(surface_id)) {
+    OwnerRecord& record = surface_owners_[surface_id];
+    if (record.waiter) {
+      record.waiter->OnSurfaceAvailable(false);
+      record.waiter = nullptr;
+    }
+
+    if (record.owner)
+      record.owner->OnSurfaceDestroyed();
+
+    surface_owners_.erase(surface_id);
+  }
+
+  if (!codec_release_tasks_.count(surface_id))
+    return;
+
+  // The codec is being released so we have to wait for it here. It's a
+  // TimedWait() because the MediaCodec release may hang, and in that case we
+  // don't want to hang the browser UI thread. Android ANRs occur when the UI
+  // thread is blocked for 5 seconds, so waiting for 4 seconds gives us some
+  // leeway to avoid an ANR. Tested on a Nexus 7.
+  base::WaitableEvent& released =
+      codec_release_tasks_[surface_id].codec_released_event;
+  released.TimedWait(base::TimeDelta::FromSeconds(4));
+  if (!released.IsSignaled())
+    DLOG(WARNING) << __func__ << ": timed out waiting for MediaCodec#release()";
+}
+
+std::unique_ptr<VideoCodecBridge> AVDACodecAllocator::CreateMediaCodecSync(
+    scoped_refptr<CodecConfig> codec_config) {
+  TRACE_EVENT0("media", "AVDA::CreateMediaCodecSync");
+
+  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);
+
+  const bool require_software_codec =
+      codec_config->task_type_ == TaskType::SW_CODEC;
+
+  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,
+      codec_config->csd0_, codec_config->csd1_, true, require_software_codec));
+
+  return codec;
+}
+
+void AVDACodecAllocator::CreateMediaCodecAsync(
+    base::WeakPtr<AVDACodecAllocatorClient> client,
+    scoped_refptr<CodecConfig> codec_config) {
+  base::PostTaskAndReplyWithResult(
+      TaskRunnerFor(codec_config->task_type_).get(), FROM_HERE,
+      base::Bind(&AVDACodecAllocator::CreateMediaCodecSync,
+                 base::Unretained(this), codec_config),
+      base::Bind(&AVDACodecAllocatorClient::OnCodecConfigured, client));
+}
+
+void AVDACodecAllocator::ReleaseMediaCodec(
+    std::unique_ptr<VideoCodecBridge> media_codec,
+    TaskType task_type,
+    int surface_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(media_codec);
+
+  // No need to track the release if it's a SurfaceTexture.
+  if (surface_id == SurfaceManager::kNoSurfaceID) {
+    TaskRunnerFor(task_type)->PostTask(
+        FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
+                              base::Passed(std::move(media_codec)), nullptr));
+    return;
+  }
+
+  base::WaitableEvent* released =
+      &codec_release_tasks_[surface_id].codec_released_event;
+
+  // TODO(watk): Even if this is the current thread, things will work, but we
+  // should refactor this to not tolerate threads failing to start.
+  TaskRunnerFor(task_type)->PostTaskAndReply(
+      FROM_HERE, base::Bind(&DeleteMediaCodecAndSignal,
+                            base::Passed(std::move(media_codec)), released),
+      base::Bind(&AVDACodecAllocator::OnMediaCodecAndSurfaceReleased,
+                 base::Unretained(this), surface_id));
+}
+
+void AVDACodecAllocator::OnMediaCodecAndSurfaceReleased(int surface_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  codec_release_tasks_.erase(surface_id);
+  if (!surface_owners_.count(surface_id))
+    return;
+
+  OwnerRecord& record = surface_owners_[surface_id];
+  if (!record.owner && record.waiter) {
+    record.owner = record.waiter;
+    record.waiter = nullptr;
+    record.owner->OnSurfaceAvailable(true);
+  }
+}
+
 // Returns a hint about whether the construction thread has hung for
 // |task_type|.  Note that if a thread isn't started, then we'll just return
 // "not hung", since it'll run on the current thread anyway.  The hang
 // detector will see no pending jobs in that case, so it's automatic.
 bool AVDACodecAllocator::IsThreadLikelyHung(TaskType task_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
   return threads_[task_type]->hang_detector.IsThreadLikelyHung();
 }
 
 bool AVDACodecAllocator::IsAnyRegisteredAVDA() {
-  return !thread_avda_instances_.empty();
+  return !clients_.empty();
 }
 
-AVDACodecAllocator::TaskType AVDACodecAllocator::TaskTypeForAllocation() {
+TaskType AVDACodecAllocator::TaskTypeForAllocation() {
   if (!IsThreadLikelyHung(TaskType::AUTO_CODEC))
     return TaskType::AUTO_CODEC;
 
   if (!IsThreadLikelyHung(TaskType::SW_CODEC))
     return TaskType::SW_CODEC;
 
   // If nothing is working, then we can't allocate anyway.
   return TaskType::FAILED_CODEC;
 }
 
@@ skipping 29 matching lines @@
 }
 
 void AVDACodecAllocator::StopThreadTask(size_t index,
                                         base::WaitableEvent* event) {
   threads_[index]->thread.Stop();
   if (event)
     event->Signal();
 }
 
 }  // namespace media