Add GL_EXT_unpack_subimage support to command buffer client code.

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 "../client/gles2_implementation.h"
 
 #include <map>
 #include <set>
@@ skipping 371 matching lines @@
       ShareGroup* share_group,
       TransferBufferInterface* transfer_buffer,
       bool share_resources,
       bool bind_generates_resource)
     : helper_(helper),
       transfer_buffer_(transfer_buffer),
       angle_pack_reverse_row_order_status(kUnknownExtensionStatus),
       pack_alignment_(4),
       unpack_alignment_(4),
       unpack_flip_y_(false),
+      unpack_row_length_(0),
+      unpack_skip_rows_(0),
+      unpack_skip_pixels_(0),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_renderbuffer_(0),
       bound_array_buffer_id_(0),
       bound_element_array_buffer_id_(0),
       client_side_array_id_(0),
       client_side_element_array_id_(0),
       error_bits_(0),
       debug_(false),
@@ skipping 820 matching lines @@
   GPU_CLIENT_LOG("[" << this << "] glPixelStorei("
       << GLES2Util::GetStringPixelStore(pname) << ", "
       << param << ")");
   switch (pname) {
     case GL_PACK_ALIGNMENT:
         pack_alignment_ = param;
         break;
     case GL_UNPACK_ALIGNMENT:
         unpack_alignment_ = param;
         break;
+    case GL_UNPACK_ROW_LENGTH:
+        unpack_row_length_ = param;
+        return;
+    case GL_UNPACK_SKIP_ROWS:
+        unpack_skip_rows_ = param;
+        return;
+    case GL_UNPACK_SKIP_PIXELS:
+        unpack_skip_pixels_ = param;
+        return;
     case GL_UNPACK_FLIP_Y_CHROMIUM:
         unpack_flip_y_ = (param != 0);
         return;
     case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
         pack_reverse_row_order_ =
             IsAnglePackReverseRowOrderAvailable() ? (param != 0) : false;
         break;
     default:
         break;
   }
@@ skipping 252 matching lines @@
   }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexSubImage2DBucket(
       target, level, xoffset, yoffset, width, height, format, kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
-bool GLES2Implementation::CopyRectToBufferFlipped(
+namespace {
+
+void CopyRectToBuffer(
     const void* pixels,
-    GLsizei width,
-    GLsizei height,
-    GLenum format,
-    GLenum type,
-    void* buffer) {
-  if (width == 0 || height == 0) {
-    return true;
+    uint32 height,
+    uint32 unpadded_row_size,
+    uint32 pixels_padded_row_size,
+    bool flip_y,
+    void* buffer,
+    uint32 buffer_padded_row_size) {
+  const int8* source = static_cast<const int8*>(pixels);
+  int8* dest = static_cast<int8*>(buffer);
+  if (flip_y || pixels_padded_row_size != buffer_padded_row_size) {
+    if (flip_y) {
+      dest += buffer_padded_row_size * (height - 1);
+    }
+    // the last row is copied unpadded at the end
+    for (; height > 1; --height) {
+      memcpy(dest, source, buffer_padded_row_size);
+      if (flip_y) {
+        dest -= buffer_padded_row_size;
+      } else {
+        dest += buffer_padded_row_size;
+      }
+      source += pixels_padded_row_size;
+    }
+    memcpy(dest, source, unpadded_row_size);
+  } else {
+    uint32 size = (height - 1) * pixels_padded_row_size + unpadded_row_size;
+    memcpy(dest, source, size);
   }
+}
 
-  uint32 temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 1, format, type, unpack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return false;
-  }
-  GLsizeiptr unpadded_row_size = temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 2, format, type, unpack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return false;
-  }
-  GLsizeiptr padded_row_size = temp_size - unpadded_row_size;
-  if (padded_row_size < 0 || unpadded_row_size < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return false;
-  }
-
-  const int8* source = static_cast<const int8*>(pixels);
-  int8* dest = static_cast<int8*>(buffer) + padded_row_size * (height - 1);
-  for (; height; --height) {
-    memcpy(dest, source, unpadded_row_size);
-    dest -= padded_row_size;
-    source += padded_row_size;
-  }
-  return true;
-}
+}  // anonymous namespace
 
 void GLES2Implementation::TexImage2D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
       << width << ", " << height << ", " << border << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D dimension < 0");
     return;
   }
   uint32 size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &size)) {
+  uint32 unpadded_row_size;
+  uint32 padded_row_size;
+  if (!GLES2Util::ComputeImageDataSizes(
+          width, height, format, type, unpack_alignment_, &size,
+          &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D: image size too large");
     return;
   }
 
   // If there's no data just issue TexImage2D
   if (!pixels) {
     helper_->TexImage2D(
        target, level, internalformat, width, height, border, format, type,
        0, 0);
     return;
   }
 
+  // compute the advance bytes per row for the src pixels
+  uint32 src_padded_row_size;
+  if (unpack_row_length_ > 0) {
+    if (!GLES2Util::ComputeImagePaddedRowSize(
+        unpack_row_length_, format, type, unpack_alignment_,
+        &src_padded_row_size)) {
+      SetGLError(GL_INVALID_VALUE, "glTexImage2D: unpack row length too large");
+      return;
+    }
+  } else {
+    src_padded_row_size = padded_row_size;
+  }
+
+  // advance pixels pointer past the skip rows and skip pixels
+  pixels = reinterpret_cast<const int8*>(pixels) +
+      unpack_skip_rows_ * src_padded_row_size;
+  if (unpack_skip_pixels_) {
+    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8*>(pixels) +
+        unpack_skip_pixels_ * group_size;
+  }
+
   // Check if we can send it all at once.
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   if (!buffer.valid()) {
     return;
   }
 
   if (buffer.size() >= size) {
-    bool copy_success = true;
-    if (unpack_flip_y_) {
-      copy_success = CopyRectToBufferFlipped(
-          pixels, width, height, format, type, buffer.address());
-    } else {
-      memcpy(buffer.address(), pixels, size);
-    }
-
-    if (copy_success) {
-      helper_->TexImage2D(
-          target, level, internalformat, width, height, border, format, type,
-          buffer.shm_id(), buffer.offset());
-    }
+    CopyRectToBuffer(
+        pixels, height, unpadded_row_size, src_padded_row_size, unpack_flip_y_,
+        buffer.address(), padded_row_size);
+    helper_->TexImage2D(
+        target, level, internalformat, width, height, border, format, type,
+        buffer.shm_id(), buffer.offset());
     return;
   }
 
   // No, so send it using TexSubImage2D.
   helper_->TexImage2D(
      target, level, internalformat, width, height, border, format, type,
      0, 0);
   TexSubImage2DImpl(
-      target, level, 0, 0, width, height, format, type, pixels, GL_TRUE,
-      &buffer);
+      target, level, 0, 0, width, height, format, type, unpadded_row_size,
+      pixels, src_padded_row_size, GL_TRUE, &buffer, padded_row_size);
 }
 
 void GLES2Implementation::TexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << this << "] glTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringTextureFormat(format) << ", "
       << GLES2Util::GetStringPixelType(type) << ", "
       << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
 
   uint32 temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &temp_size)) {
+  uint32 unpadded_row_size;
+  uint32 padded_row_size;
+  if (!GLES2Util::ComputeImageDataSizes(
+        width, height, format, type, unpack_alignment_, &temp_size,
+        &unpadded_row_size, &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
 
+  // compute the advance bytes per row for the src pixels
+  uint32 src_padded_row_size;
+  if (unpack_row_length_ > 0) {
+    if (!GLES2Util::ComputeImagePaddedRowSize(
+        unpack_row_length_, format, type, unpack_alignment_,
+        &src_padded_row_size)) {
+      SetGLError(GL_INVALID_VALUE, "glTexImage2D: unpack row length too large");
+      return;
+    }
+  } else {
+    src_padded_row_size = padded_row_size;
+  }
+
+  // advance pixels pointer past the skip rows and skip pixels
+  pixels = reinterpret_cast<const int8*>(pixels) +
+      unpack_skip_rows_ * src_padded_row_size;
+  if (unpack_skip_pixels_) {
+    uint32 group_size = GLES2Util::ComputeImageGroupSize(format, type);
+    pixels = reinterpret_cast<const int8*>(pixels) +
+        unpack_skip_pixels_ * group_size;
+  }
+
   ScopedTransferBufferPtr buffer(temp_size, helper_, transfer_buffer_);
   TexSubImage2DImpl(
-      target, level, xoffset, yoffset, width, height, format, type, pixels,
-      GL_FALSE, &buffer);
+      target, level, xoffset, yoffset, width, height, format, type,
+      unpadded_row_size, pixels, src_padded_row_size, GL_FALSE, &buffer,
+      padded_row_size);
 }
 
 static GLint ComputeNumRowsThatFitInBuffer(
     GLsizeiptr padded_row_size, GLsizeiptr unpadded_row_size,
     unsigned int size) {
   GPU_DCHECK_GE(unpadded_row_size, 0);
   if (padded_row_size == 0) {
     return 1;
   }
   GLint num_rows = size / padded_row_size;
   return num_rows + (size - num_rows * padded_row_size) / unpadded_row_size;
 }
 
 void GLES2Implementation::TexSubImage2DImpl(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-    GLsizei height, GLenum format, GLenum type, const void* pixels,
-    GLboolean internal, ScopedTransferBufferPtr* buffer) {
+    GLsizei height, GLenum format, GLenum type, uint32 unpadded_row_size,
+    const void* pixels, uint32 pixels_padded_row_size, GLboolean internal,
+    ScopedTransferBufferPtr* buffer, uint32 buffer_padded_row_size) {
   GPU_DCHECK(buffer);
   GPU_DCHECK_GE(level, 0);
   GPU_DCHECK_GT(height, 0);
   GPU_DCHECK_GT(width, 0);
 
-  const int8* source = static_cast<const int8*>(pixels);
-  uint32 temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 1, format, type, unpack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return;
-  }
-  GLsizeiptr unpadded_row_size = temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 2, format, type, unpack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return;
-  }
-  GLsizeiptr padded_row_size = temp_size - unpadded_row_size;
-  if (padded_row_size < 0 || unpadded_row_size < 0) {
-    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
-    return;
-  }
-
+  const int8* source = reinterpret_cast<const int8*>(pixels);
   GLint original_yoffset = yoffset;
   // Transfer by rows.
   while (height) {
     unsigned int desired_size =
-        padded_row_size * (height - 1) + unpadded_row_size;
+        buffer_padded_row_size * (height - 1) + unpadded_row_size;
     if (!buffer->valid() || buffer->size() == 0) {
       buffer->Reset(desired_size);
       if (!buffer->valid()) {
         return;
       }
     }
 
     GLint num_rows = ComputeNumRowsThatFitInBuffer(
-        padded_row_size, unpadded_row_size, buffer->size());
+        buffer_padded_row_size, unpadded_row_size, buffer->size());
     num_rows = std::min(num_rows, height);
