Reland of Extend CopyTextureCHROMIUM to more ES 3.0 texture formats.

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 871 matching lines @@
       GLint yoffset,
       GLint zoffset,
       GLsizei width,
       GLsizei height,
       GLsizei depth,
       GLenum format,
       GLsizei imageSize,
       const void* data,
       ContextState::Dimension dimension);
 
+  bool ValidateCopyTexFormatHelper(GLenum internal_format, GLenum read_format,
+                                   GLenum read_type, std::string& err_msg);
   // Validate if |format| is valid for CopyTex{Sub}Image functions.
   // If not, generate a GL error and return false.
   bool ValidateCopyTexFormat(const char* func_name, GLenum internal_format,
                              GLenum read_format, GLenum read_type);
 
   // Wrapper for CopyTexImage2D.
   void DoCopyTexImage2D(
       GLenum target,
       GLint level,
       GLenum internal_format,
@@ skipping 12788 matching lines @@
                                 height, depth, format, image_size, data);
     }
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
-bool GLES2DecoderImpl::ValidateCopyTexFormat(
-    const char* func_name, GLenum internal_format,
-    GLenum read_format, GLenum read_type) {
+bool GLES2DecoderImpl::ValidateCopyTexFormatHelper(GLenum internal_format,
+    GLenum read_format, GLenum read_type, std::string& err_msg) {

[Zhenyao Mo, 2016/11/03 22:55:35]

This is against coding style:
https://google.github.io/styleguide/cppguide.html#Reference_Arguments

std::string* output_error_msg.

   if (read_format == 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, func_name, "no valid color image");
+    err_msg = std::string("no valid color image");
     return false;
   }
   // Check we have compatible formats.
   uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
   uint32_t channels_needed = GLES2Util::GetChannelsForFormat(internal_format);
   if (!channels_needed ||
       (channels_needed & channels_exist) != channels_needed) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, func_name, "incompatible format");
+    err_msg = std::string("incompatible format");
     return false;
   }
   if (feature_info_->IsWebGL2OrES3Context()) {
     GLint color_encoding = GetColorEncodingFromInternalFormat(read_format);
     if (color_encoding != GetColorEncodingFromInternalFormat(internal_format) ||
         GLES2Util::IsFloatFormat(internal_format) ||
         (GLES2Util::IsSignedIntegerFormat(internal_format) !=
          GLES2Util::IsSignedIntegerFormat(read_format)) ||
         (GLES2Util::IsUnsignedIntegerFormat(internal_format) !=
          GLES2Util::IsUnsignedIntegerFormat(read_format))) {
-      LOCAL_SET_GL_ERROR(
-          GL_INVALID_OPERATION, func_name, "incompatible format");
+      err_msg = std::string("incompatible format");
       return false;
     }
   }
   if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        func_name, "can not be used with depth or stencil textures");
+    err_msg = std::string("can not be used with depth or stencil textures");
     return false;
   }
   if (feature_info_->IsWebGL2OrES3Context()) {
     if (GLES2Util::IsSizedColorFormat(internal_format)) {
       int sr, sg, sb, sa;
       GLES2Util::GetColorFormatComponentSizes(
           read_format, read_type, &sr, &sg, &sb, &sa);
       DCHECK(sr > 0 || sg > 0 || sb > 0 || sa > 0);
       int dr, dg, db, da;
       GLES2Util::GetColorFormatComponentSizes(
           internal_format, 0, &dr, &dg, &db, &da);
       DCHECK(dr > 0 || dg > 0 || db > 0 || da > 0);
       if ((dr > 0 && sr != dr) ||
           (dg > 0 && sg != dg) ||
           (db > 0 && sb != db) ||
           (da > 0 && sa != da)) {
-        LOCAL_SET_GL_ERROR(
-            GL_INVALID_OPERATION,
-            func_name, "incompatible color component sizes");
+        err_msg = std::string("incompatible color component sizes");
         return false;
       }
     }
   }
   return true;
 }
 
