Use gfx::Rect::Intersect() to clip for CopyTex{Sub}Image functions.

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 13375 matching lines @@
   } else {
     glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
                               format, image_size, data);
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
-static void Clip(
-    GLint start, GLint range, GLint sourceRange,
-    GLint* out_start, GLint* out_range) {
-  DCHECK(out_start);
-  DCHECK(out_range);
-  if (start < 0) {
-    range += start;
-    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);
@@ skipping 137 matching lines @@
 
   bool requires_luma_blit =
       CopyTexImageResourceManager::CopyTexImageRequiresBlit(feature_info_.get(),
                                                             format);
   if (requires_luma_blit &&
       !InitializeCopyTexImageBlitter(func_name)) {
     return;
   }
 
   // Clip to size to source dimensions
-  GLint copyX = 0;
-  GLint copyY = 0;
-  GLint copyWidth = 0;
-  GLint copyHeight = 0;
-  Clip(x, width, size.width(), &copyX, &copyWidth);
-  Clip(y, height, size.height(), &copyY, &copyHeight);
+  gfx::Rect src(x, y, width, height);
+  const gfx::Rect dst(0, 0, size.width(), size.height());
+  src.Intersect(dst);
 
-  if (copyX != x ||
-      copyY != y ||
-      copyWidth != width ||
-      copyHeight != height) {
+  if (src.x() != x || src.y() != y ||
+      src.width() != width || src.height() != height) {
     // some part was clipped so clear the rect.
     std::unique_ptr<char[]> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexImage2D(target, level, TextureManager::AdjustTexInternalFormat(
                                     feature_info_.get(), internal_format),
                  width, height, border, format, type, zero.get());
-    if (copyHeight > 0 && copyWidth > 0) {
-      GLint dx = copyX - x;
-      GLint dy = copyY - y;
-      GLint destX = dx;
-      GLint destY = dy;
+    if (!src.IsEmpty()) {
+      GLint destX = src.x() - x;
+      GLint destY = src.y() - y;
       if (requires_luma_blit) {
         copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
             this, texture->service_id(), texture->target(), target, format,
-            type, level, destX, destY, 0, copyX, copyY, copyWidth, copyHeight,
+            type, level, destX, destY, 0,
+            src.x(), src.y(), src.width(), src.height(),
             GetBoundReadFramebufferServiceId(),
             GetBoundReadFramebufferInternalFormat());
       } else {
-        glCopyTexSubImage2D(target, level, destX, destY, copyX, copyY,
-                            copyWidth, copyHeight);
+        glCopyTexSubImage2D(target, level, destX, destY,
+                            src.x(), src.y(), src.width(), src.height());
       }
     }
   } else {
     GLenum final_internal_format = TextureManager::AdjustTexInternalFormat(
         feature_info_.get(), internal_format);
     if (workarounds().init_two_cube_map_levels_before_copyteximage &&
         texture->target() == GL_TEXTURE_CUBE_MAP &&
         target != GL_TEXTURE_CUBE_MAP_POSITIVE_X) {
       for (int i = 0; i < 2; ++i) {
         TextureManager::DoTexImageArguments args = {
           target, i, final_internal_format, 1, 1, 1, border,
           format, type, nullptr, 1, 0,
           TextureManager::DoTexImageArguments::kTexImage2D };
         texture_manager()->WorkaroundCopyTexImageCubeMap(&texture_state_,
             &state_, &framebuffer_state_, texture_ref, func_name, args);
       }
     }
 
     // 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 (requires_luma_blit) {
       copy_tex_image_blit_->DoCopyTexImage2DToLUMACompatibilityTexture(
           this, texture->service_id(), texture->target(), target, format,
-          type, level, internal_format, copyX, copyY, copyWidth, copyHeight,
+          type, level, internal_format, x, y, width, height,
           GetBoundReadFramebufferServiceId(),
           GetBoundReadFramebufferInternalFormat());
     } else 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;
       if (channels_exist == GLES2Util::kRGBA) {
         temp_internal_format = GL_RGBA;
       } else if (channels_exist == GLES2Util::kRGB) {
         temp_internal_format = GL_RGB;
       } else {
         NOTREACHED();
       }
 
       GLuint temp_texture;
       {
         // Copy from the read framebuffer into |temp_texture|.
         glGenTextures(1, &temp_texture);
         ScopedTextureBinder binder(&state_, temp_texture,
                                    source_texture_target);
-        glCopyTexImage2D(source_texture_target, 0, temp_internal_format, copyX,
-                         copyY, copyWidth, copyHeight, border);
+        glCopyTexImage2D(source_texture_target, 0, temp_internal_format,
+                         x, y, width, height, border);
 
         // Attach the temp texture to the read framebuffer.
         glFramebufferTexture2DEXT(framebuffer_target, GL_COLOR_ATTACHMENT0,
                                   source_texture_target, temp_texture, 0);
       }
 
       // Copy to the final texture.
       DCHECK_EQ(static_cast<GLuint>(GL_TEXTURE_2D), dest_texture_target);
       glCopyTexImage2D(dest_texture_target, level, final_internal_format, 0, 0,
-                       copyWidth, copyHeight, 0);
+                       width, height, 0);
 
       // Rebind source texture.
       glFramebufferTexture2DEXT(framebuffer_target, GL_COLOR_ATTACHMENT0,
                                 source_texture_target,
                                 source_texture_service_id, 0);
 
       glDeleteTextures(1, &temp_texture);
     } else {
       if (workarounds().init_one_cube_map_level_before_copyteximage &&
           texture->target() == GL_TEXTURE_CUBE_MAP &&
           target != GL_TEXTURE_CUBE_MAP_POSITIVE_X) {
         TextureManager::DoTexImageArguments args = {
           target, level, final_internal_format, width, height, 1, border,
           format, type, nullptr, pixels_size, 0,
           TextureManager::DoTexImageArguments::kTexImage2D };
         texture_manager()->WorkaroundCopyTexImageCubeMap(&texture_state_,
             &state_, &framebuffer_state_, texture_ref, func_name, args);
       }
-      glCopyTexImage2D(target, level, final_internal_format, copyX, copyY,
-                       copyWidth, copyHeight, border);
+      glCopyTexImage2D(target, level, final_internal_format,
+                       x, y, width, height, border);
     }
   }
   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());
   }
 