-    GLint y;
-    if (unpack_flip_y_) {
-      CopyRectToBufferFlipped(
-          source, width, num_rows, format, type, buffer->address());
-      y = original_yoffset + height - num_rows;
-    } else {
-      temp_size = padded_row_size * (num_rows - 1) + unpadded_row_size;
-      memcpy(buffer->address(), source, temp_size);
-      y = yoffset;
-    }
+    CopyRectToBuffer(
+        source, num_rows, unpadded_row_size, pixels_padded_row_size,
+        unpack_flip_y_, buffer->address(), buffer_padded_row_size);
+    GLint y = unpack_flip_y_ ? original_yoffset + height - num_rows : yoffset;
     helper_->TexSubImage2D(
         target, level, xoffset, y, width, num_rows, format, type,
         buffer->shm_id(), buffer->offset(), internal);
     buffer->Release();
     yoffset += num_rows;
-    source += num_rows * padded_row_size;
+    source += num_rows * pixels_padded_row_size;
     height -= num_rows;
   }
 }
 
 bool GLES2Implementation::GetActiveAttribHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef gles2::GetActiveAttrib::Result Result;
@@ skipping 206 matching lines @@
   // Clears the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // Adds extensions implemented on client side only.
     switch (name) {
       case GL_EXTENSIONS:
         str += std::string(str.empty() ? "" : " ") +
             "GL_CHROMIUM_map_sub "
-            "GL_CHROMIUM_flipy";
+            "GL_CHROMIUM_flipy "
+            "GL_EXT_unpack_subimage";
         break;
       default:
         break;
     }
 
     // Because of WebGL the extensions can change. We have to cache each unique
     // result since we don't know when the client will stop referring to a
     // previous one it queries.
     GLStringMap::iterator it = gl_strings_.find(name);
     if (it == gl_strings_.end()) {
@@ skipping 96 matching lines @@
   // 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 gles2::ReadPixels::Result Result;
 
   int8* dest = reinterpret_cast<int8*>(pixels);
   uint32 temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 1, format, type, pack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
-    return;
-  }
-  GLsizeiptr unpadded_row_size = temp_size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, 2, format, type, pack_alignment_, &temp_size)) {
-    SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
-    return;
-  }
-  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: size too large.");
     return;
   }
   // 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;
@@ skipping 487 matching lines @@
     SetGLError(GL_INVALID_ENUM, "MapTexSubImage2DCHROMIUM: bad access mode");
     return NULL;
   }
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "MapTexSubImage2DCHROMIUM: bad dimensions");
     return NULL;
   }
   uint32 size;
-  if (!GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_, &size)) {
+  if (!GLES2Util::ComputeImageDataSizes(
+      width, height, format, type, unpack_alignment_, &size, NULL, NULL)) {
     SetGLError(
         GL_INVALID_VALUE, "MapTexSubImage2DCHROMIUM: image size too large");
     return NULL;
   }
   int32 shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
     SetGLError(GL_OUT_OF_MEMORY, "MapTexSubImage2DCHROMIUM: out of memory");
     return NULL;
@@ skipping 514 matching lines @@
     helper_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   }
 #else
   helper_->DrawElementsInstancedANGLE(
       mode, count, type, ToGLuint(indices), primcount);
 #endif
 }
 
 }  // namespace gles2
 }  // namespace gpu