Merge to M51: Various fixes to prevent playback hang on MotoX.

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 61 matching lines @@
 
 void AndroidDeferredRenderingBackingStrategy::Cleanup(
     bool have_context,
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   // If we failed before Initialize, then do nothing.
   if (!shared_state_)
     return;
 
   // 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)
+  for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
+    ReleaseCodecBufferForPicture(entry.second);
     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 && ShouldCopyPictures())
     CopySurfaceTextureToPictures(buffers);
 
   // Now that no AVDACodecImages refer to the SurfaceTexture's texture, delete
   // the texture name.
   GLuint service_id = shared_state_->surface_texture_service_id();
   if (service_id > 0 && have_context)
@@ skipping 18 matching lines @@
     const {
   // For SurfaceView, request a 1x1 2D texture to reduce memory during
   // initialization.  For SurfaceTexture, allocate a picture buffer that is the
   // actual frame size.  Note that it will be an external texture anyway, so it
   // doesn't allocate an image of that size.  However, it's still important to
   // get the coded size right, so that VideoLayerImpl doesn't try to scale the
   // texture when building the quad for it.
   return surface_texture_ ? state_provider_->GetSize() : gfx::Size(1, 1);
 }
 
-AVDACodecImage* AndroidDeferredRenderingBackingStrategy::GetImageForPicture(
-    const media::PictureBuffer& picture_buffer) {
-  gpu::gles2::TextureRef* texture_ref =
-      state_provider_->GetTextureForPicture(picture_buffer);
-  RETURN_NULL_IF_NULL(texture_ref);
-  gl::GLImage* image =
-      texture_ref->texture()->GetLevelImage(GetTextureTarget(), 0);
-  return static_cast<AVDACodecImage*>(image);
-}
-
 void AndroidDeferredRenderingBackingStrategy::SetImageForPicture(
     const media::PictureBuffer& picture_buffer,
     const scoped_refptr<gpu::gles2::GLStreamTextureImage>& image) {
   gpu::gles2::TextureRef* texture_ref =
       state_provider_->GetTextureForPicture(picture_buffer);
   RETURN_IF_NULL(texture_ref);
 
   gpu::gles2::TextureManager* texture_manager =
       state_provider_->GetGlDecoder()->GetContextGroup()->texture_manager();
   RETURN_IF_NULL(texture_manager);
 
   if (image) {
     // Also set the parameters for the level if we're not clearing
     // the image.
     const gfx::Size size = state_provider_->GetSize();
     texture_manager->SetLevelInfo(texture_ref, GetTextureTarget(), 0, GL_RGBA,
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect());
 
     // Override the texture's service_id, so that it will use the one that
     // will be / is attached to the SurfaceTexture.
     DCHECK(shared_state_->surface_texture_service_id());
     texture_ref->texture()->SetUnownedServiceId(
         shared_state_->surface_texture_service_id());
 
     static_cast<AVDACodecImage*>(image.get())
-        ->SetTexture(texture_ref->texture());
+        ->set_texture(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_texture_ ? gpu::gles2::Texture::UNBOUND
                        : gpu::gles2::Texture::BOUND;
   texture_manager->SetLevelStreamTextureImage(texture_ref, GetTextureTarget(),
                                               0, image.get(), image_state);
 }
 
 void AndroidDeferredRenderingBackingStrategy::UseCodecBufferForPictureBuffer(
     int32_t codec_buf_index,
     const media::PictureBuffer& picture_buffer) {
   // Make sure that the decoder is available.
   RETURN_IF_NULL(state_provider_->GetGlDecoder());
 
   // Notify the AVDACodecImage for picture_buffer that it should use the
   // decoded buffer codec_buf_index to render this frame.
-  AVDACodecImage* avda_image = GetImageForPicture(picture_buffer);
+  AVDACodecImage* avda_image =
+      shared_state_->GetImageForPicture(picture_buffer.id());
   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());
+  pictures_out_for_display_.push_back(picture_buffer.id());
+  avda_image->set_media_codec_buffer_index(codec_buf_index);
+  avda_image->set_size(state_provider_->GetSize());
+
+  MaybeRenderEarly();
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     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_,
+      new AVDACodecImage(picture_buffer.id(), shared_state_, media_codec_,
                          state_provider_->GetGlDecoder(), surface_texture_);
   SetImageForPicture(picture_buffer, gl_image);
 
   if (!surface_texture_ && have_context) {
     // To make devtools work, we're using a 2D texture.  Make it transparent,
     // so that it draws a hole for the SV to show through.  This is only
     // because devtools draws and reads back, which skips overlay processing.
     // It's unclear why devtools renders twice -- once normally, and once
     // including a readback layer.  The result is that the device screen
     // flashes as we alternately draw the overlay hole and this texture,
     // unless we make the texture transparent.
     static const uint8_t rgba[] = {0, 0, 0, 0};
     const gfx::Size size(1, 1);
     DCHECK_LE(1u, picture_buffer.texture_ids().size());
     glBindTexture(GL_TEXTURE_2D, picture_buffer.texture_ids()[0]);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, rgba);
   }
 }
 
 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) {
-    // PictureBuffer wasn't displayed, so release the buffer.
-    media_codec_->ReleaseOutputBuffer(codec_buffer, false);
-    avda_image->SetMediaCodecBufferIndex(-1);
-  }
+  AVDACodecImage* avda_image =
+      shared_state_->GetImageForPicture(picture_buffer.id());
+  RETURN_IF_NULL(avda_image);
+  avda_image->UpdateSurface(AVDACodecImage::UpdateMode::DISCARD_CODEC_BUFFER);
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReuseOnePictureBuffer(
     const media::PictureBuffer& picture_buffer) {
+  pictures_out_for_display_.erase(
+      std::remove(pictures_out_for_display_.begin(),
+                  pictures_out_for_display_.end(), picture_buffer.id()),
+      pictures_out_for_display_.end());
+
   // At this point, the CC must be done with the picture.  We can't really
   // check for that here directly.  it's guaranteed in gpu_video_decoder.cc,
   // when it waits on the sync point before releasing the mailbox.  That sync
   // point is inserted by destroying the resource in VideoLayerImpl::DidDraw.
   ReleaseCodecBufferForPicture(picture_buffer);
+  MaybeRenderEarly();
+}
+
+void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBuffers(
+    const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
+  for (const std::pair<int, media::PictureBuffer>& entry : buffers)
+    ReleaseCodecBufferForPicture(entry.second);
+}
+
+void AndroidDeferredRenderingBackingStrategy::MaybeRenderEarly() {
+  if (pictures_out_for_display_.empty())
+    return;
+
+  // See if we can consume the front buffer / render to the SurfaceView. Iterate
+  // in reverse to find the most recent front buffer. If none is found, the
+  // |front_index| will point to the beginning of the array.
+  size_t front_index = pictures_out_for_display_.size() - 1;
+  AVDACodecImage* first_renderable_image = nullptr;
+  for (int i = front_index; i >= 0; --i) {
+    const int id = pictures_out_for_display_[i];
+    AVDACodecImage* avda_image = shared_state_->GetImageForPicture(id);
+    if (!avda_image)
+      continue;
+
+    // Update the front buffer index as we move along to shorten the number of
+    // candidate images we look at for back buffer rendering.
+    front_index = i;
+    first_renderable_image = avda_image;
+
+    // If we find a front buffer, stop and indicate that front buffer rendering
+    // is not possible since another image is already in the front buffer.
+    if (avda_image->was_rendered_to_front_buffer()) {
+      first_renderable_image = nullptr;
+      break;
+    }
+  }
+
+  if (first_renderable_image) {
+    first_renderable_image->UpdateSurface(
+        AVDACodecImage::UpdateMode::RENDER_TO_FRONT_BUFFER);
+  }
+
+  // Back buffer rendering is only available for surface textures. We'll always
+  // have at least one front buffer, so the next buffer must be the backbuffer.
+  size_t backbuffer_index = front_index + 1;
+  if (!surface_texture_ || backbuffer_index >= pictures_out_for_display_.size())
+    return;
+
+  // See if the back buffer is free. If so, then render the frame adjacent to
+  // the front buffer.  The listing is in render order, so we can just use the
+  // first unrendered frame if there is back buffer space.
+  first_renderable_image = shared_state_->GetImageForPicture(
+      pictures_out_for_display_[backbuffer_index]);
+  if (!first_renderable_image ||
+      first_renderable_image->was_rendered_to_back_buffer()) {
+    return;
+  }
+
+  // Due to the loop in the beginning this should never be true.
+  DCHECK(!first_renderable_image->was_rendered_to_front_buffer());
+  first_renderable_image->UpdateSurface(
+      AVDACodecImage::UpdateMode::RENDER_TO_BACK_BUFFER);
 }
 
 void AndroidDeferredRenderingBackingStrategy::CodecChanged(
-    media::VideoCodecBridge* codec,
-    const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
-  // Clear any outstanding codec buffer indices, since the new codec (if any)
-  // doesn't know about them.
+    media::VideoCodecBridge* codec) {
   media_codec_ = codec;
-  for (const std::pair<int, media::PictureBuffer>& entry : buffers) {
-    AVDACodecImage* avda_image = GetImageForPicture(entry.second);
-    avda_image->SetMediaCodec(codec);
-    avda_image->SetMediaCodecBufferIndex(-1);
-  }
+  shared_state_->CodecChanged(codec);
 }
 
 void AndroidDeferredRenderingBackingStrategy::OnFrameAvailable() {
   shared_state_->SignalFrameAvailable();
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ArePicturesOverlayable() {
   // SurfaceView frames are always overlayable because that's the only way to
   // display them.
   return !surface_texture_;
@@ skipping 29 matching lines @@
     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);
   }
 