@@ skipping 44 matching lines @@
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, 0)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         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);
-  Clip(y, height, size.height(), &copyY, &copyHeight);
 
-  GLint dx = copyX - x;
-  GLint dy = copyY - y;
+  gfx::Rect src(x, y, width, height);
+  const gfx::Rect dst(0, 0, size.width(), size.height());
+  src.Intersect(dst);
+
+  if (src.IsEmpty())
+    return;
+
+  GLint dx = src.x() - x;
+  GLint dy = src.y() - y;
   GLint destX = xoffset + dx;
   GLint destY = yoffset + dy;
   // It's only legal to skip clearing the level of the target texture
   // if the entire level is being redefined.
   GLsizei level_width = 0;
   GLsizei level_height = 0;
   GLsizei level_depth = 0;
   bool have_level = texture->GetLevelSize(
       target, level, &level_width, &level_height, &level_depth);
   // Validated above.
   DCHECK(have_level);
   if (destX == 0 && destY == 0 &&
-      copyWidth == level_width && copyHeight == level_height) {
+      src.width() == level_width && src.height() == level_height) {
     // Write all pixels in below.
     texture_manager()->SetLevelCleared(texture_ref, target, level, true);
   } else {
     gfx::Rect cleared_rect;
     if (TextureManager::CombineAdjacentRects(
             texture->GetLevelClearedRect(target, level),
-            gfx::Rect(destX, destY, copyWidth, copyHeight), &cleared_rect)) {
+            gfx::Rect(destX, destY, src.width(), src.height()),
+            &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, func_name, "dimensions too big");
         return;
       }
     }
   }
 
-  if (copyHeight > 0 && copyWidth > 0) {
-    if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
-            feature_info_.get(), internal_format)) {
-      if (!InitializeCopyTexImageBlitter("glCopyTexSubImage2D")) {
-        return;
-      }
-      copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
-          this, texture->service_id(), texture->target(), target,
-          internal_format, type, level, destX, destY, 0,
-          copyX, copyY, copyWidth, copyHeight,
-          GetBoundReadFramebufferServiceId(),
-          GetBoundReadFramebufferInternalFormat());
-    } else {
-      glCopyTexSubImage2D(target, level, destX, destY, copyX, copyY, copyWidth,
-                          copyHeight);
+  if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
+          feature_info_.get(), internal_format)) {
+    if (!InitializeCopyTexImageBlitter("glCopyTexSubImage2D")) {
+      return;
     }
+    copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
+        this, texture->service_id(), texture->target(), target,
+        internal_format, type, level, destX, destY, 0,
+        src.x(), src.y(), src.width(), src.height(),
+        GetBoundReadFramebufferServiceId(),
+        GetBoundReadFramebufferInternalFormat());
+  } else {
+    glCopyTexSubImage2D(target, level, destX, destY,
+                        src.x(), src.y(), src.width(), src.height());
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 void GLES2DecoderImpl::DoCopyTexSubImage3D(
     GLenum target,
     GLint level,
@@ skipping 37 matching lines @@
 
   if (FormsTextureCopyingFeedbackLoop(texture_ref, level, zoffset)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         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);
-  Clip(y, height, size.height(), &copyY, &copyHeight);
 
-  GLint dx = copyX - x;
-  GLint dy = copyY - y;
+  gfx::Rect src(x, y, width, height);
+  const gfx::Rect dst(0, 0, size.width(), size.height());
+  src.Intersect(dst);
+  if (src.IsEmpty())
+    return;
+
+  GLint dx = src.x() - x;
+  GLint dy = src.y() - y;
   GLint destX = xoffset + dx;
   GLint destY = yoffset + dy;
   // For 3D textures, we always clear the entire texture to 0 if it is not
   // cleared. See the code in TextureManager::ValidateAndDoTexSubImage
   // for TexSubImage3D.
   if (!texture->IsLevelCleared(target, level)) {
     if (!texture_manager()->ClearTextureLevel(this, texture_ref, target,
                                               level)) {
       LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, func_name, "dimensions too big");
       return;
     }
     DCHECK(texture->IsLevelCleared(target, level));
   }
 
-  if (copyHeight > 0 && copyWidth > 0) {
-    if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
-            feature_info_.get(), internal_format)) {
-      if (!InitializeCopyTexImageBlitter(func_name)) {
-        return;
-      }
-      copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
-          this, texture->service_id(), texture->target(), target,
-          internal_format, type, level, destX, destY, zoffset,
-          copyX, copyY, copyWidth, copyHeight,
-          GetBoundReadFramebufferServiceId(),
-          GetBoundReadFramebufferInternalFormat());
-    } else {
-      glCopyTexSubImage3D(target, level, destX, destY, zoffset,
-                          copyX, copyY, copyWidth, copyHeight);
+  if (CopyTexImageResourceManager::CopyTexImageRequiresBlit(
+          feature_info_.get(), internal_format)) {
+    if (!InitializeCopyTexImageBlitter(func_name)) {
+      return;
     }
+    copy_tex_image_blit_->DoCopyTexSubImageToLUMACompatibilityTexture(
+        this, texture->service_id(), texture->target(), target,
+        internal_format, type, level, destX, destY, zoffset,
+        src.x(), src.y(), src.width(), src.height(),
+        GetBoundReadFramebufferServiceId(),
+        GetBoundReadFramebufferInternalFormat());
+  } else {
+    glCopyTexSubImage3D(target, level, destX, destY, zoffset,
+                        src.x(), src.y(), src.width(), src.height());
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleTexSubImage2D(
     uint32_t immediate_data_size, const volatile void* cmd_data) {
   const char* func_name = "glTexSubImage2D";
@@ skipping 4569 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