Group AVDA output surface into AVDASurfaceBundle.

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 224 matching lines @@
       state_(WAITING_FOR_SURFACE),
       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);
   codec_allocator_->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 26 matching lines @@
     return false;
   }
 
   DCHECK(client);
   client_ = client;
   config_ = config;
   codec_config_ = new CodecConfig();
   codec_config_->codec = VideoCodecProfileToVideoCodec(config.profile);
   codec_config_->initial_expected_coded_size =
       config.initial_expected_coded_size;
+  incoming_bundle_ = new AVDASurfaceBundle(config_.surface_id);
 
   if (codec_config_->codec != kCodecVP8 && codec_config_->codec != kCodecVP9 &&
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       codec_config_->codec != kCodecHEVC &&
 #endif
       codec_config_->codec != kCodecH264) {
     DLOG(ERROR) << "Unsupported profile: " << GetProfileName(config.profile);
     return false;
   }
 
@@ skipping 22 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(codec_allocator_, config_.surface_id,
+  if (ShouldDeferSurfaceCreation(codec_allocator_, surface_id(),
                                  codec_config_->codec)) {
     // We should never be here if a SurfaceView is required.
-    DCHECK_EQ(config_.surface_id, SurfaceManager::kNoSurfaceID);
+    DCHECK_EQ(surface_id(), SurfaceManager::kNoSurfaceID);
     defer_surface_creation_ = true;
   }
 
   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";
       return false;
     }
     InitializeCdm();
   } else {
     StartSurfaceCreation();
   }
 
   // Fail / complete / defer initialization.
   return state_ != ERROR;
 }
 
 void AndroidVideoDecodeAccelerator::StartSurfaceCreation() {
   // We might be called during Initialize, during deferred initialization, or
   // afterwards (::Decode, for deferred surface init, UpdateSurface).
+  DCHECK(incoming_bundle_);
 
   // If surface creation is deferred, then do nothing except signal that init
   // is complete, if needed.  We might still fail to get a surface or codec,
   // which would normally be an init error.  Since we're deferring init until a
   // 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 (!codec_allocator_->AllocateSurface(this, config_.surface_id)) {
+  if (!codec_allocator_->AllocateSurface(this, incoming_bundle_->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.
     state_ = WAITING_FOR_SURFACE;
     return;
   }
 
   // We now own the surface, so finish initialization.
   InitializePictureBufferManager();
 }
 
 void AndroidVideoDecodeAccelerator::OnSurfaceAvailable(bool success) {
   DCHECK(!defer_surface_creation_);
   DCHECK_EQ(state_, WAITING_FOR_SURFACE);
+  DCHECK(incoming_bundle_);
 
   if (!success) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "Surface is not available");
+    incoming_bundle_ = nullptr;
     return;
   }
 
   InitializePictureBufferManager();
 }
 
 void AndroidVideoDecodeAccelerator::InitializePictureBufferManager() {
   DCHECK(!defer_surface_creation_);
+  DCHECK(incoming_bundle_);
 
   if (!make_context_current_cb_.Run()) {
     NOTIFY_ERROR(PLATFORM_FAILURE,
                  "Failed to make this decoder's GL context current");
     return;
   }
 
-  codec_config_->surface =
-      picture_buffer_manager_.Initialize(config_.surface_id);
-  codec_config_->surface_texture = picture_buffer_manager_.surface_texture();
-  if (codec_config_->surface.IsEmpty()) {
+  // Move |incoming_bundle_| to |codec_config_|.  Our caller must set up an
+  // incoming bundle properly, since we don't want to accidentally overwrite
+  // |surface_bundle| for a codec that's being released elsewhere.
+  incoming_bundle_->surface = picture_buffer_manager_.Initialize(surface_id());
+  incoming_bundle_->surface_texture = picture_buffer_manager_.surface_texture();
+  if (incoming_bundle_->surface.IsEmpty()) {
     NOTIFY_ERROR(PLATFORM_FAILURE, "Codec surface is empty");
+    incoming_bundle_ = nullptr;
     return;
   }
 
-  // If we have a media codec, then setSurface.  If that doesn't work, then we
+  // If we have a media codec, then SetSurface.  If that doesn't work, then we
   // do not try to allocate a new codec; we might not be at a keyframe, etc.
   // If we get here with a codec, then we must setSurface.
   if (media_codec_) {
     // TODO(liberato): fail on api check?
-    if (!media_codec_->SetSurface(codec_config_->surface.j_surface().obj())) {
+    if (!media_codec_->SetSurface(
+            incoming_bundle_->surface.j_surface().obj())) {
       NOTIFY_ERROR(PLATFORM_FAILURE, "MediaCodec failed to switch surfaces.");
+      // We're not going to use |incoming_bundle_|.
+    } else {
+      // We've switched surfaces, so replace |surface_bundle|.
+      codec_config_->surface_bundle = incoming_bundle_;
+      state_ = NO_ERROR;

[watk, 2017/02/22 20:38:55]

I don't think we should be changing state_ here?

[liberato (no reviews please), 2017/02/23 18:18:46]

it can be WAITING_FOR_SURFACE if it came through OnSurfaceAvailable.  i'd
actually prefer it if it were always WAITING_FOR_SURFACE when calling InitPBM,
or even some new JUST_GOT_SURFACE state.  not today, though.  :)

i'll add a comment.

     }
+    incoming_bundle_ = nullptr;
     return;
   }
 
+  // We're going to create a codec with |incoming_bundle_|.  It might fail, but
+  // either way, we're done with any previous bundle.  Note that, since we
+  // never get here after init (i.e., we never change surfaces without using
+  // SetSurface), there shouldn't be any previous bundle.  However, this is the
+  // right thing to do even if we can switch.
+  codec_config_->surface_bundle = incoming_bundle_;
+  incoming_bundle_ = nullptr;
+
   // If the client doesn't support deferred initialization (WebRTC), then we
   // should complete it now and return a meaningful result.  Note that it would
   // be nice if we didn't have to worry about starting codec configuration at
   // all (::Initialize or the wrapper can do it), but then they have to remember
   // not to start codec config if we have to wait for the cdm.  It's somewhat
   // clearer for us to handle both cases.
   // For this to be a case for sync configuration, we must be called from
   // Initialize(), and the client must not want deferred init.  Note that having
   // |deferred_initialization_pending_| false by itself isn't enough; if we're
   // deferring surface creation, then we'll finish deferred init before asking
@@ skipping 727 matching lines @@
   bitstreams_notified_in_advance_.clear();
 
   picture_buffer_manager_.ReleaseCodecBuffers(output_picture_buffers_);
   StartCodecDrain(DRAIN_FOR_RESET);
 }
 
 void AndroidVideoDecodeAccelerator::SetSurface(int32_t surface_id) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (surface_id == config_.surface_id) {
+  if (surface_id == this->surface_id()) {

[watk, 2017/02/22 20:38:55]

remove this->

[liberato (no reviews please), 2017/02/23 18:18:46]

can't.  |surface_id| shadows the method.

     pending_surface_id_.reset();
     return;
   }
 
   // Surface changes never take effect immediately, they will be handled during
   // DequeOutput() once we get to a good switch point or immediately during an
   // OnSurfaceDestroyed() call.
   pending_surface_id_ = surface_id;
 }
 
@@ skipping 15 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.
-  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) {
-    codec_allocator_->TaskRunnerFor(last_release_task_type_)
-        ->PostTaskAndReply(
-            FROM_HERE, base::Bind(&base::DoNothing),
-            base::Bind(&gl::SurfaceTexture::ReleaseSurfaceTexture,
-                       codec_config_->surface_texture));
-  }
+  codec_allocator_->DeallocateSurface(this, surface_id());

[watk, 2017/02/22 20:38:55]

If we have an incoming SurfaceBundle, we don't want to deallocate that surface
do we? We should deallocate the config one? Or at least both of them?

[liberato (no reviews please), 2017/02/23 18:18:46]

having |incoming_bundle_| implies that there is no allocated surface in
|current_config_|, either because there's no bundle in |current_config_| at all
(i.e., during init), or because UpdateSurface already deallocated the outgoing
surface.

this is tricky and weird.  better would be for it to be handled by the
SurfaceBundle, but that's not straightforward either.  SurfaceBundle would have
to (a) become the allocator client, and (b) WP back to AVDA to prevent callbacks
after ActualDestroy.  even then, i'm not sure that there aren't weird issues
with unexpected callbacks on a pending-destruction SurfaceBundle.

i'm leaving that for future work.

 
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
@@ skipping 20 matching lines @@
 
   // If the API is available avoid having to restart the decoder in order to
   // leave fullscreen. If we don't clear the surface immediately during this
   // callback, the MediaCodec will throw an error as the surface is destroyed.
   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 23) {
     // Since we can't wait for a transition, we must invalidate all outstanding
     // picture buffers to avoid putting the GL system in a broken state.
     picture_buffer_manager_.ReleaseCodecBuffers(output_picture_buffers_);
 
     // Switch away from the surface being destroyed to a surface texture.
-    DCHECK_NE(config_.surface_id, SurfaceManager::kNoSurfaceID);
+    DCHECK_NE(surface_id(), SurfaceManager::kNoSurfaceID);
 
     // The leaving fullscreen notification may come in before this point.
     if (pending_surface_id_)
       DCHECK_EQ(pending_surface_id_.value(), SurfaceManager::kNoSurfaceID);
 
     pending_surface_id_ = SurfaceManager::kNoSurfaceID;
     UpdateSurface();
     // Switching to a SurfaceTexture should never need to wait.  If it does,
     // then the codec might still be using the destroyed surface, which is bad.
     DCHECK_NE(state_, WAITING_FOR_SURFACE);
@@ skipping 257 matching lines @@
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted() && (codec_config_->codec == kCodecVP8 ||
                                      codec_config_->codec == kCodecVP9);
 }
 
 bool AndroidVideoDecodeAccelerator::UpdateSurface() {
   DCHECK(pending_surface_id_);
-  DCHECK_NE(config_.surface_id, pending_surface_id_.value());
-  DCHECK(config_.surface_id == SurfaceManager::kNoSurfaceID ||
+  DCHECK_NE(surface_id(), pending_surface_id_.value());
+  DCHECK(surface_id() == SurfaceManager::kNoSurfaceID ||
          pending_surface_id_.value() == SurfaceManager::kNoSurfaceID);
 
-  const int previous_surface_id = config_.surface_id;
+  const int previous_surface_id = surface_id();
   const int new_surface_id = pending_surface_id_.value();
   pending_surface_id_.reset();
 
   // Start surface creation.  Note that if we're called via surfaceDestroyed,
   // then this must complete synchronously or it will DCHECK.  Otherwise, we
   // might still be using the destroyed surface.  We don't enforce this, but
   // it's worth remembering that there are cases where it's required.
-  config_.surface_id = new_surface_id;
+  // Note that we don't re-use |surface_bundle|, since the codec is using it!
+  incoming_bundle_ = new AVDASurfaceBundle(new_surface_id);
   StartSurfaceCreation();
   if (state_ == ERROR) {
     // This might be called from OnSurfaceDestroyed(), so we have to release the
     // MediaCodec if we failed to switch the surface.  We reset the surface ID
     // to the previous one, since failures never result in the codec using the
     // new surface.  This is only guaranteed because of how OnCodecConfigured
     // works.  If it could fail after getting a codec, then this assumption
     // wouldn't be necessarily true anymore.
     // Also note that we might not have switched surfaces yet, which is also bad
     // for OnSurfaceDestroyed, because of WAITING_FOR_SURFACE.  Shouldn't
-    // happen with SurfaceTexture, and OnSurfaceDestroyed checks for it.
-    config_.surface_id = previous_surface_id;
+    // happen with SurfaceTexture, and OnSurfaceDestroyed checks for it.  In
+    // either case, we definitely should not still have an incoming bundle; it
+    // should have been dropped.
+    DCHECK(!incoming_bundle_);
     ReleaseCodec();
+    // We no longer own the new surface.
     codec_allocator_->DeallocateSurface(this, new_surface_id);
   }
 
   // Regardless of whether we succeeded, we no longer own the previous surface.
+  // It would be nice if the outgoing surface bundle did this.
+  // TODO(liberato): It could, but the CVV implementation of AndroidOverlay
+  // will do it too when the bundle holding it is dropped.  We'll do it this way
+  // until then, just to minimize changes.
   codec_allocator_->DeallocateSurface(this, previous_surface_id);
 
   return state_ != ERROR;
 }
 
 void AndroidVideoDecodeAccelerator::ReleaseCodec() {
   if (!media_codec_)
     return;
 
   picture_buffer_manager_.CodecChanged(nullptr);
-  codec_allocator_->ReleaseMediaCodec(
-      std::move(media_codec_), codec_config_->task_type, config_.surface_id);
-  last_release_task_type_ = codec_config_->task_type;
+  codec_allocator_->ReleaseMediaCodec(std::move(media_codec_),
+                                      codec_config_->task_type,
+                                      codec_config_->surface_bundle);
 }
 
 }  // namespace media