-
-
   float transform_matrix[16];
   surface_texture_->GetTransformMatrix(transform_matrix);
 
   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(),
@@ skipping 23 matching lines @@
       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: "
-                << ui::GetLastEGLErrorString();
+    DLOG(ERROR) << "Error destroying EGLImage: " << 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()) {
@@ skipping 17 matching lines @@
     }
   }
 
   return surface_texture_detach_works;
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ShouldCopyPictures() const {
   // 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 false;
+    return false;
 
   // Other devices are unreliable for other reasons (e.g., EGLImage).
   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()) {
-          return !feature_info->workarounds().avda_dont_copy_pictures;
+        return !feature_info->workarounds().avda_dont_copy_pictures;
       }
     }
   }
 
   // Samsung Galaxy Tab A, J3, and J1 Mini all like to crash on Lollipop in
   // glEGLImageTargetTexture2DOES .  Exact models were SM-T280, SM-J320F,
   // and SM-j105H.
   if (base::android::BuildInfo::GetInstance()->sdk_int() <= 22) {  // L MR1
     const std::string brand(
         base::ToLowerASCII(base::android::BuildInfo::GetInstance()->brand()));
     if (brand == "samsung") {
       const std::string model(
           base::ToLowerASCII(base::android::BuildInfo::GetInstance()->model()));
       if (model.find("sm-t280") != std::string::npos ||
           model.find("sm-j320f") != std::string::npos ||
           model.find("sm-j105") != std::string::npos)
         return false;
     }
   }
 
   // Assume so.
   return true;
 }
 
 }  // namespace content