Add GL_EXT_unpack_subimage support to command buffer client code.

gpu/command_buffer/client/gles2_implementation_unittest.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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include "gpu/command_buffer/client/client_test_helper.h"
@@ skipping 1766 matching lines @@
 
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
-static bool ComputeImageDataSizes(
-    int width, int height, int format, int type, int unpack_alignment,
-    uint32* size, uint32* unpadded_row_size, uint32* padded_row_size) {
-  uint32 temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 1, format, type, unpack_alignment, &temp_size)) {
-    return false;
-  }
-  *unpadded_row_size = temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 2, format, type, unpack_alignment, &temp_size)) {
-    return false;
-  }
-  *padded_row_size = temp_size - *unpadded_row_size;
-  return GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment, size);
-}
-
 static bool CheckRect(
     int width, int height, GLenum format, GLenum type, int alignment,
     bool flip_y, const uint8* r1, const uint8* r2) {
   uint32 size = 0;
   uint32 unpadded_row_size = 0;
   uint32 padded_row_size = 0;
-  if (!ComputeImageDataSizes(
+  if (!GLES2Util::ComputeImageDataSizes(
       width, height, format, type, alignment, &size, &unpadded_row_size,
       &padded_row_size)) {
     return false;
   }
 
   int r2_stride = flip_y ?
       -static_cast<int>(padded_row_size) :
       static_cast<int>(padded_row_size);
   r2 = flip_y ? (r2 + (height - 1) * padded_row_size) : r2;
 
@@ skipping 84 matching lines @@
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   const GLsizei kWidth = 3;
 
   uint32 size = 0;
   uint32 unpadded_row_size = 0;
   uint32 padded_row_size = 0;
-  ASSERT_TRUE(ComputeImageDataSizes(
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
   const GLsizei kHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
-  ASSERT_TRUE(GLES2Util::ComputeImageDataSize(
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment,
-      &size));
+      &size, NULL, NULL));
   uint32 half_size = 0;
-  ASSERT_TRUE(GLES2Util::ComputeImageDataSize(
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
-      &half_size));
+      &half_size, NULL, NULL));
 
   scoped_array<uint8> pixels(new uint8[size]);
   for (uint32 ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(half_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(half_size);
 
   Cmds expected;
@@ skipping 77 matching lines @@
   struct Cmds {
     PixelStorei pixel_store_i1;
     TexImage2D tex_image_2d;
     TexSubImage2D tex_sub_image_2d1;
     cmd::SetToken set_token1;
     TexSubImage2D tex_sub_image_2d2;
     cmd::SetToken set_token2;
   };
 
   uint32 sub_2_high_size = 0;
-  ASSERT_TRUE(GLES2Util::ComputeImageDataSize(
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
-      &sub_2_high_size));
+      &sub_2_high_size, NULL, NULL));
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sub_2_high_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sub_2_high_size);
 
   Cmds expected;
   expected.pixel_store_i1.Init(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
       kType, 0, 0);
   expected.tex_sub_image_2d1.Init(kTarget, kLevel, kSubImageXOffset,
@@ skipping 21 matching lines @@
       GL_TEXTURE_2D, 0, kSubImageXOffset, kSubImageYOffset, kSubImageWidth,
       kSubImageHeight, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment, true,
       reinterpret_cast<uint8*>(pixels.get() + 2 * kSubImageWidth),
       mem2.ptr));
 }
 
+TEST_F(GLES2ImplementationTest, SubImageUnpack) {
+  static const GLint unpack_alignments[] = { 1, 2, 4, 8 };
+
+  static const GLenum kFormat = GL_RGB;
+  static const GLenum kType = GL_UNSIGNED_BYTE;
+  static const GLint kLevel = 0;
+  static const GLint kBorder = 0;
+  // We're testing using the unpack params to pull a subimage out of a larger
+  // source of pixels. Here we specify the subimage by its border rows /
+  // columns.
+  static const GLint kSrcWidth = 33;
+  static const GLint kSrcSubImageX0 = 11;
+  static const GLint kSrcSubImageX1 = 20;
+  static const GLint kSrcSubImageY0 = 18;
+  static const GLint kSrcSubImageY1 = 23;
+  static const GLint kSrcSubImageWidth = kSrcSubImageX1 - kSrcSubImageX0;
+  static const GLint kSrcSubImageHeight = kSrcSubImageY1 - kSrcSubImageY0;
+
+  // these are only used in the texsubimage tests
+  static const GLint kTexWidth = 1023;
+  static const GLint kTexHeight = 511;
+  static const GLint kTexSubXOffset = 419;
+  static const GLint kTexSubYOffset = 103;
+
+  struct {
+    PixelStorei pixel_store_i;
+    TexImage2D tex_image_2d;
+  } texImageExpected;
+
+  struct  {
+    PixelStorei pixel_store_i;
+    TexImage2D tex_image_2d;
+    TexSubImage2D tex_sub_image_2d;
+  } texSubImageExpected;
+
+  uint32 src_size;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kSrcWidth, kSrcSubImageY1, kFormat, kType, 8, &src_size, NULL, NULL));
+  scoped_array<uint8> src_pixels;
+  src_pixels.reset(new uint8[src_size]);
+  for (size_t i = 0; i < src_size; ++i) {
+    src_pixels[i] = static_cast<int8>(i);
+  }
+
+  for (int sub = 0; sub < 2; ++sub) {
+    for (int flip_y = 0; flip_y < 2; ++flip_y) {
+      for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
+        GLint alignment = unpack_alignments[a];
+        uint32 size;
+        uint32 unpadded_row_size;
+        uint32 padded_row_size;
+        ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+            kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType, alignment,
+            &size, &unpadded_row_size, &padded_row_size));
+        ASSERT_TRUE(size <= MaxTransferBufferSize());
+        ExpectedMemoryInfo mem = GetExpectedMemory(size);
+
+        const void* commands = GetPut();
+        gl_->PixelStorei(GL_UNPACK_ALIGNMENT, alignment);
+        gl_->PixelStorei(GL_UNPACK_ROW_LENGTH, kSrcWidth);
+        gl_->PixelStorei(GL_UNPACK_SKIP_PIXELS, kSrcSubImageX0);
+        gl_->PixelStorei(GL_UNPACK_SKIP_ROWS, kSrcSubImageY0);
+        gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
+        if (sub) {
+          gl_->TexImage2D(
+              GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight, kBorder,
+              kFormat, kType, NULL);
+          gl_->TexSubImage2D(
+              GL_TEXTURE_2D, kLevel, kTexSubXOffset, kTexSubYOffset,
+              kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType,
+              src_pixels.get());
+          texSubImageExpected.pixel_store_i.Init(
+              GL_UNPACK_ALIGNMENT, alignment);
+          texSubImageExpected.tex_image_2d.Init(
+              GL_TEXTURE_2D, kLevel, kFormat, kTexWidth, kTexHeight, kBorder,
+              kFormat, kType, 0, 0);
+          texSubImageExpected.tex_sub_image_2d.Init(
+              GL_TEXTURE_2D, kLevel, kTexSubXOffset, kTexSubYOffset,
+              kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType, mem.id,
+              mem.offset, GL_FALSE);
+          EXPECT_EQ(0, memcmp(
+              &texSubImageExpected, commands, sizeof(texSubImageExpected)));
+        } else {
+          gl_->TexImage2D(
+              GL_TEXTURE_2D, kLevel, kFormat,
+              kSrcSubImageWidth, kSrcSubImageHeight, kBorder, kFormat, kType,
+              src_pixels.get());
+          texImageExpected.pixel_store_i.Init(GL_UNPACK_ALIGNMENT, alignment);
+          texImageExpected.tex_image_2d.Init(
+              GL_TEXTURE_2D, kLevel, kFormat, kSrcSubImageWidth,
+              kSrcSubImageHeight, kBorder, kFormat, kType, mem.id, mem.offset);
+          EXPECT_EQ(0, memcmp(
+              &texImageExpected, commands, sizeof(texImageExpected)));
+        }
+        uint32 src_padded_row_size;
+        ASSERT_TRUE(GLES2Util::ComputeImagePaddedRowSize(
+            kSrcWidth, kFormat, kType, alignment, &src_padded_row_size));
+        uint32 bytes_per_group = GLES2Util::ComputeImageGroupSize(
+            kFormat, kType);
+        for (int y = 0; y < kSrcSubImageHeight; ++y) {
+          GLint src_sub_y = flip_y ? kSrcSubImageHeight - y - 1 : y;
+          const uint8* src_row = src_pixels.get() +
+              (kSrcSubImageY0 + src_sub_y) * src_padded_row_size +
+              bytes_per_group * kSrcSubImageX0;
+          const uint8* dst_row = mem.ptr + y * padded_row_size;
+          EXPECT_EQ(0, memcmp(src_row, dst_row, unpadded_row_size));
+        }
+        ClearCommands();
+      }
+    }
+  }
+}
+
 // Binds can not be cached with bind_generates_resource = false because
 // our id might not be valid. More specifically if you bind on contextA then
 // delete on contextB the resource is still bound on contextA but GetInterger
 // won't return an id.
 TEST_F(GLES2ImplementationStrictSharedTest, BindsNotCached) {
   struct PNameValue {
     GLenum pname;
     GLint expected;
   };
   const PNameValue pairs[] = {
@@ skipping 44 matching lines @@
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(handle, kResult);
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 TEST_F(GLES2ImplementationTest, GetString) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
   // GL_CHROMIUM_map_sub GL_CHROMIUM_flipy are hard coded into
   // GLES2Implementation.
-  const char* expected_str = "foobar GL_CHROMIUM_map_sub GL_CHROMIUM_flipy";
+  const char* expected_str =
+      "foobar GL_CHROMIUM_map_sub GL_CHROMIUM_flipy GL_EXT_unpack_subimage";
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     GetString get_string;
     cmd::GetBucketSize get_bucket_size;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   ExpectedMemoryInfo result1 =
@@ skipping 215 matching lines @@
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(0u, available);
 }
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu