Upgrade PixelStorei to ES3/WebGL2.

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
@@ skipping 67 matching lines @@
     TransferBufferInterface* transfer_buffer,
     bool bind_generates_resource,
     bool lose_context_when_out_of_memory,
     bool support_client_side_arrays,
     GpuControl* gpu_control)
     : helper_(helper),
       transfer_buffer_(transfer_buffer),
       angle_pack_reverse_row_order_status_(kUnknownExtensionStatus),
       chromium_framebuffer_multisample_(kUnknownExtensionStatus),
       pack_alignment_(4),
+      pack_row_length_(0),
+      pack_skip_pixels_(0),
+      pack_skip_rows_(0),
       unpack_alignment_(4),
       unpack_row_length_(0),
       unpack_image_height_(0),
       unpack_skip_rows_(0),
       unpack_skip_pixels_(0),
       unpack_skip_images_(0),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_read_framebuffer_(0),
@@ skipping 1612 matching lines @@
   CheckGLError();
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPixelStorei("
       << GLES2Util::GetStringPixelStore(pname) << ", "
       << param << ")");
   switch (pname) {
     case GL_PACK_ALIGNMENT:
-        pack_alignment_ = param;
-        break;
+      pack_alignment_ = param;
+      break;
+    case GL_PACK_ROW_LENGTH:
+      pack_row_length_ = param;
+      break;
+    case GL_PACK_SKIP_PIXELS:
+      pack_skip_pixels_ = param;
+      break;
+    case GL_PACK_SKIP_ROWS:
+      pack_skip_rows_ = param;
+      break;
     case GL_UNPACK_ALIGNMENT:
-        unpack_alignment_ = param;
-        break;
+      unpack_alignment_ = param;
+      break;
     case GL_UNPACK_ROW_LENGTH_EXT:
-        unpack_row_length_ = param;
-        return;
+      unpack_row_length_ = param;
+      return;
     case GL_UNPACK_IMAGE_HEIGHT:
-        unpack_image_height_ = param;
-        return;
+      unpack_image_height_ = param;
+      return;
     case GL_UNPACK_SKIP_ROWS_EXT:
-        unpack_skip_rows_ = param;
-        return;
+      unpack_skip_rows_ = param;
+      return;
     case GL_UNPACK_SKIP_PIXELS_EXT:
-        unpack_skip_pixels_ = param;
-        return;
+      unpack_skip_pixels_ = param;
+      return;
     case GL_UNPACK_SKIP_IMAGES:
-        unpack_skip_images_ = param;
-        return;
+      unpack_skip_images_ = param;
+      return;
     case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
-        pack_reverse_row_order_ =
-            IsAnglePackReverseRowOrderAvailable() ? (param != 0) : false;
-        break;
+      pack_reverse_row_order_ =
+          IsAnglePackReverseRowOrderAvailable() ? (param != 0) : false;
+      break;
     default:
-        break;
+      break;
   }
   helper_->PixelStorei(pname, param);
   CheckGLError();
 }
 
 void GLES2Implementation::VertexAttribIPointer(
     GLuint index, GLint size, GLenum type, GLsizei stride, const void* ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribIPointer("
       << index << ", "
@@ skipping 1709 matching lines @@
   uint32 temp_size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, 2, 1, format, type, pack_alignment_, &temp_size,
       &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
   }
 
+  if (bound_pixel_pack_buffer_) {
+    // TODO(zmo): Need to handle the case of reading into a PIXEL_PACK_BUFFER
+    // in ES3. For now, generate a GL error.
+    SetGLError(GL_INVALID_OPERATION, "glReadPixels",
+               "ReadPixels to a pixel pack buffer isn't implemented");
+    return;
+  }
+
   if (bound_pixel_pack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_pack_transfer_buffer_id_,
         "glReadPixels", offset, padded_row_size * height);
     if (buffer && buffer->shm_id() != -1) {
       helper_->ReadPixels(xoffset, yoffset, width, height, format, type,
                           buffer->shm_id(), buffer->shm_offset(),
                           0, 0, true);
       CheckGLError();
     }
     return;
   }
 
   if (!pixels) {
     SetGLError(GL_INVALID_OPERATION, "glReadPixels", "pixels = NULL");
     return;
   }
 
+  // compute the advance bytes per row for the dst pixels
+  uint32 dst_padded_row_size;
+  if (pack_row_length_ > 0) {
+    if (!GLES2Util::ComputeImagePaddedRowSize(
+        pack_row_length_, format, type, pack_alignment_,
+        &dst_padded_row_size)) {
+      SetGLError(
+          GL_INVALID_VALUE, "glReadPixels", "pack row length too large");
+      return;
+    }
+  } else {
+    dst_padded_row_size = padded_row_size;
+  }
+
+  // Advance pixels pointer past the skip rows and skip pixels
+  dest += pack_skip_rows_ * dst_padded_row_size;
+  if (pack_skip_pixels_) {
+    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    dest += pack_skip_pixels_ * group_size;
+  }
+
   // Transfer by rows.
   // The max rows we can transfer.
   while (height) {
     GLsizei desired_size = padded_row_size * (height - 1) + unpadded_row_size;
     ScopedTransferBufferPtr buffer(desired_size, helper_, transfer_buffer_);
     if (!buffer.valid()) {
       return;
     }
     GLint num_rows = ComputeNumRowsThatFitInBuffer(
         padded_row_size, unpadded_row_size, buffer.size(), height);
@@ skipping 10 matching lines @@
         buffer.shm_id(), buffer.offset(),
         GetResultShmId(), GetResultShmOffset(),
         false);
     WaitForCmd();
     if (*result != 0) {
       // when doing a y-flip we have to iterate through top-to-bottom chunks
       // of the dst. The service side handles reversing the rows within a
       // chunk.
       int8* rows_dst;
       if (pack_reverse_row_order_) {
-          rows_dst = dest + (height - num_rows) * padded_row_size;
+          rows_dst = dest + (height - num_rows) * dst_padded_row_size;
       } else {
           rows_dst = dest;
       }
       // We have to copy 1 row at a time to avoid writing pad bytes.
       const int8* src = static_cast<const int8*>(buffer.address());
       for (GLint yy = 0; yy < num_rows; ++yy) {
         memcpy(rows_dst, src, unpadded_row_size);
-        rows_dst += padded_row_size;
+        rows_dst += dst_padded_row_size;
         src += padded_row_size;
       }
       if (!pack_reverse_row_order_) {
         dest = rows_dst;
       }
     }
     // If it was not marked as successful exit.
     if (*result == 0) {
       return;
     }
@@ skipping 2847 matching lines @@
   CheckGLError();
 }
 
 // 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/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu