Copy NV12 picture buffers on demand on the main thread.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 1901 matching lines @@
   // Returns true if successful, simulated will be true if attrib0 was
   // simulated.
   bool SimulateAttrib0(
       const char* function_name, GLuint max_vertex_accessed, bool* simulated);
   void RestoreStateForAttrib(GLuint attrib, bool restore_array_binding);
 
   // Copies the image to the texture currently bound to |textarget|. The image
   // state of |texture| is updated to reflect the new state.
   void DoCopyTexImage(Texture* texture, GLenum textarget, gl::GLImage* image);
 
-  // This will call DoCopyTexImage if texture has an image but that image is
-  // not bound or copied to the texture.
-  void DoCopyTexImageIfNeeded(Texture* texture, GLenum textarget);
+  // If the texture has an image but that image is not bound or copied to the
+  // texture, this will first attempt to bind it, and if that fails
+  // DoCopyTexImage on it. texture_unit is the texture unit it should be bound
+  // to, or 0 if it doesn't matter - setting it to 0 will cause the previous
+  // binding to be restored after the operation. This returns true if a copy
+  // or bind happened.

[Zhenyao Mo, 2017/05/26 01:11:07]

Can you add it here that it is the caller's responsibility to recover the active
texture and |textarget| binding?

+  bool DoBindOrCopyTexImageIfNeeded(Texture* texture,
+                                    GLenum textarget,
+                                    GLuint texture_unit);
 
   // Returns false if textures were replaced.
   bool PrepareTexturesForRender();
   void RestoreStateForTextures();
 
   // Returns true if GL_FIXED attribs were simulated.
   bool SimulateFixedAttribs(
       const char* function_name,
       GLuint max_vertex_accessed, bool* simulated, GLsizei primcount);
   void RestoreStateForSimulatedFixedAttribs();
@@ skipping 582 matching lines @@
     const char* function_name, ErrorState* error_state)
     : function_name_(function_name),
       error_state_(error_state) {
   ERRORSTATE_COPY_REAL_GL_ERRORS_TO_WRAPPER(error_state_, function_name_);
 }
 
 ScopedGLErrorSuppressor::~ScopedGLErrorSuppressor() {
   ERRORSTATE_CLEAR_REAL_GL_ERRORS(error_state_, function_name_);
 }
 
-static void RestoreCurrentTextureBindings(ContextState* state, GLenum target) {
+static void RestoreCurrentTextureBindings(ContextState* state,
+                                          GLenum target,
+                                          GLuint texture_unit) {
   DCHECK(!state->texture_units.empty());
-  TextureUnit& info = state->texture_units[0];
+  DCHECK_LT(texture_unit, state->texture_units.size());
+  TextureUnit& info = state->texture_units[texture_unit];
   GLuint last_id;
   TextureRef* texture_ref = info.GetInfoForTarget(target);
   if (texture_ref) {
     last_id = texture_ref->service_id();
   } else {
     last_id = 0;
   }
 
   glBindTexture(target, last_id);
-  glActiveTexture(GL_TEXTURE0 + state->active_texture_unit);
 }
 
 ScopedTextureBinder::ScopedTextureBinder(ContextState* state,
                                          GLuint id,
                                          GLenum target)
     : state_(state),
       target_(target) {
   ScopedGLErrorSuppressor suppressor(
       "ScopedTextureBinder::ctor", state_->GetErrorState());
 
   // TODO(apatrick): Check if there are any other states that need to be reset
   // before binding a new texture.
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(target, id);
 }
 
 ScopedTextureBinder::~ScopedTextureBinder() {
   ScopedGLErrorSuppressor suppressor(
       "ScopedTextureBinder::dtor", state_->GetErrorState());
-  RestoreCurrentTextureBindings(state_, target_);
+  RestoreCurrentTextureBindings(state_, target_, 0);
+  state_->RestoreActiveTexture();
 }
 
 ScopedRenderBufferBinder::ScopedRenderBufferBinder(ContextState* state,
                                                    GLuint id)
     : state_(state) {
   ScopedGLErrorSuppressor suppressor(
       "ScopedRenderBufferBinder::ctor", state_->GetErrorState());
   glBindRenderbufferEXT(GL_RENDERBUFFER, id);
 }
 
@@ skipping 5203 matching lines @@
 
   if ((level > 0 && !feature_info_->IsWebGL2OrES3Context()) ||
       !texture_manager()->ValidForTarget(textarget, level, 0, 0, 1)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         name, "level out of range");
     return;
   }
 
   if (texture_ref)
