media: Handle output SurfaceView destruction in AVDA

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 300 matching lines @@
       is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       drain_type_(DRAIN_TYPE_NONE),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       error_sequence_token_(0),
       defer_errors_(false),
       deferred_initialization_pending_(false),
+      surface_id_(media::VideoDecodeAccelerator::Config::kNoSurfaceID),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_timer.Pointer()->StopTimer(this);
   g_avda_timer.Pointer()->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 77 matching lines @@
   } else {
     DVLOG(1) << __FUNCTION__ << ", using copy back strategy.";
     strategy_.reset(new AndroidCopyingBackingStrategy(this));
   }
 
   if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
-  codec_config_->surface_ = strategy_->Initialize(config.surface_id);
+  surface_id_ = config.surface_id;
+  codec_config_->surface_ = strategy_->Initialize(surface_id_);
   if (codec_config_->surface_.IsEmpty()) {
     LOG(ERROR) << "Failed to initialize the backing strategy. The returned "
                   "Java surface is empty.";
     return false;
   }
 
+  on_destroying_surface_cb_ =
+      base::Bind(&AndroidVideoDecodeAccelerator::OnDestroyingSurface,
+                 weak_this_factory_.GetWeakPtr());
+  AVDASurfaceTracker::GetInstance()->RegisterOnDestroyingSurfaceCallback(
+      on_destroying_surface_cb_);
+
   // TODO(watk,liberato): move this into the strategy.
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       strategy_->GetSurfaceTexture();
   if (surface_texture) {
     on_frame_available_handler_ =
         new OnFrameAvailableHandler(this, surface_texture);
   }
 
   // Start the thread for async configuration, even if we don't need it now.
   // ResetCodecState might rebuild the codec later, for example.
@@ skipping 61 matching lines @@
 
   NOTIMPLEMENTED();
   NotifyInitializationComplete(false);
 
 #endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void AndroidVideoDecodeAccelerator::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
-  if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
+  if (state_ == ERROR || state_ == WAITING_FOR_CODEC ||
+      state_ == SURFACE_DESTROYED) {
     return;
+  }
 
   strategy_->MaybeRenderEarly();
   bool did_work = QueueInput();
   while (DequeueOutput())
     did_work = true;
 
   ManageTimer(did_work || start_timer);
 }
 
 bool AndroidVideoDecodeAccelerator::QueueInput() {
@@ skipping 149 matching lines @@
     TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutput");
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, &presentation_timestamp,
         &eos, NULL);
     TRACE_EVENT_END2("media", "AVDA::DequeueOutput", "status", status,
                      "presentation_timestamp (ms)",
                      presentation_timestamp.InMilliseconds());
 
     switch (status) {
       case media::MEDIA_CODEC_ERROR:
-        // Do not post an error if we are draining for reset and destroy.
+        // Do not post an error if we are draining for reset or destroy.
         // Instead, run the drain completion task.
         if (IsDrainingForResetOrDestroy()) {
           DVLOG(1) << __FUNCTION__ << ": error while codec draining";
           state_ = ERROR;
           OnDrainCompleted();
         } else {
           POST_ERROR(PLATFORM_FAILURE, "DequeueOutputBuffer failed.");
         }
         return false;
 
@@ skipping 245 matching lines @@
   }
 
   strategy_->ReuseOnePictureBuffer(i->second);
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::Flush() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  StartCodecDrain(DRAIN_FOR_FLUSH);
+  if (state_ == SURFACE_DESTROYED) {
+    NotifyFlushDone();
+  } else {
+    StartCodecDrain(DRAIN_FOR_FLUSH);
+  }
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // It's probably okay just to return here, since the codec will be configured
   // asynchronously.  It's unclear that any state for the new request could
   // be different, unless somebody modifies |codec_config_| while we're already
   // waiting for a codec.  One shouldn't do that for thread safety.
   DCHECK_NE(state_, WAITING_FOR_CODEC);
@@ skipping 45 matching lines @@
   return std::unique_ptr<media::VideoCodecBridge>(
       media::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));
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<media::VideoCodecBridge> media_codec) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(state_, WAITING_FOR_CODEC);
-
-  media_codec_ = std::move(media_codec);
+  DCHECK(state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED);
 
   // Record one instance of the codec being initialized.
   RecordFormatChangedMetric(FormatChangedValue::CodecInitialized);
 
-  strategy_->CodecChanged(media_codec_.get());
-
   // If we are supposed to notify that initialization is complete, then do so
   // now.  Otherwise, this is a reconfiguration.
   if (deferred_initialization_pending_) {
-    NotifyInitializationComplete(!!media_codec_);
+    // Losing the output surface is not considered an error state, so notify
+    // success. The client will destroy this soon.
+    NotifyInitializationComplete(state_ == SURFACE_DESTROYED ? true
+                                                             : !!media_codec);
     deferred_initialization_pending_ = false;
   }
 
+  // If |state_| changed to SURFACE_DESTROYED while we were configuring a codec,
+  // then the codec is already invalid so we return early and drop it.
+  if (state_ == SURFACE_DESTROYED)
+    return;
+
+  media_codec_ = std::move(media_codec);
+  strategy_->CodecChanged(media_codec_.get());
   if (!media_codec_) {
     POST_ERROR(PLATFORM_FAILURE, "Failed to create MediaCodec.");
     return;
   }
 
   state_ = NO_ERROR;
 
   ManageTimer(true);
 }
 