+bool GLES2DecoderImpl::ValidateCopyTexFormat(
+    const char* func_name, GLenum internal_format,
+    GLenum read_format, GLenum read_type) {
+  std::string err_msg;
+  if (!ValidateCopyTexFormatHelper(internal_format, read_format,
+                                   read_type, err_msg)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name, err_msg.c_str());
+    return false;
+  }
+  return true;
+}
+
 void GLES2DecoderImpl::DoCopyTexImage2D(
     GLenum target,
     GLint level,
     GLenum internal_format,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLint border) {
   const char* func_name = "glCopyTexImage2D";
@@ skipping 2184 matching lines @@
       source_internal_format == GL_RED || source_internal_format == GL_ALPHA ||
       source_internal_format == GL_RGB || source_internal_format == GL_RGBA ||
       source_internal_format == GL_RGB8 || source_internal_format == GL_RGBA8 ||
       source_internal_format == GL_LUMINANCE ||
       source_internal_format == GL_LUMINANCE_ALPHA ||
       source_internal_format == GL_BGRA_EXT ||
       source_internal_format == GL_BGRA8_EXT ||
       source_internal_format == GL_RGB_YCBCR_420V_CHROMIUM ||
       source_internal_format == GL_RGB_YCBCR_422_CHROMIUM;
   if (!valid_source_format) {
-    std::string msg = "invalid source internal format " +
-        GLES2Util::GetStringEnum(source_internal_format);
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
-                       msg.c_str());
     return false;
   }
   if (!valid_dest_format) {
-    std::string msg = "invalid dest internal format " +
-        GLES2Util::GetStringEnum(dest_internal_format);
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
-                       msg.c_str());
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::ValidateCompressedCopyTextureCHROMIUM(
     const char* function_name,
     TextureRef* source_texture_ref,
     TextureRef* dest_texture_ref) {
   if (!source_texture_ref || !dest_texture_ref) {
@@ skipping 46 matching lines @@
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
   static const char kFunctionName[] = "glCopyTextureCHROMIUM";
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
 
-  if (!texture_manager()->ValidateTextureParameters(
-          GetErrorState(), kFunctionName, true, internal_format, dest_type,
-          internal_format, 0))
-    return;
-
   if (!ValidateCopyTextureCHROMIUMTextures(kFunctionName, source_texture_ref,
                                            dest_texture_ref)) {
     return;
   }
 
-  if (!ValidateCopyTextureCHROMIUMInternalFormats(
-          kFunctionName, source_texture_ref, internal_format)) {
-    return;
-  }
-
   Texture* source_texture = source_texture_ref->texture();
   Texture* dest_texture = dest_texture_ref->texture();
   GLenum source_target = source_texture->target();
   GLenum dest_target = dest_texture->target();
+
+  GLenum source_type = 0;
+  GLenum source_internal_format = 0;
+  source_texture->GetLevelType(source_target, 0, &source_type,
+                               &source_internal_format);
+  GLenum format = TextureManager::ExtractFormatFromStorageFormat(
+      internal_format);
+  if (!texture_manager()->ValidateTextureParameters(
+          GetErrorState(), kFunctionName, true, format, dest_type,
+          internal_format, 0))
+    return;
+
+  bool legacy_format_valid = ValidateCopyTextureCHROMIUMInternalFormats(

[Zhenyao Mo, 2016/11/03 22:55:35]

I think you should expand this function to handle all formats, and return an
enum which tells you which path to go down.

+      kFunctionName, source_texture_ref, internal_format);
+  bool source_format_color_renderable = Texture::ColorRenderable(
+      GetFeatureInfo(), source_internal_format, source_texture->IsImmutable());
+  std::string err_msg;
+  bool copy_tex_image_format_valid = source_format_color_renderable &&
+      source_target == GL_TEXTURE_2D && dest_target == GL_TEXTURE_2D &&
+      ValidateCopyTexFormatHelper(internal_format,
+          source_internal_format, source_type, err_msg);
+  if (!legacy_format_valid && !copy_tex_image_format_valid) {
+    std::string msg = "source internal format(" +
+        GLES2Util::GetStringEnum(source_internal_format) +
+        ") and destination internal format(" +
+        GLES2Util::GetStringEnum(internal_format) +
+        ") combination is invalid.";
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
+        msg.c_str());
+    return;
+  }
+
   int source_width = 0;
   int source_height = 0;
   gl::GLImage* image =
       source_texture->GetLevelImage(source_target, 0);
   if (image) {
     gfx::Size size = image->GetSize();
     source_width = size.width();
     source_height = size.height();
     if (source_width <= 0 || source_height <= 0) {
       LOCAL_SET_GL_ERROR(
@@ skipping 11 matching lines @@
     }
 
     // Check that this type of texture is allowed.
     if (!texture_manager()->ValidForTarget(source_target, 0,
                                            source_width, source_height, 1)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "Bad dimensions");
       return;
     }
   }
 
-  GLenum source_type = 0;
-  GLenum source_internal_format = 0;
-  source_texture->GetLevelType(source_target, 0, &source_type,
-                               &source_internal_format);
-
   if (dest_texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "texture is immutable");
     return;
   }
 
   // Clear the source texture if necessary.
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
                                             source_target, 0)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName, "dimensions too big");
