Add GL_EXT_unpack_subimage support to command buffer client code.

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 <list>
@@ skipping 1640 matching lines @@
                     0,  // border
                     format,
                     GL_UNSIGNED_BYTE,
                     NULL);
 
   size_ = size;
 
   bool success = glGetError() == GL_NO_ERROR;
   if (success) {
     uint32 image_size = 0;
-    GLES2Util::ComputeImageDataSize(
-        size.width(), size.height(), format, GL_UNSIGNED_BYTE, 4, &image_size);
+    GLES2Util::ComputeImageDataSizes(
+        size.width(), size.height(), format, GL_UNSIGNED_BYTE, 4, &image_size,
+        NULL, NULL);
     estimated_size_ = image_size;
     decoder_->UpdateBackbufferMemoryAccounting();
   }
   return success;
 }
 
 void Texture::Copy(const gfx::Size& size, GLenum format) {
   DCHECK_NE(id_, 0u);
   ScopedGLErrorSuppressor suppressor(decoder_);
   ScopedTexture2DBinder binder(decoder_, id_);
@@ skipping 4292 matching lines @@
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions < 0");
     return error::kNoError;
   }
   typedef gles2::ReadPixels::Result Result;
   uint32 pixels_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, pack_alignment_, &pixels_size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, pack_alignment_, &pixels_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!pixels || !result) {
     return error::kOutOfBounds;
   }
 
@@ skipping 24 matching lines @@
   }
 
   CopyRealGLErrorsToWrapper();
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
 
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
     // at a time.
     uint32 temp_size;
-    if (!GLES2Util::ComputeImageDataSize(
-        width, 1, format, type, pack_alignment_, &temp_size)) {
-      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
-      return error::kNoError;
-    }
-    GLsizei unpadded_row_size = temp_size;
-    if (!GLES2Util::ComputeImageDataSize(
-        width, 2, format, type, pack_alignment_, &temp_size)) {
-      SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
-      return error::kNoError;
-    }
-    GLsizei padded_row_size = temp_size - unpadded_row_size;
-    if (padded_row_size < 0 || unpadded_row_size < 0) {
+    uint32 unpadded_row_size;
+    uint32 padded_row_size;
+    if (!GLES2Util::ComputeImageDataSizes(
+        width, 2, format, type, pack_alignment_, &temp_size,
+        &unpadded_row_size, &padded_row_size)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
       return error::kNoError;
     }
 
     GLint dest_x_offset = std::max(-x, 0);
     uint32 dest_row_offset;
-    if (!GLES2Util::ComputeImageDataSize(
-      dest_x_offset, 1, format, type, pack_alignment_, &dest_row_offset)) {
+    if (!GLES2Util::ComputeImageDataSizes(
+        dest_x_offset, 1, format, type, pack_alignment_, &dest_row_offset, NULL,
+        NULL)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
       return error::kNoError;
     }
 
     // Copy each row into the larger dest rect.
     int8* dst = static_cast<int8*>(pixels);
     GLint read_x = std::max(0, x);
     GLint read_end_x = std::max(0, std::min(max_size.width(), max_x));
     GLint read_width = read_end_x - read_x;
     for (GLint yy = 0; yy < height; ++yy) {
@@ skipping 14 matching lines @@
   }
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     *result = true;
 
     GLenum read_format = GetBoundReadFrameBufferInternalFormat();
     uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     if ((channels_exist & 0x0008) == 0) {
       // Set the alpha to 255 because some drivers are buggy in this regard.
       uint32 temp_size;
-      if (!GLES2Util::ComputeImageDataSize(
-          width, 1, format, type, pack_alignment_, &temp_size)) {
-        SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
-        return error::kNoError;
-      }
-      GLsizei unpadded_row_size = temp_size;
-      if (!GLES2Util::ComputeImageDataSize(
-          width, 2, format, type, pack_alignment_, &temp_size)) {
-        SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
-        return error::kNoError;
-      }
-      GLsizei padded_row_size = temp_size - unpadded_row_size;
-      if (padded_row_size < 0 || unpadded_row_size < 0) {
+
+      uint32 unpadded_row_size;
+      uint32 padded_row_size;
+      if (!GLES2Util::ComputeImageDataSizes(
+          width, 2, format, type, pack_alignment_, &temp_size,
+          &unpadded_row_size, &padded_row_size)) {
         SetGLError(GL_INVALID_VALUE, "glReadPixels: dimensions out of range");
         return error::kNoError;
       }
       // NOTE: Assumes the type is GL_UNSIGNED_BYTE which was true at the time
       // of this implementation.
       if (type != GL_UNSIGNED_BYTE) {
         SetGLError(GL_INVALID_OPERATION, "unsupported readPixel format");
         return error::kNoError;
       }
       switch (format) {
@@ skipping 358 matching lines @@
     unsigned bind_target,
     unsigned target,
     int level,
     unsigned format,
     unsigned type,
     int width,
     int height,
     bool is_texture_immutable) {
   // Assumes the size has already been checked.
   uint32 pixels_size = 0;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &pixels_size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &pixels_size, NULL,
+      NULL)) {
     return false;
   }
   scoped_array<char> zero(new char[pixels_size]);
   memset(zero.get(), 0, pixels_size);
   glBindTexture(bind_target, service_id);
   if (is_texture_immutable) {
     glTexSubImage2D(
         target, level, 0, 0, width, height, format, type, zero.get());
   } else {
     WrappedTexImage2D(
@@ skipping 286 matching lines @@
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
   uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
   uint32 pixels_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &pixels_size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &pixels_size, NULL,
+      NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
   return DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, pixels_size);
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2DImmediate(
     uint32 immediate_data_size, const gles2::TexImage2DImmediate& c) {
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, size, immediate_data_size);
   if (!pixels) {
     return error::kOutOfBounds;
   }
   DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, size);
@@ skipping 205 matching lines @@
     SetGLError(GL_OUT_OF_MEMORY, "glCopyTexSubImage2D: dimensions too big");
     return;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
-    if (!GLES2Util::ComputeImageDataSize(
-        width, height, format, type, unpack_alignment_, &pixels_size)) {
+    if (!GLES2Util::ComputeImageDataSizes(
+        width, height, format, type, unpack_alignment_, &pixels_size, NULL,
+        NULL)) {
       SetGLError(GL_INVALID_VALUE, "glCopyTexSubImage2D: dimensions too large");
       return;
     }
     scoped_array<char> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
 
@@ skipping 86 matching lines @@
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &data_size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
@@ skipping 27 matching lines @@
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &data_size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
     SetGLError(GL_INVALID_ENUM, "glTexSubImage2D: target GL_INVALID_ENUM");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: width < 0");
@@ skipping 1117 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