media: Don't create a new MediaCodec during AVDA teardown

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 90 matching lines @@
 constexpr base::TimeDelta DecodePollDelay =
     base::TimeDelta::FromMilliseconds(10);
 
 constexpr base::TimeDelta NoWaitTimeOut = base::TimeDelta::FromMicroseconds(0);
 
 constexpr base::TimeDelta IdleTimerTimeOut = base::TimeDelta::FromSeconds(1);
 
 // On low end devices (< KitKat is always low-end due to buggy MediaCodec),
 // defer the surface creation until the codec is actually used if we know no
 // software fallback exists.
-bool ShouldDeferSurfaceCreation(int surface_id, VideoCodec codec) {
+bool ShouldDeferSurfaceCreation(AVDACodecAllocator* codec_allocator,
+                                int surface_id,
+                                VideoCodec codec) {
   return surface_id == SurfaceManager::kNoSurfaceID && codec == kCodecH264 &&
-         AVDACodecAllocator::Instance()->IsAnyRegisteredAVDA() &&
+         codec_allocator->IsAnyRegisteredAVDA() &&
          (base::android::BuildInfo::GetInstance()->sdk_int() <= 18 ||
           base::SysInfo::IsLowEndDevice());
 }
 
 }  // namespace
 
 // AVDAManager manages shared resources for a number of AVDA instances.
 // Its responsibilities include:
 //  - Starting and stopping a shared "construction" thread for instantiating and
 //    releasing MediaCodecs.
@@ skipping 92 matching lines @@
     memory.reset(new SharedMemoryRegion(buffer, true));
 }
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::BitstreamRecord(
     BitstreamRecord&& other)
     : buffer(std::move(other.buffer)), memory(std::move(other.memory)) {}
 
 AndroidVideoDecodeAccelerator::BitstreamRecord::~BitstreamRecord() {}
 
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
+    AVDACodecAllocator* codec_allocator,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb)
-    : client_(NULL),
+    : client_(nullptr),
+      codec_allocator_(codec_allocator),
       make_context_current_cb_(make_context_current_cb),
       get_gles2_decoder_cb_(get_gles2_decoder_cb),
       state_(BEFORE_SURFACE_ALLOC),
       picturebuffers_requested_(false),
       picture_buffer_manager_(this),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       during_initialize_(false),
       deferred_initialization_pending_(false),
       codec_needs_reset_(false),
       defer_surface_creation_(false),
       last_release_task_type_(TaskType::AUTO_CODEC),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   GetManager()->StopTimer(this);
-  AVDACodecAllocator::Instance()->StopThread(this);
+  codec_allocator_->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
 
   DCHECK(cdm_registration_id_);
 
   // Cancel previously registered callback (if any).
   media_drm_bridge_cdm_context_->SetMediaCryptoReadyCB(
       MediaDrmBridgeCdmContext::MediaCryptoReadyCB());
@@ skipping 62 matching lines @@
   // SetSurface() can't be called before Initialize(), so we pick up our first
   // surface ID from the codec configuration.
   DCHECK(!pending_surface_id_);
 
   // We signaled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
 
   // If we're low on resources, we may decide to defer creation of the surface
   // until the codec is actually used.