@@ skipping 20 matching lines @@
       dest_height != source_height ||
       dest_internal_format != internal_format ||
       dest_type_previous != dest_type) {
     // Ensure that the glTexImage2D succeeds.
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(kFunctionName);
     glBindTexture(dest_target, dest_texture->service_id());
     glTexImage2D(
         dest_target, 0, TextureManager::AdjustTexInternalFormat(
                             feature_info_.get(), internal_format),
         source_width, source_height, 0,
-        TextureManager::AdjustTexFormat(feature_info_.get(), internal_format),
+        TextureManager::AdjustTexFormat(feature_info_.get(), format),
         dest_type, NULL);
     GLenum error = LOCAL_PEEK_GL_ERROR(kFunctionName);
     if (error != GL_NO_ERROR) {
       RestoreCurrentTextureBindings(&state_, dest_target);
       return;
     }
 
     texture_manager()->SetLevelInfo(
         dest_texture_ref, dest_target, 0, internal_format, source_width,
-        source_height, 1, 0, internal_format, dest_type,
+        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, 0,
-                                       true);
+    texture_manager()->SetLevelCleared(dest_texture_ref, dest_target, 0, true);
   }
 
   // Try using GLImage::CopyTexImage when possible.
   bool unpack_premultiply_alpha_change =
       (unpack_premultiply_alpha ^ unpack_unmultiply_alpha) != 0;
   if (image && !unpack_flip_y && !unpack_premultiply_alpha_change) {
     glBindTexture(dest_target, dest_texture->service_id());
     if (image->CopyTexImage(dest_target))
       return;
   }
 
   DoCopyTexImageIfNeeded(source_texture, source_target);
 
   // 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,
                                                        0)) {
       GLfloat transform_matrix[16];
       image->GetTextureMatrix(transform_matrix);
       copy_texture_CHROMIUM_->DoCopyTextureWithTransform(
           this, source_target, source_texture->service_id(), dest_target,
           dest_texture->service_id(), source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
     }
   }
-  copy_texture_CHROMIUM_->DoCopyTexture(
-      this, source_target, source_texture->service_id(), source_internal_format,
-      dest_target, dest_texture->service_id(), internal_format, source_width,
-      source_height, unpack_flip_y == GL_TRUE,
-      unpack_premultiply_alpha == GL_TRUE, unpack_unmultiply_alpha == GL_TRUE);
+  if (legacy_format_valid) {
+    copy_texture_CHROMIUM_->DoCopyTexture(
+        this, source_target, source_texture->service_id(),
+        source_internal_format, dest_target, dest_texture->service_id(),
+        internal_format, source_width, source_height, unpack_flip_y == GL_TRUE,
+        unpack_premultiply_alpha == GL_TRUE,
+        unpack_unmultiply_alpha == GL_TRUE);
+  } else if (copy_tex_image_format_valid) {
+    copy_texture_CHROMIUM_->DoCopyTexImage2D(
+        this, source_target, source_texture->service_id(),
+        dest_target, dest_texture->service_id(),
+        internal_format, source_width, source_height);
+  } else {
+    NOTIMPLEMENTED();
+  }
 }
 
 void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(
     GLuint source_id,
     GLuint dest_id,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
@@ skipping 81 matching lines @@
                        "destination texture is not defined");
     return;
   }
   if (!dest_texture->ValidForTexture(dest_target, 0, xoffset,
                                      yoffset, 0, width, height, 1)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName,
                        "destination texture bad dimensions.");
     return;
   }
 
