Add ContentVideoViewOverlay to 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 17 matching lines @@
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_bridge_impl.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/gpu/avda_picture_buffer_manager.h"
+#include "media/gpu/content_video_view_overlay.h"
 #include "media/gpu/shared_memory_region.h"
 #include "media/video/picture.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_bindings.h"
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 #include "media/mojo/services/mojo_cdm_service.h"
 #endif
 
@@ skipping 309 matching lines @@
 
   // 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_);
 
+  // We should not yet have an overlay.
+  DCHECK(!incoming_bundle_->overlay);
+
+  // Note that we don't enforce that for any SurfaceTexture or its Surface,
+  // since there might be a codec that's using them.  They'll get cleared
+  // later, in InitializePictureBufferManager.
+
   // 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, incoming_bundle_->surface_id)) {
+  if (incoming_bundle_->surface_id != SurfaceManager::kNoSurfaceID) {
+    // Create the overlay.  Note that it will never call us back immediately.
+    // It will post when the surface is available.
+    AndroidOverlay::Config overlay_config;
+    // We use weak ptrs here since |overlay| can outlive us, if we send it for
+    // async codec config.
+    overlay_config.ready_cb =
+        base::Bind(&AndroidVideoDecodeAccelerator::OnOverlayReady,
+                   weak_this_factory_.GetWeakPtr());
+    overlay_config.failed_cb =
+        base::Bind(&AndroidVideoDecodeAccelerator::OnOverlayFailed,
+                   weak_this_factory_.GetWeakPtr());
+    overlay_config.destroyed_cb =
+        base::Bind(&AndroidVideoDecodeAccelerator::OnSurfaceDestroyed,
+                   weak_this_factory_.GetWeakPtr());
+    // TODO(liberato): make |surface_id| the overlay config token.  If we're
+    // using CVV, then we'll need a CVV factory impl that understands it.
+    incoming_bundle_->overlay = base::MakeUnique<ContentVideoViewOverlay>(
+        codec_allocator_, incoming_bundle_->surface_id, overlay_config);
     // We have to wait for some other AVDA instance to free up the surface.
-    // OnSurfaceAvailable will be called when it's available.
+    // OnOverlayReady 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.
+    // Also remember that ContentVideoViewOverlay will not call OnOverlayReady
+    // before it returns.
     state_ = WAITING_FOR_SURFACE;
     return;
   }
 
-  // We now own the surface, so finish initialization.
+  // We're creating a SurfaceTexture.
   InitializePictureBufferManager();
 }
 
-void AndroidVideoDecodeAccelerator::OnSurfaceAvailable(bool success) {
+void AndroidVideoDecodeAccelerator::OnOverlayReady() {
   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();
+}
 
-  InitializePictureBufferManager();
+void AndroidVideoDecodeAccelerator::OnOverlayFailed() {
+  NOTIFY_ERROR(PLATFORM_FAILURE, "Surface is not available");
 }
 
 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");
+    incoming_bundle_ = nullptr;
     return;
   }
 
   // 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;
+  // TODO(liberato): it doesn't make sense anymore for the PictureBufferManager
+  // to create the surface texture.  We can probably make an overlay impl out
+  // of it, and provide the surface texture to |picture_buffer_manager_|.
+  if (incoming_bundle_->overlay) {
+    picture_buffer_manager_.InitializeForOverlay();
+  } else {
+    incoming_bundle_->surface_texture_surface =
+        picture_buffer_manager_.InitializeForSurfaceTexture();
+    incoming_bundle_->surface_texture =
+        picture_buffer_manager_.surface_texture();
+
+    if (!incoming_bundle_->surface_texture) {
+      NOTIFY_ERROR(PLATFORM_FAILURE, "Could not allocate surface texture");
+      incoming_bundle_ = nullptr;
+      return;
+    }
   }
 
   // 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(
-            incoming_bundle_->surface.j_surface().obj())) {
+    if (!media_codec_->SetSurface(incoming_bundle_->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_;
       // We could be in WAITING_FOR_SURFACE, but we're not anymore.
       state_ = NO_ERROR;
     }
     incoming_bundle_ = nullptr;
     return;
@@ skipping 202 matching lines @@
 
   // If we're waiting to switch surfaces pause output release until we have all
   // picture buffers returned. This is so we can ensure the right flags are set
   // on the picture buffers returned to the client.
   if (pending_surface_id_) {
     if (picture_buffer_manager_.HasUnrenderedPictures())
       return false;
     if (!UpdateSurface())
       return false;
     // If we can't allocate the incoming surface yet, then stop here.
-    if (state_ == WAITING_FOR_SURFACE)
+    if (state_ != NO_ERROR)
       return false;
   }
 
   bool eos = false;
   base::TimeDelta presentation_timestamp;
   int32_t buf_index = 0;
   do {
     size_t offset = 0;
     size_t size = 0;
 
@@ skipping 338 matching lines @@
   std::unique_ptr<MediaCodecBridge> media_codec =
       AVDACodecAllocator::Instance()->CreateMediaCodecSync(codec_config_);
   // Note that |media_codec| might be null, which will NotifyError.
   OnCodecConfigured(std::move(media_codec));
 }
 
 void AndroidVideoDecodeAccelerator::OnCodecConfigured(
     std::unique_ptr<MediaCodecBridge> 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
   // before returning.  Otherwise, this is a reconfiguration.
 
   // 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.
   // TODO(liberato): We're going to drop the codec when |media_codec| goes out
   // of scope, on this thread.  We really should post it to the proper thread
   // to avoid potentially hanging.
   if (state_ == SURFACE_DESTROYED) {
     if (deferred_initialization_pending_) {
@@ skipping 123 matching lines @@
   // Flush the codec if possible, or create a new one if not.
   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);
+    // Note that this will release the codec, then allocate a new one.  It will
+    // not wait for the old one to finish up with the surface, which is bad.
+    // It works (usually) because it ends up allocating the codec on the same
+    // thread as is used to release the old one, so it's serialized anyway.
     ConfigureMediaCodecAsynchronously();
   }
 }
 
 void AndroidVideoDecodeAccelerator::Reset() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Reset");
 
   if (defer_surface_creation_) {
@@ skipping 56 matching lines @@
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // 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, surface_id());
-
   delete this;
 }
 
 bool AndroidVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 const gfx::Size& AndroidVideoDecodeAccelerator::GetSize() const {
@@ skipping 301 matching lines @@
   return !config_.is_encrypted() && (codec_config_->codec == kCodecVP8 ||
                                      codec_config_->codec == kCodecVP9);
 }
 
 bool AndroidVideoDecodeAccelerator::UpdateSurface() {
   DCHECK(pending_surface_id_);
   DCHECK_NE(surface_id(), pending_surface_id_.value());
   DCHECK(surface_id() == SurfaceManager::kNoSurfaceID ||
          pending_surface_id_.value() == SurfaceManager::kNoSurfaceID);
 
-  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.
   // 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.  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.
-  // This is the only case where we start a new incoming bundle, and we maintain
-  // the property that |incoming_bundle_| is the one that we own, as documented
-  // for surface_id().
-  // 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,
                                       codec_config_->surface_bundle);
 }
 
 }  // namespace media