Made full screen video with DevTools not flash black on Android.

content/common/gpu/media/android_deferred_rendering_backing_strategy.cc

 // Copyright 2015 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 "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
@@ skipping 23 matching lines @@
 // clang-format off
 const float kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
                                    0.0f, 1.0f, 0.0f, 0.0f,
                                    0.0f, 0.0f, 1.0f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f};
 // clang-format on
 }
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy(AVDAStateProvider* state_provider)
-    : state_provider_(state_provider), media_codec_(nullptr) {}
+    : state_provider_(state_provider),
+      transparent_image_(EGL_NO_IMAGE_KHR),
+      media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
 gfx::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
     int surface_view_id) {
   shared_state_ = new AVDASharedState();
 
   // 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.
   GLuint service_id = 0;
   glGenTextures(1, &service_id);
   DCHECK(service_id);
   shared_state_->set_surface_texture_service_id(service_id);
 
   gfx::ScopedJavaSurface surface;
   if (surface_view_id != media::VideoDecodeAccelerator::Config::kNoSurfaceID) {
     surface =
         GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(surface_view_id);
+
+    // We will attach a transparent image to the PictureBuffer textures, so
+    // that the device inspector still works.  In addition to drawing them
+    // as overlays, it will draw them as normal quads, too.  The transparent
+    // image lets the SurfaceView show through on the device.
+    transparent_image_ = CreateImageFromTexture(base::Bind(
+        &AndroidDeferredRenderingBackingStrategy::InitTransparentTexture,
+        base::Unretained(this)));
   } else {
     if (DoesSurfaceTextureDetachWork()) {
       // Create a detached SurfaceTexture. Detaching it will silently fail to
       // delete texture 0.
       surface_texture_ = gfx::SurfaceTexture::Create(0);
       surface_texture_->DetachFromGLContext();
     } else {
       // Detach doesn't work so well on all platforms.  Just attach the
       // SurfaceTexture here, and probably context switch later.
       surface_texture_ = gfx::SurfaceTexture::Create(service_id);
       shared_state_->DidAttachSurfaceTexture();
     }
     surface = gfx::ScopedJavaSurface(surface_texture_.get());
   }
 
   return surface;
 }
 
 void AndroidDeferredRenderingBackingStrategy::Cleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
     return;
 
+  if (have_context && transparent_image_ != EGL_NO_IMAGE_KHR) {

[no sievers, 2016/03/25 23:23:00]

does it really need a context for the EGL call?

[liberato (no reviews please), 2016/03/26 17:59:09]

thanks!  i just assumed it needed one since creating the image does.  i didn't
realize that the context was needed only for the source texture, which makes
quite a bit of sense in retrospect :)

+    EGLBoolean result = eglDestroyImageKHR(
+        gfx::GLSurfaceEGL::GetHardwareDisplay(), transparent_image_);
+    if (result == EGL_FALSE) {
+      DLOG(ERROR) << "Error destroying transparent EGLImage: "
+                  << ui::GetLastEGLErrorString();
+      // Continue with cleanup anyway.
+    }
+  }
+
   // Make sure that no PictureBuffer textures refer to the SurfaceTexture or to
   // the service_id that we created for it.
   for (const std::pair<int, media::PictureBuffer>& entry : buffers)
     SetImageForPicture(entry.second, nullptr);
 
   // If we're rendering to a SurfaceTexture we can make a copy of the current
   // front buffer so that the PictureBuffer textures are still valid.
   if (surface_texture_ && have_context)
     CopySurfaceTextureToPictures(buffers);
 
@@ skipping 81 matching lines @@
   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.
   avda_image->SetMediaCodecBufferIndex(codec_buf_index);
   avda_image->SetSize(state_provider_->GetSize());
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
-    const media::PictureBuffer& picture_buffer) {
+    const media::PictureBuffer& picture_buffer,
+    bool have_context) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
   scoped_refptr<gpu::gles2::GLStreamTextureImage> gl_image =
       new AVDACodecImage(shared_state_, media_codec_,
                          state_provider_->GetGlDecoder(), surface_texture_);
   SetImageForPicture(picture_buffer, gl_image);
+
+  if (!surface_texture_ && transparent_image_ != EGL_NO_IMAGE_KHR) {
+    // Attach a transparent image if we're using SurfaceView, so that devtools
+    // draws that.  It lets us see through to the SV on the device, since it's
+    // drawn there too.  Without devtools, this image is never drawn.
+    gpu::gles2::TextureRef* texture_ref =
+        state_provider_->GetTextureForPicture(picture_buffer);
+    if (have_context && texture_ref) {
+      gfx::ScopedTextureBinder texture_binder(
+          GL_TEXTURE_EXTERNAL_OES, texture_ref->texture()->service_id());
+      glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, transparent_image_);
+      DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+    }
+  }
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBufferForPicture(
     const media::PictureBuffer& 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 = avda_image->GetMediaCodecBufferIndex();
 
   if (codec_buffer >= 0) {
@@ skipping 48 matching lines @@
 }
 
 void AndroidDeferredRenderingBackingStrategy::UpdatePictureBufferSize(
     media::PictureBuffer* picture_buffer,
     const gfx::Size& new_size) {
   // This strategy uses EGL images which manage the texture size for us.  We
   // simply update the PictureBuffer meta-data and leave the texture as-is.
   picture_buffer->set_size(new_size);
 }
 
+bool AndroidDeferredRenderingBackingStrategy::InitTextureWithCopy(
+    GLint source_id) {
+  gpu::gles2::GLES2Decoder* gl_decoder = state_provider_->GetGlDecoder().get();
+  if (!gl_decoder)
+    return false;
+
+  const gfx::Size size = state_provider_->GetSize();
+
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+  gpu::CopyTextureCHROMIUMResourceManager copier;
+  copier.Initialize(
+      gl_decoder,
+      gl_decoder->GetContextGroup()->feature_info()->feature_flags());
+  copier.DoCopyTextureWithTransform(
+      gl_decoder, GL_TEXTURE_EXTERNAL_OES,
+      shared_state_->surface_texture_service_id(), GL_TEXTURE_2D, source_id,
+      size.width(), size.height(), false, false, false, kIdentityMatrix);
+
+  return true;
+}
+
+bool AndroidDeferredRenderingBackingStrategy::InitTransparentTexture(
+    GLint source_id) {
+  unsigned char rgba[] = {0, 0, 0, 0};
+  const gfx::Size size(1, 1);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
+               GL_RGBA, GL_UNSIGNED_BYTE, rgba);
+  return true;
+}
+
 void AndroidDeferredRenderingBackingStrategy::CopySurfaceTextureToPictures(
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   DVLOG(3) << __FUNCTION__;
 
   // Don't try to copy if the SurfaceTexture was never attached because that
   // means it was never updated.
   if (!shared_state_->surface_texture_is_attached())
     return;
 
-  gpu::gles2::GLES2Decoder* gl_decoder = state_provider_->GetGlDecoder().get();
-  if (!gl_decoder)
-    return;
-
   // Mali + <= KitKat crashes when we try to do this.  We don't know if it's
   // due to detaching a surface texture, but it's the same set of devices.
   if (!DoesSurfaceTextureDetachWork())
     return;
 
-  const gfx::Size size = state_provider_->GetSize();
-
-  // Create a 2D texture to hold a copy of the SurfaceTexture's front buffer.
-  GLuint tmp_texture_id;
-  glGenTextures(1, &tmp_texture_id);
-  {
-    gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, tmp_texture_id);
-    // The target texture's size will exactly match the source.
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
-                 GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
-  }
-
-  // TODO(liberato,watk): Use the SurfaceTexture matrix when copying.
-  gpu::CopyTextureCHROMIUMResourceManager copier;
-  copier.Initialize(
-      gl_decoder,
-      gl_decoder->GetContextGroup()->feature_info()->feature_flags());
-  copier.DoCopyTextureWithTransform(gl_decoder, GL_TEXTURE_EXTERNAL_OES,
-                                    shared_state_->surface_texture_service_id(),
-                                    GL_TEXTURE_2D, tmp_texture_id, size.width(),
-                                    size.height(), false, false, false,
-                                    kIdentityMatrix);
-
-  // Create an EGLImage from the 2D texture we just copied into. By associating
-  // the EGLImage with the PictureBuffer textures they will remain valid even
-  // after we delete the 2D texture and EGLImage.
-  const EGLImageKHR egl_image = eglCreateImageKHR(
-      gfx::GLSurfaceEGL::GetHardwareDisplay(), eglGetCurrentContext(),
-      EGL_GL_TEXTURE_2D_KHR, reinterpret_cast<EGLClientBuffer>(tmp_texture_id),
-      nullptr /* attrs */);
-
-  glDeleteTextures(1, &tmp_texture_id);
-  DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+  EGLImageKHR egl_image = CreateImageFromTexture(
+      base::Bind(&AndroidDeferredRenderingBackingStrategy::InitTextureWithCopy,
+                 base::Unretained(this)));
 
   if (egl_image == EGL_NO_IMAGE_KHR) {
-    DLOG(ERROR) << "Failed creating EGLImage: " << ui::GetLastEGLErrorString();
+    DLOG(ERROR) << "Failed creating EGLImage for full screen transition: "
+                << ui::GetLastEGLErrorString();
     return;
   }
 
   for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
     gpu::gles2::TextureRef* texture_ref =
         state_provider_->GetTextureForPicture(entry.second);
     if (!texture_ref)
       continue;
     gfx::ScopedTextureBinder texture_binder(
         GL_TEXTURE_EXTERNAL_OES, texture_ref->texture()->service_id());
     glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 
   EGLBoolean result =
       eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), egl_image);
   if (result == EGL_FALSE) {
-    DLOG(ERROR) << "Error destroying EGLImage: "
+    DLOG(ERROR) << "Error destroying EGLImage for transition: "
                 << ui::GetLastEGLErrorString();
   }
 }
 
 bool AndroidDeferredRenderingBackingStrategy::DoesSurfaceTextureDetachWork()
     const {
   bool surface_texture_detach_works = true;
   if (gpu::gles2::GLES2Decoder* gl_decoder =
           state_provider_->GetGlDecoder().get()) {
     if (gpu::gles2::ContextGroup* group = gl_decoder->GetContextGroup()) {
       if (gpu::gles2::FeatureInfo* feature_info = group->feature_info()) {
         surface_texture_detach_works =
             !feature_info->workarounds().surface_texture_cant_detach;
       }
     }
   }
 
   return surface_texture_detach_works;
 }
 
