Improve CopyTex{Sub}Image2D format validation.

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 892 matching lines @@
   // Wrapper for CompressedTexSubImage2D.
   void DoCompressedTexSubImage2D(
       GLenum target,
       GLint level,
       GLint xoffset,
       GLint yoffset,
       GLsizei width,
       GLsizei height,
       GLenum format,
       GLsizei imageSize,
-      const void * data);
+      const void* data);
 
   // Wrapper for CompressedTexSubImage3D.
   void DoCompressedTexSubImage3D(
       GLenum target,
       GLint level,
       GLint xoffset,
       GLint yoffset,
       GLint zoffset,
       GLsizei width,
       GLsizei height,
       GLsizei depth,
       GLenum format,
       GLsizei image_size,
       const void* data);
 
+  // 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,
       GLint x,
       GLint y,
       GLsizei width,
       GLsizei height,
       GLint border);
@@ skipping 11178 matching lines @@
     start = 0;
   }
   GLint end = start + range;
   if (end > sourceRange) {
     range -= end - sourceRange;
   }
   *out_start = start;
   *out_range = range;
 }
 
+bool GLES2DecoderImpl::ValidateCopyTexFormat(
+    const char* func_name, GLenum internal_format,
+    GLenum read_format, GLenum read_type) {
+  if (read_format == 0) {
+    LOCAL_SET_GL_ERROR(
+        GL_INVALID_OPERATION, func_name, "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");
+    return false;
+  }
+  if (feature_info_->IsES3Enabled()) {
+    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");
+      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");
+    return false;
+  }
+  if (feature_info_->IsES3Enabled()) {
+    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, "imcompatible color component sizes");
+        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";
   DCHECK(!ShouldDeferReads());
   TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopyTexImage2D", "unknown texture for target");
+        GL_INVALID_OPERATION, func_name, "unknown texture for target");
     return;
   }
   Texture* texture = texture_ref->texture();
   if (texture->IsImmutable()) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, "glCopyTexImage2D", "texture is immutable");
+        GL_INVALID_OPERATION, func_name, "texture is immutable");
     return;
   }
   if (!texture_manager()->ValidForTarget(target, level, width, height, 1) ||
       border != 0) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glCopyTexImage2D", "dimensions out of range");
+        GL_INVALID_VALUE, func_name, "dimensions out of range");
     return;
   }
 
-  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D",
+  if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  if (read_format == 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopyTexImage2D",
-        "no valid color image");
+  GLenum read_type = GetBoundReadFrameBufferTextureType();
+  if (!ValidateCopyTexFormat(func_name, internal_format,
+                             read_format, read_type)) {
     return;
   }
 
-  // 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_exist) != channels_needed) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, "glCopyTexImage2D", "incompatible format");
-    return;
-  }
-
-  if (feature_info_->IsES3Enabled()) {
-    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, "glCopyTexImage2D", "incompatible format");
-      return;
-    }
-  }
-
-  if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopyTexImage2D", "can not be used with depth or stencil textures");
-    return;
-  }
-
   uint32_t pixels_size = 0;
   GLenum format = TextureManager::ExtractFormatFromStorageFormat(
       internal_format);
   GLenum type = TextureManager::ExtractTypeFromStorageFormat(internal_format);
   // Only target image size is validated here.
   if (!GLES2Util::ComputeImageDataSizes(
       width, height, 1, format, type,
       state_.unpack_alignment, &pixels_size, NULL, NULL)) {
-    LOCAL_SET_GL_ERROR(
-        GL_OUT_OF_MEMORY, "glCopyTexImage2D", "dimensions too large");
+    LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "dimensions too large");
     return;
   }
 
   if (!EnsureGPUMemoryAvailable(pixels_size)) {
-    LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopyTexImage2D", "out of memory");
+    LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "out of memory");
     return;
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
-        "glCopyTexImage2D", "source and destination textures are the same");
+        func_name, "source and destination textures are the same");
     return;
   }
 
-  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyTexImage2D");
+  LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER(func_name);
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   // Clip to size to source dimensions
   GLint copyX = 0;
   GLint copyY = 0;