-  if (ShouldDeferSurfaceCreation(config_.surface_id, codec_config_->codec)) {
+  if (ShouldDeferSurfaceCreation(codec_allocator_, config_.surface_id,
+                                 codec_config_->codec)) {
     // We should never be here if a SurfaceView is required.
     DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
     defer_surface_creation_ = true;
   }
 
-  if (!AVDACodecAllocator::Instance()->StartThread(this)) {
+  if (!codec_allocator_->StartThread(this)) {
     LOG(ERROR) << "Unable to start thread";
     return false;
   }
 
   // For encrypted media, start by initializing the CDM.  Otherwise, start with
   // the surface.
   if (config_.is_encrypted()) {
     if (!deferred_initialization_pending_) {
       DLOG(ERROR)
           << "Deferred initialization must be used for encrypted streams";
@@ skipping 19 matching lines @@
   // decode to save resources, though, we're signaling success now.  If we're
   // wrong, then decoding might fail when we might have been able to use a
   // fallback renderer in WMPI if we failed init.
   if (defer_surface_creation_) {
     if (deferred_initialization_pending_)
       NotifyInitializationSucceeded();
 
     return;
   }
 
-  if (!AVDACodecAllocator::Instance()->AllocateSurface(this,
-                                                       config_.surface_id)) {
+  if (!codec_allocator_->AllocateSurface(this, config_.surface_id)) {
     // We have to wait for some other AVDA instance to free up the surface.
     // OnSurfaceAvailable will be called when it's available.
     // Note that if we aren't deferring init, then we'll signal success, and
     // if we fail later then it will fail decoding instead.  However, since
     // nobody that provides a SurfaceView requires sync init, it doesn't matter.
     return;
   }
 
   // We now own the surface, so finish initialization.
   InitializePictureBufferManager();
@@ skipping 535 matching lines @@
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DCHECK_NE(state_, WAITING_FOR_CODEC);
   state_ = WAITING_FOR_CODEC;
 
   ReleaseCodec();
 
   base::Optional<TaskType> task_type =
-      AVDACodecAllocator::Instance()->TaskTypeForAllocation();
+      codec_allocator_->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return;
   }
 
   // If autodetection is disallowed, fall back to Chrome's software decoders
   // instead of using the software decoders provided by MediaCodec.
   if (task_type == TaskType::SW_CODEC &&
       IsMediaCodecSoftwareDecodingForbidden()) {
     OnCodecConfigured(nullptr);
     return;
   }
 
   codec_config_->task_type = task_type.value();
-  AVDACodecAllocator::Instance()->CreateMediaCodecAsync(
-      weak_this_factory_.GetWeakPtr(), codec_config_);
+  codec_allocator_->CreateMediaCodecAsync(weak_this_factory_.GetWeakPtr(),
+                                          codec_config_);
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecSynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!media_codec_);
   DCHECK_NE(state_, WAITING_FOR_CODEC);
   state_ = WAITING_FOR_CODEC;
 
   base::Optional<TaskType> task_type =
-      AVDACodecAllocator::Instance()->TaskTypeForAllocation();
+      codec_allocator_->TaskTypeForAllocation();
   if (!task_type) {
     // If there is no free thread, then just fail.
     OnCodecConfigured(nullptr);
     return;
   }
 
   codec_config_->task_type = task_type.value();
   std::unique_ptr<VideoCodecBridge> media_codec =
-      AVDACodecAllocator::Instance()->CreateMediaCodecSync(codec_config_);
+      codec_allocator_->CreateMediaCodecSync(codec_config_);
   // Note that |media_codec| might be null, which will NotifyError.
   OnCodecConfigured(std::move(media_codec));
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // If we are supposed to notify that initialization is complete, then do so
@@ skipping 65 matching lines @@
   return drain_type_ == DRAIN_FOR_RESET || drain_type_ == DRAIN_FOR_DESTROY;
 }
 
 void AndroidVideoDecodeAccelerator::OnDrainCompleted() {
   DVLOG(2) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Sometimes MediaCodec returns an EOS buffer even if we didn't queue one.
   // Consider it an error. http://crbug.com/585959.
   if (!drain_type_) {
-    state_ = ERROR;
-    ResetCodecState();
+    NOTIFY_ERROR(PLATFORM_FAILURE, "Unexpected EOS");
     return;
   }
 
-  ResetCodecState();
   switch (*drain_type_) {
     case DRAIN_FOR_FLUSH:
+      ResetCodecState();
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyFlushDone,
                                 weak_this_factory_.GetWeakPtr()));
       break;
     case DRAIN_FOR_RESET:
+      ResetCodecState();
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                                 weak_this_factory_.GetWeakPtr()));
       break;
     case DRAIN_FOR_DESTROY:
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::ActualDestroy,
                                 weak_this_factory_.GetWeakPtr()));
       break;
   }
   drain_type_.reset();
 }
 
 void AndroidVideoDecodeAccelerator::ResetCodecState() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  // If there is already a reset in flight, then that counts.  This can really