-  if (!ValidateCopyTextureCHROMIUMInternalFormats(
-          kFunctionName, source_texture_ref, dest_internal_format)) {
+  bool legacy_format_valid = ValidateCopyTextureCHROMIUMInternalFormats(
+      kFunctionName, source_texture_ref, dest_internal_format);
+  bool source_format_color_renderable = Texture::ColorRenderable(
+      GetFeatureInfo(), source_internal_format, source_texture->IsImmutable());
+  std::string err_msg;
+  bool copy_tex_image_format_valid = source_format_color_renderable &&
+      source_target == GL_TEXTURE_2D && dest_target == GL_TEXTURE_2D &&
+      ValidateCopyTexFormatHelper(dest_internal_format,
+          source_internal_format, source_type, err_msg);
+  if (!legacy_format_valid && !copy_tex_image_format_valid) {
+    std::string msg = "source internal format(" +
+        GLES2Util::GetStringEnum(source_internal_format) +
+        ") and destination internal format(" +
+        GLES2Util::GetStringEnum(dest_internal_format) +
+        ") combination is invalid.";
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
+        msg.c_str());
     return;
   }
 
   // Clear the source texture if necessary.
   if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
                                             source_target, 0)) {
     LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, kFunctionName,
                        "source texture dimensions too big");
     return;
   }
@@ skipping 56 matching lines @@
       copy_texture_CHROMIUM_->DoCopySubTextureWithTransform(
           this, source_target, source_texture->service_id(),
           source_internal_format, dest_target, dest_texture->service_id(),
           dest_internal_format, xoffset, yoffset, x, y, width, height,
           dest_width, dest_height, source_width, source_height,
           unpack_flip_y == GL_TRUE, unpack_premultiply_alpha == GL_TRUE,
           unpack_unmultiply_alpha == GL_TRUE, transform_matrix);
       return;
     }
   }
-  copy_texture_CHROMIUM_->DoCopySubTexture(
-      this, source_target, source_texture->service_id(), source_internal_format,
-      dest_target, dest_texture->service_id(), dest_internal_format, xoffset,
-      yoffset, x, y, width, height, dest_width, dest_height, source_width,
-      source_height, unpack_flip_y == GL_TRUE,
-      unpack_premultiply_alpha == GL_TRUE, unpack_unmultiply_alpha == GL_TRUE);
+  if (legacy_format_valid) {
+      copy_texture_CHROMIUM_->DoCopySubTexture(
+          this, source_target, source_texture->service_id(),
+          source_internal_format, dest_target, dest_texture->service_id(),
+          dest_internal_format, xoffset, yoffset, x, y, width, height,
+          dest_width, dest_height, source_width,
+          source_height, unpack_flip_y == GL_TRUE,
+          unpack_premultiply_alpha == GL_TRUE,
+          unpack_unmultiply_alpha == GL_TRUE);
+  } else if (copy_tex_image_format_valid) {
+      copy_texture_CHROMIUM_->DoCopyTexSubImage2D(
+          this, source_target, source_texture->service_id(),
+          dest_target, dest_texture->service_id(),
+          xoffset, yoffset, x, y, width, height);
+  } else {
+    NOTIMPLEMENTED();
+  }
 }
 
 bool GLES2DecoderImpl::InitializeCopyTexImageBlitter(
     const char* function_name) {
   if (!copy_tex_image_blit_.get()) {
     LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(function_name);
     copy_tex_image_blit_.reset(
         new CopyTexImageResourceManager(feature_info_.get()));
     copy_tex_image_blit_->Initialize(this);
     if (LOCAL_PEEK_GL_ERROR(function_name) != GL_NO_ERROR)
@@ skipping 2405 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