@@ skipping 21 matching lines @@
                           destX, destY, copyX, copyY,
                           copyWidth, copyHeight);
     }
   } else {
     GLenum final_internal_format =
         texture_manager()->AdjustTexInternalFormat(internal_format);
 
     // The service id and target of the texture attached to READ_FRAMEBUFFER.
     GLuint source_texture_service_id = 0;
     GLenum source_texture_target = 0;
+    uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     bool use_workaround = NeedsCopyTextureImageWorkaround(
         final_internal_format, channels_exist, &source_texture_service_id,
         &source_texture_target);
     if (use_workaround) {
       GLenum dest_texture_target = target;
       GLenum framebuffer_target = features().chromium_framebuffer_multisample
                                       ? GL_READ_FRAMEBUFFER_EXT
                                       : GL_FRAMEBUFFER;
 
       GLenum temp_internal_format = 0;
@@ skipping 28 matching lines @@
       glFramebufferTexture2DEXT(framebuffer_target, GL_COLOR_ATTACHMENT0,
                                 source_texture_target,
                                 source_texture_service_id, 0);
 
       glDeleteTextures(1, &temp_texture);
     } else {
       glCopyTexImage2D(target, level, final_internal_format, copyX, copyY,
                        copyWidth, copyHeight, border);
     }
   }
-  GLenum error = LOCAL_PEEK_GL_ERROR("glCopyTexImage2D");
+  GLenum error = LOCAL_PEEK_GL_ERROR(func_name);
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, 1, border, format,
                                     type, gfx::Rect(width, height));
     texture->ApplyFormatWorkarounds(feature_info_.get());
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage2D(
     GLenum target,
     GLint level,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height) {
+  const char* func_name = "glCopyTexSubImage2D";
   DCHECK(!ShouldDeferReads());
   TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture_ref) {
     LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopyTexSubImage2D", "unknown texture for target");
+        GL_INVALID_OPERATION, func_name, "unknown texture for target");
     return;
   }
   Texture* texture = texture_ref->texture();
   GLenum type = 0;
-  GLenum format = 0;
-  if (!texture->GetLevelType(target, level, &type, &format) ||
+  GLenum internal_format = 0;
+  if (!texture->GetLevelType(target, level, &type, &internal_format) ||
       !texture->ValidForTexture(
           target, level, xoffset, yoffset, 0, width, height, 1)) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_VALUE, "glCopyTexSubImage2D", "bad dimensions.");
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "bad dimensions.");
     return;
   }
 
-  if (!CheckBoundReadFramebufferValid("glCopyTexImage2D",
+  if (!CheckBoundReadFramebufferValid(func_name,
                                       GL_INVALID_FRAMEBUFFER_OPERATION)) {
     return;
   }
 
   GLenum read_format = GetBoundReadFrameBufferInternalFormat();
-  if (read_format == 0) {
-    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopyTexImage2D",
-        "no valid color image");
-    return;
-  }
-  // Check we have compatible formats.
-  uint32_t channels_exist = GLES2Util::GetChannelsForFormat(read_format);
-  uint32_t channels_needed = GLES2Util::GetChannelsForFormat(format);
-
-  if (!channels_needed ||
-      (channels_needed & channels_exist) != channels_needed) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION, "glCopyTexSubImage2D", "incompatible format");
-    return;
-  }
-
-  if ((channels_needed & (GLES2Util::kDepth | GLES2Util::kStencil)) != 0) {
-    LOCAL_SET_GL_ERROR(
-        GL_INVALID_OPERATION,
-        "glCopySubImage2D", "can not be used with depth or stencil textures");
+  GLenum read_type = GetBoundReadFrameBufferTextureType();
+  if (!ValidateCopyTexFormat(func_name, internal_format,
+                             read_format, read_type)) {
     return;
   }
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
-        "glCopyTexSubImage2D", "source and destination textures are the same");
+        func_name, "source and destination textures are the same");
     return;
   }
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
   gfx::Size size = GetBoundReadFrameBufferSize();
   GLint copyX = 0;
   GLint copyY = 0;
   GLint copyWidth = 0;
   GLint copyHeight = 0;
   Clip(x, width, size.width(), &copyX, &copyWidth);
@@ skipping 10 matching lines @@
             texture->GetLevelClearedRect(target, level),
             gfx::Rect(destX, destY, copyWidth, copyHeight), &cleared_rect)) {
       DCHECK_GE(cleared_rect.size().GetArea(),
                 texture->GetLevelClearedRect(target, level).size().GetArea());
       texture_manager()->SetLevelClearedRect(texture_ref, target, level,
                                              cleared_rect);
     } else {
       // Otherwise clear part of texture level that is not already cleared.
       if (!texture_manager()->ClearTextureLevel(this, texture_ref, target,
                                                 level)) {
-        LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D",
-                           "dimensions too big");
+        LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "dimensions too big");
         return;
       }
     }
   } else {
     // Write all pixels in below.
     texture_manager()->SetLevelCleared(texture_ref, target, level, true);
   }
 
   if (copyHeight > 0 && copyWidth > 0) {
     glCopyTexSubImage2D(target, level,
@@ skipping 4339 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