Handle UNPACK_SKIP_* and PACK_SKIP_* parameters on the client side.

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 940 matching lines @@
     case GL_MINOR_VERSION:
       *params = capabilities_.minor_version;
       return true;
     case GL_NUM_EXTENSIONS:
       UpdateCachedExtensionsIfNeeded();
       *params = cached_extensions_.size();
       return true;
     case GL_NUM_PROGRAM_BINARY_FORMATS:
       *params = capabilities_.num_program_binary_formats;
       return true;
+    case GL_PACK_SKIP_PIXELS:
+      *params = pack_skip_pixels_;
+      return true;
+    case GL_PACK_SKIP_ROWS:
+      *params = pack_skip_rows_;
+      return true;
     case GL_PIXEL_PACK_BUFFER_BINDING:
       *params = bound_pixel_pack_buffer_;
       return true;
     case GL_PIXEL_UNPACK_BUFFER_BINDING:
       *params = bound_pixel_unpack_buffer_;
       return true;
     case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
       *params = bound_transform_feedback_buffer_;
       return true;
     case GL_UNIFORM_BUFFER_BINDING:
       *params = bound_uniform_buffer_;
       return true;
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
       *params = capabilities_.uniform_buffer_offset_alignment;
       return true;
+    case GL_UNPACK_SKIP_IMAGES:
+      *params = unpack_skip_images_;
+      return true;
+    case GL_UNPACK_SKIP_PIXELS:
+      *params = unpack_skip_pixels_;
+      return true;
+    case GL_UNPACK_SKIP_ROWS:
+      *params = unpack_skip_rows_;
+      return true;
 
     // Non-cached ES3 parameters.
     case GL_DRAW_BUFFER0:
     case GL_DRAW_BUFFER1:
     case GL_DRAW_BUFFER2:
     case GL_DRAW_BUFFER3:
     case GL_DRAW_BUFFER4:
     case GL_DRAW_BUFFER5:
     case GL_DRAW_BUFFER6:
     case GL_DRAW_BUFFER7:
     case GL_DRAW_BUFFER8:
     case GL_DRAW_BUFFER9:
     case GL_DRAW_BUFFER10:
     case GL_DRAW_BUFFER11:
     case GL_DRAW_BUFFER12:
     case GL_DRAW_BUFFER13:
     case GL_DRAW_BUFFER14:
     case GL_DRAW_BUFFER15:
     case GL_DRAW_FRAMEBUFFER_BINDING:
     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT:
     case GL_PACK_ROW_LENGTH:
-    case GL_PACK_SKIP_PIXELS:
-    case GL_PACK_SKIP_ROWS:
     case GL_PRIMITIVE_RESTART_FIXED_INDEX:
     case GL_PROGRAM_BINARY_FORMATS:
     case GL_RASTERIZER_DISCARD:
     case GL_READ_BUFFER:
     case GL_READ_FRAMEBUFFER_BINDING:
     case GL_SAMPLER_BINDING:
     case GL_TEXTURE_BINDING_2D_ARRAY:
     case GL_TEXTURE_BINDING_3D:
     case GL_TRANSFORM_FEEDBACK_BINDING:
     case GL_TRANSFORM_FEEDBACK_ACTIVE:
     case GL_TRANSFORM_FEEDBACK_PAUSED:
     case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
     case GL_TRANSFORM_FEEDBACK_BUFFER_START:
     case GL_UNIFORM_BUFFER_SIZE:
     case GL_UNIFORM_BUFFER_START:
     case GL_UNPACK_IMAGE_HEIGHT:
     case GL_UNPACK_ROW_LENGTH:
-    case GL_UNPACK_SKIP_IMAGES:
-    case GL_UNPACK_SKIP_PIXELS:
-    case GL_UNPACK_SKIP_ROWS:
     case GL_VERTEX_ARRAY_BINDING:
       return false;
     default:
       return false;
   }
 }
 
 bool GLES2Implementation::GetBooleanvHelper(GLenum pname, GLboolean* params) {
   // TODO(gman): Make this handle pnames that return more than 1 value.
   GLint value;
@@ skipping 728 matching lines @@
       buffer.offset() + shader_id_size,
       length);
   CheckGLError();
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPixelStorei("
       << GLES2Util::GetStringPixelStore(pname) << ", "
       << param << ")");
+  // We have to validate before caching these parameters because we use them
+  // to compute image sizes on the client side.
+  switch (pname) {
+    case GL_PACK_ALIGNMENT:
+    case GL_UNPACK_ALIGNMENT:
+      if (param != 1 && param != 2 && param != 4 && param != 8) {
+        SetGLError(GL_INVALID_VALUE, "glPixelStorei", "invalid param");
+        return;
+      }
+      break;
+    case GL_PACK_ROW_LENGTH:
+    case GL_PACK_SKIP_PIXELS:
+    case GL_PACK_SKIP_ROWS:
+    case GL_UNPACK_IMAGE_HEIGHT:
+    case GL_UNPACK_SKIP_IMAGES:
+      if (capabilities_.major_version < 3) {
+        SetGLError(GL_INVALID_ENUM, "glPixelStorei", "invalid pname");
+        return;
+      }
+      if (param < 0) {
+        SetGLError(GL_INVALID_VALUE, "glPixelStorei", "invalid param");
+        return;
+      }
+      break;
+    case GL_UNPACK_ROW_LENGTH:
+    case GL_UNPACK_SKIP_ROWS:
+    case GL_UNPACK_SKIP_PIXELS:
+      // These parameters are always enabled in ES2 by EXT_unpack_subimage.
+      if (param < 0) {
+        SetGLError(GL_INVALID_VALUE, "glPixelStorei", "invalid param");
+        return;
+      }
+      break;
+    default:
+      SetGLError(GL_INVALID_ENUM, "glPixelStorei", "invalid pname");
+      return;
+  }
+  // Do not send SKIP parameters to the service side.
+  // Handle them on the client side.
   switch (pname) {
     case GL_PACK_ALIGNMENT:
       pack_alignment_ = param;
       break;
     case GL_PACK_ROW_LENGTH:
       pack_row_length_ = param;
       break;
     case GL_PACK_SKIP_PIXELS:
       pack_skip_pixels_ = param;
-      break;
+      return;
     case GL_PACK_SKIP_ROWS:
       pack_skip_rows_ = param;
-      break;
+      return;
     case GL_UNPACK_ALIGNMENT:
       unpack_alignment_ = param;
       break;
-    case GL_UNPACK_ROW_LENGTH_EXT:
+    case GL_UNPACK_ROW_LENGTH:
       unpack_row_length_ = param;
+      if (capabilities_.major_version < 3) {
+        // In ES2 with EXT_unpack_subimage, it's handled on the client side
+        // and there is no need to send it to the service side.
+        return;
+      }
       break;
     case GL_UNPACK_IMAGE_HEIGHT:
       unpack_image_height_ = param;
       break;
-    case GL_UNPACK_SKIP_ROWS_EXT:
+    case GL_UNPACK_SKIP_ROWS:
       unpack_skip_rows_ = param;
-      break;
-    case GL_UNPACK_SKIP_PIXELS_EXT:
+      return;
+    case GL_UNPACK_SKIP_PIXELS:
       unpack_skip_pixels_ = param;
-      break;
+      return;
     case GL_UNPACK_SKIP_IMAGES:
       unpack_skip_images_ = param;
-      break;
+      return;
     default:
+      NOTREACHED();
       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("
@@ skipping 1731 matching lines @@
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef cmds::ReadPixels::Result Result;
 
-  if (bound_pixel_pack_buffer_) {
-    GLuint offset = ToGLuint(pixels);
-    helper_->ReadPixels(
-        xoffset, yoffset, width, height, format, type, 0, offset, 0, 0, false);
-    CheckGLError();
-    return;
-  }
-
   uint32_t size;
   uint32_t unpadded_row_size;
   uint32_t padded_row_size;
   uint32_t skip_size;
   PixelStoreParams params;
   params.alignment = pack_alignment_;
   params.row_length = pack_row_length_;
   params.skip_pixels = pack_skip_pixels_;
   params.skip_rows = pack_skip_rows_;
   if (!GLES2Util::ComputeImageDataSizesES3(width, height, 1,
                                            format, type,
                                            params,
                                            &size,
                                            &unpadded_row_size,
                                            &padded_row_size,
                                            &skip_size,
                                            nullptr)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
   }
+
+  if (bound_pixel_pack_buffer_) {
+    base::CheckedNumeric<GLuint> offset = ToGLuint(pixels);
+    offset += skip_size;
+    if (!offset.IsValid()) {
+      SetGLError(GL_INVALID_VALUE, "glReadPixels", "skip size too large.");
+      return;
+    }
+    helper_->ReadPixels(xoffset, yoffset, width, height, format, type, 0,
+                        offset.ValueOrDefault(0), 0, 0, false);
+    CheckGLError();
+    return;
+  }
+
   uint32_t service_padded_row_size = 0;
   if (pack_row_length_ > 0 && pack_row_length_ != width) {
     if (!GLES2Util::ComputeImagePaddedRowSize(width,
                                               format, type,
                                               pack_alignment_,
                                               &service_padded_row_size)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
       return;
     }
   } else {
     service_padded_row_size = padded_row_size;
   }
 
   if (bound_pixel_pack_transfer_buffer_id_) {
     if (pack_row_length_ > 0 || pack_skip_pixels_ > 0 || pack_skip_rows_ > 0) {
       SetGLError(GL_INVALID_OPERATION, "glReadPixels",
                  "No ES3 pack parameters with pixel pack transfer buffer.");
       return;
     }
     DCHECK_EQ(0u, skip_size);
     GLuint offset = ToGLuint(pixels);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_pack_transfer_buffer_id_, "glReadPixels", offset, size);
     if (buffer && buffer->shm_id() != -1) {
       helper_->ReadPixels(xoffset, yoffset, width, height, format, type,
-                          buffer->shm_id(), buffer->shm_offset(),
+                          buffer->shm_id(), buffer->shm_offset() + offset,
                           0, 0, true);
       CheckGLError();
     }
     return;
   }
 
   if (!pixels) {
     SetGLError(GL_INVALID_OPERATION, "glReadPixels", "pixels = NULL");
     return;
   }
@@ skipping 2960 matching lines @@
   cached_extensions_.clear();
 }
 
 // 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