-    DoCopyTexImageIfNeeded(texture_ref->texture(), textarget);
+    DoBindOrCopyTexImageIfNeeded(texture_ref->texture(), textarget, 0);
 
   std::vector<GLenum> attachments;
   if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
     attachments.push_back(GL_DEPTH_ATTACHMENT);
     attachments.push_back(GL_STENCIL_ATTACHMENT);
   } else {
     attachments.push_back(attachment);
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(name);
   for (size_t ii = 0; ii < attachments.size(); ++ii) {
@@ skipping 1857 matching lines @@
                                       gl::GLImage* image) {
   // Note: We update the state to COPIED prior to calling CopyTexImage()
   // as that allows the GLImage implemenatation to set it back to UNBOUND
   // and ensure that CopyTexImage() is called each time the texture is
   // used.
   texture->SetLevelImageState(textarget, 0, Texture::COPIED);
   bool rv = image->CopyTexImage(textarget);
   DCHECK(rv) << "CopyTexImage() failed";
 }
 
-void GLES2DecoderImpl::DoCopyTexImageIfNeeded(Texture* texture,
-                                              GLenum textarget) {
+bool GLES2DecoderImpl::DoBindOrCopyTexImageIfNeeded(Texture* texture,
+                                                    GLenum textarget,
+                                                    GLuint texture_unit) {
   // Image is already in use if texture is attached to a framebuffer.
   if (texture && !texture->IsAttachedToFramebuffer()) {
     Texture::ImageState image_state;
     gl::GLImage* image = texture->GetLevelImage(textarget, 0, &image_state);
     if (image && image_state == Texture::UNBOUND) {
       ScopedGLErrorSuppressor suppressor(
-          "GLES2DecoderImpl::DoCopyTexImageIfNeeded", GetErrorState());
+          "GLES2DecoderImpl::DoBindOrCopyTexImageIfNeeded", GetErrorState());
+      if (texture_unit)
+        glActiveTexture(texture_unit);
       glBindTexture(textarget, texture->service_id());
-      DoCopyTexImage(texture, textarget, image);
-      RestoreCurrentTextureBindings(&state_, textarget);
+      if (image->BindTexImage(textarget)) {
+        image_state = Texture::BOUND;
+      } else {
+        DoCopyTexImage(texture, textarget, image);
+      }
+      if (!texture_unit)
+        RestoreCurrentTextureBindings(&state_, textarget,
+                                      state_.active_texture_unit);
+      return true;
     }
   }
+  return false;
 }
 
 void GLES2DecoderImpl::DoCopyBufferSubData(GLenum readtarget,
                                            GLenum writetarget,
                                            GLintptr readoffset,
                                            GLintptr writeoffset,
                                            GLsizeiptr size) {
   // Just delegate it. Some validation is actually done before this.
   buffer_manager()->ValidateAndDoCopyBufferSubData(
       &state_, readtarget, writetarget, readoffset, writeoffset, size);
@@ skipping 34 matching lines @@
                 std::string("texture bound to texture unit ") +
                 base::UintToString(texture_unit_index) +
                 " is not renderable. It maybe non-power-of-2 and have"
                 " incompatible texture filtering.");
           }
           continue;
         }
 
         if (textarget != GL_TEXTURE_CUBE_MAP) {
           Texture* texture = texture_ref->texture();
-          Texture::ImageState image_state;
-          gl::GLImage* image =
-              texture->GetLevelImage(textarget, 0, &image_state);
-          if (image && image_state == Texture::UNBOUND &&
-              !texture->IsAttachedToFramebuffer()) {
-            ScopedGLErrorSuppressor suppressor(
-                "GLES2DecoderImpl::PrepareTexturesForRender", GetErrorState());
+          if (DoBindOrCopyTexImageIfNeeded(texture, textarget,
+                                           GL_TEXTURE0 + texture_unit_index)) {
             textures_set = true;
-            glActiveTexture(GL_TEXTURE0 + texture_unit_index);
-            DoCopyTexImage(texture, textarget, image);
             continue;
           }
         }
       }
       // else: should this be an error?
     }
   }
   return !textures_set;
 }
 
@@ skipping 7166 matching lines @@
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
     glBindTexture(dest_binding_target, dest_texture->service_id());
     glTexImage2D(dest_target, dest_level,
                  TextureManager::AdjustTexInternalFormat(feature_info_.get(),
                                                          internal_format),
                  source_width, source_height, 0,
                  TextureManager::AdjustTexFormat(feature_info_.get(), format),
                  dest_type, nullptr);
     GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
     if (error != GL_NO_ERROR) {
-      RestoreCurrentTextureBindings(&state_, dest_binding_target);
+      RestoreCurrentTextureBindings(&state_, dest_binding_target,
+                                    state_.active_texture_unit);
       return;
     }
 
     texture_manager()->SetLevelInfo(dest_texture_ref, dest_target, dest_level,
                                     internal_format, source_width,
                                     source_height, 1, 0, format, dest_type,
                                     gfx::Rect(source_width, source_height));
     dest_texture->ApplyFormatWorkarounds(feature_info_.get());
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, dest_target,
                                        dest_level, true);
   }
 
   // Try using GLImage::CopyTexImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
   // TODO(qiankun.miao@intel.com): Support level > 0 for CopyTexImage.
   if (image && dest_level == 0 && !unpack_flip_y &&
       !unpack_premultiply_alpha_change) {
     glBindTexture(dest_binding_target, dest_texture->service_id());
     if (image->CopyTexImage(dest_target))
       return;
   }
 