-  // only happen if somebody calls Reset.
-  // If the surface is destroyed there's nothing to do.
-  // Note that BEFORE_SURFACE_ALLOC implies that we have no codec, but it's
-  // included for completeness.
-  if (state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED ||
-      state_ == BEFORE_SURFACE_ALLOC || !media_codec_) {
+  // If the surface is destroyed or we're in an error state there's nothing to
+  // do.
+  if (state_ == WAITING_FOR_CODEC || !media_codec_ ||
+      state_ == SURFACE_DESTROYED || state_ == BEFORE_SURFACE_ALLOC ||
+      state_ == ERROR) {
     return;
   }
 
   bitstream_buffers_in_decoder_.clear();
 
   if (pending_input_buf_index_ != -1) {
     // The data for that index exists in the input buffer, but corresponding
     // shm block been deleted. Check that it is safe to flush the codec, i.e.
     // |pending_bitstream_records_| is empty.
     // TODO(timav): keep shm block for that buffer and remove this restriction.
     DCHECK(pending_bitstream_records_.empty());
     pending_input_buf_index_ = -1;
   }
 
-  const bool did_codec_error_happen = state_ == ERROR;
-  state_ = NO_ERROR;
-
-  // Don't reset the codec here if there's no error and we're only flushing;
-  // instead defer until the next decode call; this prevents us from unbacking
-  // frames that might be out for display at end of stream.
-  codec_needs_reset_ = false;
-  if (drain_type_ == DRAIN_FOR_FLUSH && !did_codec_error_happen) {
-    codec_needs_reset_ = true;
+  // If we've just completed a flush don't reset the codec yet. Instead defer
+  // until the next decode call. This prevents us from unbacking frames that
+  // might be out for display at end of stream.
+  codec_needs_reset_ = drain_type_ == DRAIN_FOR_FLUSH;
+  if (codec_needs_reset_)
     return;
-  }
 
   // Flush the codec if possible, or create a new one if not.
-  if (!did_codec_error_happen &&
-      !MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
+  if (!MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
     DVLOG(3) << __func__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     picture_buffer_manager_.CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __func__ << " Deleting the MediaCodec and creating a new one.";
     GetManager()->StopTimer(this);
     ConfigureMediaCodecAsynchronously();
   }
@@ skipping 66 matching lines @@
 
   // 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();
   GetManager()->StopTimer(this);
   ReleaseCodec();
 
   // 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.
-  AVDACodecAllocator::Instance()->DeallocateSurface(this, config_.surface_id);
+  codec_allocator_->DeallocateSurface(this, config_.surface_id);
 
   // Hop the SurfaceTexture release call through the task runner used last time
   // we released a codec. This ensures that we release the surface texture after
   // the codec it's attached to (if any) is released. It's not sufficient to use
   // |codec_config_->task_type| because that might have changed since we
   // released the codec this surface was attached to.
   if (codec_config_->surface_texture) {
-    AVDACodecAllocator::Instance()
-        ->TaskRunnerFor(last_release_task_type_)
+    codec_allocator_->TaskRunnerFor(last_release_task_type_)
         ->PostTaskAndReply(
             FROM_HERE, base::Bind(&base::DoNothing),
             base::Bind(&gl::SurfaceTexture::ReleaseSurfaceTexture,
                        codec_config_->surface_texture));
   }
 
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
@@ skipping 310 matching lines @@
   DCHECK_NE(config_.surface_id, pending_surface_id_.value());
   DCHECK(config_.surface_id == SurfaceManager::kNoSurfaceID ||
          pending_surface_id_.value() == SurfaceManager::kNoSurfaceID);
 
   const int previous_surface_id = config_.surface_id;
   const int new_surface_id = pending_surface_id_.value();
   pending_surface_id_.reset();
   bool success = true;
 
   // TODO(watk): Fix this so we can wait for the new surface to be allocated.
-  if (!AVDACodecAllocator::Instance()->AllocateSurface(this, new_surface_id)) {
+  if (!codec_allocator_->AllocateSurface(this, new_surface_id)) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "Failed to allocate the new surface");
     success = false;
   }
 
   // Ensure the current context is active when switching surfaces; we may need
   // to create a new texture.
   if (success && !make_context_current_cb_.Run()) {
     NOTIFY_ERROR(PLATFORM_FAILURE,
                  "Failed to make this decoder's GL context current when "
                  "switching surfaces.");
@@ skipping 16 matching lines @@
   }
 
   if (success) {
     config_.surface_id = new_surface_id;
     codec_config_->surface = std::move(new_surface);
     codec_config_->surface_texture = picture_buffer_manager_.surface_texture();
   } else {
     // This might be called from OnSurfaceDestroyed(), so we have to release the
     // MediaCodec if we failed to switch the surface.
     ReleaseCodec();
-    AVDACodecAllocator::Instance()->DeallocateSurface(this, new_surface_id);
+    codec_allocator_->DeallocateSurface(this, new_surface_id);
   }
 
   // Regardless of whether we succeeded, we no longer own the previous surface.
-  AVDACodecAllocator::Instance()->DeallocateSurface(this, previous_surface_id);
+  codec_allocator_->DeallocateSurface(this, previous_surface_id);
 
   return success;
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseCodec() {
   if (!media_codec_)
     return;
 
   picture_buffer_manager_.CodecChanged(nullptr);
-  AVDACodecAllocator::Instance()->ReleaseMediaCodec(
+  codec_allocator_->ReleaseMediaCodec(
       std::move(media_codec_), codec_config_->task_type, config_.surface_id);
   last_release_task_type_ = codec_config_->task_type;
 }
 
 }  // namespace media