+EGLImageKHR AndroidDeferredRenderingBackingStrategy::CreateImageFromTexture(
+    const base::Callback<bool(GLint)>& init_texture) {
+  // Create a 2D texture to hold a copy of the SurfaceTexture's front buffer.
+  GLuint tmp_texture_id;
+  glGenTextures(1, &tmp_texture_id);
+  {
+    gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, tmp_texture_id);
+    // The target texture's size will exactly match the source.
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    if (!init_texture.Run(tmp_texture_id)) {
+      glDeleteTextures(1, &tmp_texture_id);
+      return EGL_NO_IMAGE_KHR;
+    }
+    // Note that tmp_texture_id might not be bound, which is okay.
+  }
+
+  // Create an EGLImage from the 2D texture we just copied into. By associating
+  // the EGLImage with the PictureBuffer textures they will remain valid even
+  // after we delete the 2D texture and EGLImage.
+  const EGLImageKHR egl_image = eglCreateImageKHR(
+      gfx::GLSurfaceEGL::GetHardwareDisplay(), eglGetCurrentContext(),
+      EGL_GL_TEXTURE_2D_KHR, reinterpret_cast<EGLClientBuffer>(tmp_texture_id),
+      nullptr /* attrs */);
+
+  glDeleteTextures(1, &tmp_texture_id);
+  DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  if (egl_image == EGL_NO_IMAGE_KHR) {
+    DLOG(ERROR) << "Failed creating EGLImage: " << ui::GetLastEGLErrorString();
+  }
+
+  return egl_image;
+}
+
 }  // namespace content