AndroidVideoDecodeAccelerator can now render to a SurfaceView

content/common/gpu/media/android_deferred_rendering_backing_strategy.cc

Index: content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
diff --git a/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc b/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
index 0bec437888ff5b68ab2ec5459930bd9f975eacc3..9b4eb2e2fc3ada83018bef8056ff5a51ce495308 100644
--- a/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
+++ b/content/common/gpu/media/android_deferred_rendering_backing_strategy.cc
@@ -20,15 +20,18 @@ namespace content {
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy()
-    : state_provider_(nullptr), media_codec_(nullptr) {}
+    : state_provider_(nullptr), surface_kind_(UNKNOWN), media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
 void AndroidDeferredRenderingBackingStrategy::Initialize(

[liberato (no reviews please), 2016/01/26 21:48:45]

Initialize(state_provider, surface_id (which may be kNullSurfaceID) would end up
requiring only very small changes to the existing code.

-    AVDAStateProvider* state_provider) {
+    AVDAStateProvider* state_provider,
+    scoped_refptr<gfx::SurfaceTexture> surface_texture) {
   state_provider_ = state_provider;
+  surface_texture_ = surface_texture;
   shared_state_ = new AVDASharedState();
+  surface_kind_ = surface_texture ? SURFACE_TEXTURE : SURFACE_VIEW;
 
   // Create a texture for the SurfaceTexture to use.  We don't attach it here
   // so that it gets attached in the compositor gl context in the common case.
@@ -57,17 +60,6 @@ uint32_t AndroidDeferredRenderingBackingStrategy::GetTextureTarget() const {
   return GL_TEXTURE_EXTERNAL_OES;
 }
 
-scoped_refptr<gfx::SurfaceTexture>
-AndroidDeferredRenderingBackingStrategy::CreateSurfaceTexture() {
-  // AVDACodecImage will handle attaching this to a texture later.
-  surface_texture_ = gfx::SurfaceTexture::Create(0);
-  // Detach from our GL context so that the GLImages can attach.  It will
-  // silently fail to delete texture 0.
-  surface_texture_->DetachFromGLContext();
-
-  return surface_texture_;
-}
-
 gpu::gles2::TextureRef*
 AndroidDeferredRenderingBackingStrategy::GetTextureForPicture(
     const media::PictureBuffer& picture_buffer) {
@@ -116,15 +108,25 @@ void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
         shared_state_->surface_texture_service_id());
 
     static_cast<AVDACodecImage*>(image.get())
-        ->setTexture(texture_ref->texture());
+        ->SetTexture(texture_ref->texture());
   } else {
     // Clear the unowned service_id, so that this texture is no longer going
     // to depend on the surface texture at all.
     texture_ref->texture()->SetUnownedServiceId(0);
   }
 
+  // For SurfaceTexture we set the image to UNBOUND so that the implementation
+  // will call CopyTexImage, which is where AVDACodecImage updates the
+  // SurfaceTexture to the right frame.
+  // For SurfaceView we set the image to be BOUND because ScheduleOverlayPlane
+  // expects it. If something tries to sample from this texture it won't work,
+  // but there's no way to sample from a SurfaceView anyway, so it doesn't
+  // matter. The only way to use this texture is to schedule it as an overlay.
+  const gpu::gles2::Texture::ImageState image_state =
+      (surface_kind_ == SURFACE_VIEW) ? gpu::gles2::Texture::BOUND
+                                      : gpu::gles2::Texture::UNBOUND;
   texture_manager->SetLevelImage(texture_ref, GetTextureTarget(), 0,
-                                 image.get(), gpu::gles2::Texture::UNBOUND);
+                                 image.get(), image_state);
 }
 
 void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
@@ -135,36 +137,36 @@ void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
 
   // Notify the AVDACodecImage for picture_buffer that it should use the
   // decoded buffer codec_buf_index to render this frame.
-  AVDACodecImage* avImage = GetImageForPicture(picture_buffer);
-  RETURN_IF_NULL(avImage);
-  DCHECK_EQ(avImage->GetMediaCodecBufferIndex(), -1);
+  AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
+  RETURN_IF_NULL(avda_image);
+  DCHECK_EQ(avda_image->GetMediaCodecBufferIndex(), -1);
   // Note that this is not a race, since we do not re-use a PictureBuffer
   // until after the CC is done drawing it.
-  avImage->SetMediaCodecBufferIndex(codec_buf_index);
-  avImage->SetSize(state_provider_->GetSize());
+  avda_image->SetMediaCodecBufferIndex(codec_buf_index);
+  avda_image->SetSize(state_provider_->GetSize());
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
-  scoped_refptr<gl::GLImage> gl_image(
+  scoped_refptr<gl::GLImage> gl_image =
       new AVDACodecImage(shared_state_, media_codec_,
-                         state_provider_->GetGlDecoder(), surface_texture_));
+                         state_provider_->GetGlDecoder(), surface_texture_);
   SetImageForPicture(picture_buffer, gl_image);
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBufferForPicture(
     const media::PictureBuffer& picture_buffer) {
-  AVDACodecImage* avImage = GetImageForPicture(picture_buffer);
+  AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
 
   // See if there is a media codec buffer still attached to this image.
-  const int32_t codec_buffer = avImage->GetMediaCodecBufferIndex();
+  const int32_t codec_buffer = avda_image->GetMediaCodecBufferIndex();
 
   if (codec_buffer >= 0) {
     // PictureBuffer wasn't displayed, so release the buffer.
     media_codec_->ReleaseOutputBuffer(codec_buffer, false);
-    avImage->SetMediaCodecBufferIndex(-1);
+    avda_image->SetMediaCodecBufferIndex(-1);
   }
 }
 
@@ -196,9 +198,9 @@ void AndroidDeferredRenderingBackingStrategy::CodecChanged(
   // doesn't know about them.
   media_codec_ = codec;
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
-    AVDACodecImage* avImage = GetImageForPicture(entry.second);
-    avImage->SetMediaCodec(codec);
-    avImage->SetMediaCodecBufferIndex(-1);
+    AVDACodecImage* avda_image = GetImageForPicture(entry.second);
+    avda_image->SetMediaCodec(codec);
+    avda_image->SetMediaCodecBufferIndex(-1);
   }
 }