Implement helper functionalities for computing image size with ES3 settings.

gpu/command_buffer/common/gles2_cmd_utils.cc

Index: gpu/command_buffer/common/gles2_cmd_utils.cc
diff --git a/gpu/command_buffer/common/gles2_cmd_utils.cc b/gpu/command_buffer/common/gles2_cmd_utils.cc
index 8b547fa2455f68e447ec69ab26fec23e01dd7f16..1e8a49be5f02310220de4935c8dcd97daabd13f0 100644
--- a/gpu/command_buffer/common/gles2_cmd_utils.cc
+++ b/gpu/command_buffer/common/gles2_cmd_utils.cc
@@ -543,28 +543,21 @@ bool GLES2Util::ComputeImageDataSizes(
   if (!SafeMultiplyUint32(height, depth, &num_of_rows)) {
     return false;
   }
-  if (num_of_rows > 1) {
-    uint32 temp;
-    if (!SafeAddUint32(row_size, unpack_alignment - 1, &temp)) {
-      return false;
-    }
-    uint32 padded_row_size = (temp / unpack_alignment) * unpack_alignment;
-    uint32 size_of_all_but_last_row;
-    if (!SafeMultiplyUint32((num_of_rows - 1), padded_row_size,
-                            &size_of_all_but_last_row)) {
-      return false;
-    }
-    if (!SafeAddUint32(size_of_all_but_last_row, row_size, size)) {
-      return false;
-    }
-    if (ret_padded_row_size) {
-      *ret_padded_row_size = padded_row_size;
-    }
-  } else {
-    *size = row_size;
-    if (ret_padded_row_size) {
-      *ret_padded_row_size = row_size;
-    }
+  uint32 temp;
+  if (!SafeAddUint32(row_size, unpack_alignment - 1, &temp)) {
+    return false;
+  }
+  uint32 padded_row_size = (temp / unpack_alignment) * unpack_alignment;
+  uint32 size_of_all_but_last_row;
+  if (!SafeMultiplyUint32((num_of_rows - 1), padded_row_size,
+                          &size_of_all_but_last_row)) {
+    return false;
+  }
+  if (!SafeAddUint32(size_of_all_but_last_row, row_size, size)) {
+    return false;
+  }
+  if (ret_padded_row_size) {
+    *ret_padded_row_size = padded_row_size;
   }
   if (ret_unpadded_row_size) {
     *ret_unpadded_row_size = row_size;
@@ -573,6 +566,49 @@ bool GLES2Util::ComputeImageDataSizes(
   return true;
 }
 
+bool GLES2Util::ComputeImageDataSizes(
+    int width, int height, int depth, int format, int type,
+    const PixelStoreParams& params,
+    uint32_t* size, uint32_t* unpadded_row_size,
+    uint32_t* padded_row_size, uint32_t* skip_size) {
+  int actual_width = params.row_length > 0 ? params.row_length : width;

[piman, 2015/12/08 00:06:10]

So, technically, the code (whether client-side, or GL, depending on the case)
will not access the trailing bytes. For example for width==height==4,
1-byte-per-pixel format, and a (un)pack_row_length of 8, the code would only
access 8 bytes on each of the first 3 row, and then 4 bytes in the last row.

So the rule is not height*pack_row_length, but (height-1)*pack_row_length +
width.
See also the code on l.551 and following above, that treats the last row
specially.

This is actually critical for the case where pack_row_length is less than the
width. In the case above, if pack_row_length is 2, then you still need to count
the last line fully - 3*2+4==10 instead of 4*2==8.

This is similar for actual_height vs (un)pack_image_height - the formula is
(depth-1)*pack_image_height +  (height-1)*pack_row_length + width.

The interesting bit is that then you don't care about whether the transfer is 2D
or 3D (so you wouldn't need ContextState::Dimension). If depth==1, then the
formula above doesn't depend on pack_image_height.

[Zhenyao Mo, 2015/12/08 23:39:17]

Done.

However, I think we still need the ContextState::Dimension arg to avoid applying
skip_images in 2D.

+  int actual_height = params.image_height > 0 ? params.image_height : height;
+  if (!ComputeImageDataSizes(actual_width, actual_height, depth, format, type,
+                             params.alignment,
+                             size, unpadded_row_size, padded_row_size)) {
+    return false;
+  }
+
+  uint32 total_skip_size = 0;
+  if (params.skip_images > 0) {
+    uint32 image_size;
+    if (!SafeMultiplyUint32(actual_height, *padded_row_size, &image_size))
+      return false;
+    if (!SafeMultiplyUint32(image_size, params.skip_images, &total_skip_size))
+      return false;
+  }
+  if (params.skip_rows > 0) {
+    uint32 temp;
+    if (!SafeMultiplyUint32(*padded_row_size, params.skip_rows, &temp))
+      return false;
+    if (!SafeAddUint32(total_skip_size, temp, &total_skip_size))
+      return false;
+  }
+  if (params.skip_pixels > 0) {
+    uint32 bytes_per_group = ComputeImageGroupSize(format, type);
+    uint32 temp;
+    if (!SafeMultiplyUint32(bytes_per_group, params.skip_pixels, &temp))
+      return false;
+    if (!SafeAddUint32(total_skip_size, temp, &total_skip_size))
+      return false;
+  }
+  if (!SafeAddUint32(*size, total_skip_size, size))

[piman, 2015/12/08 00:06:10]

I think this is more confusing than useful. Only |size| bytes are used, it's
just that they're offset to |total_skip_size|.

In particular if we want to use this to size the shared memory, we shouldn't
count the skipped bytes (since they're skipped on the client side).

[Zhenyao Mo, 2015/12/08 23:39:17]

OK, I won't write into size, but we still wanna check overflow for this add.

+    return false;
+  if (skip_size)
+    *skip_size = total_skip_size;
+  return true;
+}
+
 size_t GLES2Util::RenderbufferBytesPerPixel(int format) {
   switch (format) {
     case GL_STENCIL_INDEX8: