gpu: Extend CopyTextureCHROMIUM with support for copying part of source texture.

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 <stdio.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 985 matching lines @@
   void DoCopyTextureCHROMIUM(GLenum target,
                              GLuint source_id,
                              GLuint dest_id,
                              GLenum internal_format,
                              GLenum dest_type);
 
   void DoCopySubTextureCHROMIUM(GLenum target,
                                 GLuint source_id,
                                 GLuint dest_id,
                                 GLint xoffset,
-                                GLint yoffset);
+                                GLint yoffset,
+                                GLint x,
+                                GLint y,
+                                GLsizei width,
+                                GLsizei height);
 
   // Wrapper for TexStorage2DEXT.
   void DoTexStorage2DEXT(
       GLenum target,
       GLint levels,
       GLenum internal_format,
       GLsizei width,
       GLsizei height);
 
   void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
@@ skipping 10971 matching lines @@
         unpack_unpremultiply_alpha_);
   }
 
   DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(GLenum target,
                                                 GLuint source_id,
                                                 GLuint dest_id,
                                                 GLint xoffset,
-                                                GLint yoffset) {
+                                                GLint yoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopySubTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   int source_width = 0;
   int source_height = 0;
   gfx::GLImage* image =
       source_texture->GetLevelImage(source_texture->target(), 0);
@@ skipping 20 matching lines @@
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopySubTextureCHROMIUM",
                          "source texture bad dimensions");
       return;
     }
   }
 
   GLenum source_type = 0;
   GLenum source_internal_format = 0;
   source_texture->GetLevelType(source_texture->target(), 0, &source_type,
                                &source_internal_format);
+  if (!source_texture->ValidForTexture(source_texture->target(), 0, x, y, 0,
+                                       width, height, 1, source_type)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopySubTextureCHROMIUM",
+                       "source texture bad dimensions.");
+    return;
+  }
+
   GLenum dest_type = 0;
   GLenum dest_internal_format = 0;
   bool dest_level_defined = dest_texture->GetLevelType(
       dest_texture->target(), 0, &dest_type, &dest_internal_format);
   if (!dest_level_defined) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopySubTextureCHROMIUM",
                        "destination texture is not defined");
     return;
   }
   if (!dest_texture->ValidForTexture(dest_texture->target(), 0, xoffset,
-                                     yoffset, 0, source_width, source_height,
-                                     1, dest_type)) {
+                                     yoffset, 0, width, height, 1, dest_type)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glCopySubTextureCHROMIUM",
                        "destination texture bad dimensions.");
     return;
   }
 
   if (!ValidateCopyTextureCHROMIUM("glCopySubTextureCHROMIUM", target,
                                    source_texture_ref, dest_texture_ref,
                                    dest_internal_format)) {
     return;
   }
@@ skipping 15 matching lines @@
     RestoreCurrentFramebufferBindings();
     if (LOCAL_PEEK_GL_ERROR("glCopySubTextureCHROMIUM") != GL_NO_ERROR)
       return;
   }
 
   int dest_width = 0;
   int dest_height = 0;
   bool ok = dest_texture->GetLevelSize(
       GL_TEXTURE_2D, 0, &dest_width, &dest_height, nullptr);
   DCHECK(ok);
-  if (xoffset != 0 || yoffset != 0 || source_width != dest_width ||
-      source_height != dest_height) {
+  if (xoffset != 0 || yoffset != 0 || width != dest_width ||
+      height != dest_height) {
     if (!texture_manager()->ClearTextureLevel(this, dest_texture_ref, target,
                                               0)) {
       LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopySubTextureCHROMIUM",
                          "destination texture dimensions too big");
       return;
     }
   } else {
     texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
                                        true);
   }
 
   ScopedModifyPixels modify(dest_texture_ref);
 
   // Try using GLImage::CopyTexSubImage when possible.
   bool unpack_premultiply_alpha_change =
       unpack_premultiply_alpha_ ^ unpack_unpremultiply_alpha_;
   if (image && !unpack_flip_y_ && !unpack_premultiply_alpha_change) {
     glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
     if (image->CopyTexSubImage(GL_TEXTURE_2D, gfx::Point(xoffset, yoffset),
-                               gfx::Rect(0, 0, source_width, source_height))) {
+                               gfx::Rect(x, y, source_width, source_height))) {
       return;
     }
   }
 
   DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
 
-  // GL_TEXTURE_EXTERNAL_OES texture requires apply a transform matrix
-  // before presenting.
-  if (source_texture->target() == GL_TEXTURE_EXTERNAL_OES) {
-    // TODO(hkuang): get the StreamTexture transform matrix in GPU process
-    // instead of using kIdentityMatrix crbug.com/226218.

[piman, 2015/05/22 21:11:03]

nit: can you keep the TODO and a reference to this bug?

[reveman, 2015/05/22 22:18:14]

We have this TODO and bug reference in GLES2DecoderImpl::DoCopyTextureCHROMIUM.
It was copied here when CopyTexture forked into CopyTexture+CopySubTexture. I
don't think we need to support stream textures in the CopySubTexture case and
applying a generic transformation matrix when performing a sub copy makes
everything more complicated.

+sievers to make sure I understand this correctly.

[no sievers, 2015/05/22 22:37:55]

This stuff is a bit unfortunate. You can put a TODO, although I don't think
anything would use CopyTexSubImage() with a stream texture (but the full copy
API is broken in the same way).

It might actually be easy to implement: We only need to worry about the matrix
if there is an image attached to the texture. So we'd probably need to have a
GLImage API to get the matrix which the StreamTexture implementation on Android
can then simply return. 

But again, this is much more interesting for CopyTextureCHROMIUM than
CopySubTexture touched in this patch.

[reveman, 2015/05/23 18:56:13]

Can we simply implement the copy in GLImage::CopyTexSubImage for stream
textures? I think that would be cleaner than pulling some magic matrix out the
generic GLImage.
Ok, thanks for explaining. I kept the TODO for now as it shouldn't hurt to have
it here.

-    copy_texture_CHROMIUM_->DoCopySubTextureWithTransform(
-        this, source_texture->target(), source_texture->service_id(),
-        dest_texture->service_id(), xoffset, yoffset, dest_width, dest_height,
-        source_width, source_height, unpack_flip_y_, unpack_premultiply_alpha_,
-        unpack_unpremultiply_alpha_, kIdentityMatrix);
-  } else {
-    copy_texture_CHROMIUM_->DoCopySubTexture(
-        this, source_texture->target(), source_texture->service_id(),
-        source_internal_format, dest_texture->service_id(),
-        dest_internal_format, xoffset, yoffset, dest_width, dest_height,
-        source_width, source_height, unpack_flip_y_, unpack_premultiply_alpha_,
-        unpack_unpremultiply_alpha_);
-  }
+  copy_texture_CHROMIUM_->DoCopySubTexture(
+      this, source_texture->target(), source_texture->service_id(),
+      source_internal_format, dest_texture->service_id(), dest_internal_format,
+      xoffset, yoffset, x, y, width, height, dest_width, dest_height,
+      source_width, source_height, unpack_flip_y_, unpack_premultiply_alpha_,
+      unpack_unpremultiply_alpha_);
 
   DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
 static GLenum ExtractTypeFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
     case GL_RGB565:
       return GL_UNSIGNED_SHORT_5_6_5;
     case GL_RGBA4:
       return GL_UNSIGNED_SHORT_4_4_4_4;
@@ skipping 1136 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu