Increase cases where back/front buffering early rendering occur.

media/gpu/avda_codec_image.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 "media/gpu/avda_codec_image.h"
 
 #include <string.h>
 
 #include <memory>
 
@@ skipping 107 matching lines @@
   return true;
 }
 
 void AVDACodecImage::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd,
                                   uint64_t process_tracing_id,
                                   const std::string& dump_name) {}
 
 void AVDACodecImage::UpdateSurfaceTexture(RestoreBindingsMode mode) {
   DCHECK(surface_texture_);
   DCHECK_EQ(codec_buffer_index_, kUpdateOnly);
-  codec_buffer_index_ = kInvalidCodecBufferIndex;
+  codec_buffer_index_ = kRendered;
 
   // Swap the rendered image to the front.
   std::unique_ptr<ui::ScopedMakeCurrent> scoped_make_current =
       MakeCurrentIfNeeded();
 
   // If we changed contexts, then we always want to restore it, since the caller
   // doesn't know that we're switching contexts.
   if (scoped_make_current)
     mode = kDoRestoreBindings;
 
   // Save the current binding if requested.
   GLint bound_service_id = 0;
   if (mode == kDoRestoreBindings)
     glGetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES, &bound_service_id);
 
   surface_texture_->UpdateTexImage();
   if (mode == kDoRestoreBindings)
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, bound_service_id);
 
   // Helpfully, this is already column major.
   surface_texture_->GetTransformMatrix(gl_matrix_);
 }
 
-void AVDACodecImage::SetMediaCodecBufferIndex(int buffer_index) {
-  codec_buffer_index_ = buffer_index;
-}
-
-void AVDACodecImage::SetSize(const gfx::Size& size) {
-  size_ = size;
-}
-
 void AVDACodecImage::UpdateSurface(UpdateMode update_mode) {
   UpdateSurfaceInternal(update_mode, kDoRestoreBindings);
 }
 
 void AVDACodecImage::CodecChanged(media::MediaCodecBridge* codec) {
   media_codec_ = codec;
   codec_buffer_index_ = kInvalidCodecBufferIndex;
 }
 
-void AVDACodecImage::SetTexture(gpu::gles2::Texture* texture) {
-  texture_ = texture;
-}
-
 void AVDACodecImage::UpdateSurfaceInternal(
     UpdateMode update_mode,
     RestoreBindingsMode attached_bindings_mode) {
   if (!IsCodecBufferOutstanding())
     return;
 
   ReleaseOutputBuffer(update_mode);
 
   // SurfaceViews are updated implicitly, so no further steps are necessary.
   if (!surface_texture_) {
@@ skipping 27 matching lines @@
   glBindTexture(GL_TEXTURE_EXTERNAL_OES, bound_service_id);
 }
 
 void AVDACodecImage::ReleaseOutputBuffer(UpdateMode update_mode) {
   DCHECK(IsCodecBufferOutstanding());
 
   // In case of discard, simply discard and clear our codec buffer index.
   if (update_mode == UpdateMode::DISCARD_CODEC_BUFFER) {
     if (codec_buffer_index_ != kUpdateOnly)
       media_codec_->ReleaseOutputBuffer(codec_buffer_index_, false);
+
+    // Note: No need to wait for the frame to be available in the kUpdateOnly
+    // case since it will be or has been waited on by another release call.
     codec_buffer_index_ = kInvalidCodecBufferIndex;
     return;
   }
 
   DCHECK(update_mode == UpdateMode::RENDER_TO_BACK_BUFFER ||
          update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER);
 
   if (!surface_texture_) {
     DCHECK(update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER);
     DCHECK_GE(codec_buffer_index_, 0);
     media_codec_->ReleaseOutputBuffer(codec_buffer_index_, true);
-    codec_buffer_index_ = kInvalidCodecBufferIndex;
+    codec_buffer_index_ = kRendered;
     return;
   }
 
   // If we've already released to the back buffer, there's nothing left to do,
   // but wait for the previously released buffer if necessary.
   if (codec_buffer_index_ != kUpdateOnly) {
     DCHECK(surface_texture_);
     DCHECK_GE(codec_buffer_index_, 0);
     shared_state_->RenderCodecBufferToSurfaceTexture(media_codec_,
                                                      codec_buffer_index_);
@@ skipping 36 matching lines @@
 }
 
 void AVDACodecImage::GetTextureMatrix(float matrix[16]) {
   // Our current matrix may be stale.  Update it if possible.
   if (surface_texture_)
     UpdateSurface(UpdateMode::RENDER_TO_FRONT_BUFFER);
   memcpy(matrix, gl_matrix_, sizeof(gl_matrix_));
 }
 
 bool AVDACodecImage::IsCodecBufferOutstanding() const {
-  return codec_buffer_index_ != kInvalidCodecBufferIndex && media_codec_;
+  static_assert(kUpdateOnly < 0 && kUpdateOnly > kRendered &&
+                    kRendered > kInvalidCodecBufferIndex,
+                "Codec buffer index enum values are not ordered correctly.");
+  return codec_buffer_index_ > kRendered && media_codec_;
 }
 
 }  // namespace media