@@ skipping 55 matching lines @@
   }
   drain_type_ = DRAIN_TYPE_NONE;
 }
 
 void AndroidVideoDecodeAccelerator::ResetCodecState(
     const base::Closure& done_cb) {
   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 (state_ == WAITING_FOR_CODEC) {
+  // If the surface is destroyed there's nothing to do.
+  if (state_ == WAITING_FOR_CODEC || state_ == SURFACE_DESTROYED) {
     if (!done_cb.is_null())
       done_cb.Run();
     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 coec, i.e.
@@ skipping 106 matching lines @@
     StartCodecDrain(DRAIN_FOR_DESTROY);
   } else {
     ActualDestroy();
   }
 }
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (!on_destroying_surface_cb_.is_null()) {
+    AVDASurfaceTracker::GetInstance()->UnregisterOnDestroyingSurfaceCallback(
+        on_destroying_surface_cb_);
+  }
+
   // 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();
   }
   delete this;
 }
@@ skipping 33 matching lines @@
 
   DCHECK_LE(1u, picture_buffer.internal_texture_ids().size());
   gpu::gles2::TextureRef* texture_ref =
       texture_manager->GetTexture(picture_buffer.internal_texture_ids()[0]);
   RETURN_ON_FAILURE(this, texture_manager, "Null texture_ref", ILLEGAL_STATE,
                     nullptr);
 
   return texture_ref;
 }
 
+void SynchronouslyDrainCodec() {
+  // The timeout for dequeueing input/output buffers picked mostly arbitrarily.
+  // It's about as long as a working MediaCodec might conceivably delay before
+  // returning something. If the timeout is exceeded the MediaCodec might hang
+  // when we try to delete it later, but that's effectively the same thing as
+  // waiting longer here anyway.
+  const base::TimeDelta kTimeout = base::TimeDelta::FromSeconds(3);
+  strategy_->ReleaseCodecBuffers(output_picture_buffers_);
+
+  // If we're in the middle of a drain already, don't queue another EOS; just
+  // drain until we get the one already queued.
+  if (drain_type_ != DRAIN_TYPE_NONE) {
+    int input_buf_index = -1;
+    media::MediaCodecStatus status =
+        media_codec_->DequeueInputBuffer(kTimeout, &input_buf_index);

[liberato (no reviews please), 2016/05/04 14:19:56]

input buffers might become available after we decode output buffers.  i don't
think that one can do this only once.

it might be better to start a drain normally via StartCodecDrain, which queues
an EOS bitstream bfufer, then drive DoIOTask() here until done / timeout.  not
sure off-hand if you would need a new drain type, or if you can use DESTROY.

[watk, 2016/05/04 18:18:46]

Do we care about input buffers? We only need to queue one eos.
I can try that. I was hoping this would be simple enough to offset the code
duplication. DoIOTask has conditions that we have to audit and make sure we
don't break going forward.

[liberato (no reviews please), 2016/05/04 18:30:00]

my concern is how does one know that an input buffer will be available right
now?  maybe they're all full, pending avda releasing an output buffer to decode
the next input buffer into.

+    if (status != media::MEDIA_CODEC_OK)
+      return;
+    DCHECK_NE(input_buf_index, -1);
+
+    media_codec_->QueueEOS(input_buf_index);
+  }
+
+  // Drain all of the output buffers.
+  for (;;) {
+    int32_t buf_index = -1;
+    size_t offset = 0;
+    size_t size = 0;
+    base::TimeDelta presentation_timestamp;
+    bool eos = false;
+    media::MediaCodecStatus status =
+        media_codec_->DequeueOutputBuffer(kTimeout, &buf_index, &offset, &size,
+                                          &presentation_timestamp, &eos, NULL);
+    switch (status) {
+      case media::MEDIA_CODEC_ERROR:
+      case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+        return;
+      case media::MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
+      case media::MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
+        continue;
+      case media::MEDIA_CODEC_OK:
+        DCHECK_GE(buf_index, 0);
+        if (eos)
+          return;
+        media_codec_->ReleaseOutputBuffer(buf_index, false);
+    }
+  }
+}
+
+void AndroidVideoDecodeAccelerator::OnDestroyingSurface(int surface_id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  TRACE_EVENT0("media", "AVDA::OnDestroyingSurface");
+  DVLOG(1) << __FUNCTION__ << " surface_id: " << surface_id;
+
+  if (surface_id != surface_id_)
+    return;
+
+  // Some VP8 files require a complete MediaCodec drain before we can call
+  // MediaCodec.flush() or MediaCodec.reset() so we must synchronously drain
+  // the MediaCodec here. http://crbug.com/598963.
+  if (media_codec_ && codec_config_->codec_ == media::kCodecVP8)
+    SynchronouslyDrainCodec();
+
+  // If we're currently asynchronously configuring a codec, it will be destroyed
+  // when configuration completes and it notices that |state_| has changed to
+  // SURFACE_DESTROYED.
+  state_ = SURFACE_DESTROYED;
+  if (media_codec_) {
+    media_codec_.reset();
+    strategy_->CodecChanged(media_codec_.get());
+  }
+
+  // If we're draining, signal completion now because either the drain was
+  // finished above, or the drain can no longer proceed anyway.
+  if (drain_type_ != DRAIN_TYPE_NONE)
+    OnDrainCompleted();
+}
+
 void AndroidVideoDecodeAccelerator::OnFrameAvailable() {
   // Remember: this may be on any thread.
   DCHECK(strategy_);
   strategy_->OnFrameAvailable();
 }
 
 void AndroidVideoDecodeAccelerator::PostError(
     const ::tracked_objects::Location& from_here,
     media::VideoDecodeAccelerator::Error error) {
   base::MessageLoop::current()->PostDelayedTask(
@@ skipping 168 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media