-  DoCopyTexImageIfNeeded(source_texture, source_target);
+  DoBindOrCopyTexImageIfNeeded(source_texture, source_target, 0);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires that we apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
                                                        source_level)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
@@ skipping 191 matching lines @@
   if (image && dest_level == 0 && !unpack_flip_y &&
       !unpack_premultiply_alpha_change) {
     ScopedTextureBinder binder(&state_, dest_texture->service_id(),
                                dest_binding_target);
     if (image->CopyTexSubImage(dest_target, gfx::Point(xoffset, yoffset),
                                gfx::Rect(x, y, width, height))) {
       return;
     }
   }
 
-  DoCopyTexImageIfNeeded(source_texture, source_target);
+  DoBindOrCopyTexImageIfNeeded(source_texture, source_target, 0);
 
   // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
   // before presenting.
   if (source_target == GL_TEXTURE_EXTERNAL_OES) {
     if (GLStreamTextureImage* image =
             source_texture->GetLevelStreamTextureImage(GL_TEXTURE_EXTERNAL_OES,
                                                        source_level)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopySubTextureWithTransform(
@@ skipping 156 matching lines @@
           &source_size);
       DCHECK(did_get_size);
 
       // Ensure that the glCompressedTexImage2D succeeds.
       LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
       glCompressedTexImage2D(GL_TEXTURE_2D, 0, source_internal_format,
                              source_width, source_height, 0, source_size,
                              NULL);
       GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
       if (error != GL_NO_ERROR) {
-        RestoreCurrentTextureBindings(&state_, dest_texture->target());
+        RestoreCurrentTextureBindings(&state_, dest_texture->target(),
+                                      state_.active_texture_unit);
         return;
       }
 
       texture_manager()->SetLevelInfo(
           dest_texture_ref, dest_texture->target(), 0, source_internal_format,
           source_width, source_height, 1, 0, source_internal_format,
           source_type, gfx::Rect(source_width, source_height));
     } else {
       texture_manager()->SetLevelCleared(
           dest_texture_ref, dest_texture->target(), 0, true);
     }
 
     if (image->CopyTexImage(dest_texture->target()))
       return;
   }
 
   TRACE_EVENT0(
       "gpu",
       "GLES2DecoderImpl::DoCompressedCopyTextureCHROMIUM, fallback");
 
-  DoCopyTexImageIfNeeded(source_texture, source_texture->target());
+  DoBindOrCopyTexImageIfNeeded(source_texture, source_texture->target(), 0);
 
   // As a fallback, copy into a non-compressed GL_RGBA texture.
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
   glTexImage2D(dest_texture->target(), 0, GL_RGBA, source_width, source_height,
                0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
   GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
   if (error != GL_NO_ERROR) {
-    RestoreCurrentTextureBindings(&state_, dest_texture->target());
+    RestoreCurrentTextureBindings(&state_, dest_texture->target(),
+                                  state_.active_texture_unit);
     return;
   }
 
   texture_manager()->SetLevelInfo(
       dest_texture_ref, dest_texture->target(), 0, GL_RGBA, source_width,
       source_height, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
       gfx::Rect(source_width, source_height));
 
   copy_texture_CHROMIUM_->DoCopyTexture(
       this, source_texture->target(), source_texture->service_id(), 0,
@@ skipping 297 matching lines @@
     GLenum target,
     GLuint client_id) {
   TextureRef* texture_ref = GetTexture(client_id);
   if (!texture_ref) {
     GLuint service_id;
     glGenTextures(1, &service_id);
     DCHECK_NE(0u, service_id);
     texture_ref = CreateTexture(client_id, service_id);
     texture_manager()->SetTarget(texture_ref, target);
     glBindTexture(target, service_id);
-    RestoreCurrentTextureBindings(&state_, target);
+    RestoreCurrentTextureBindings(&state_, target, state_.active_texture_unit);
   }
 }
 
 void GLES2DecoderImpl::DoCreateAndConsumeTextureINTERNAL(
     GLenum target,
     GLuint client_id,
     const volatile GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoCreateAndConsumeTextureINTERNAL",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
@@ skipping 2028 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu