Add GL_ANGLE_pack_reverse_row_order to command buffer

gpu/command_buffer/client/gles2_implementation.cc

 // Copyright (c) 2011 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 <set>
 #include <queue>
@@ skipping 522 matching lines @@
       int32 transfer_buffer_id,
       bool share_resources,
       bool bind_generates_resource)
     : helper_(helper),
       transfer_buffer_(
           kStartingOffset,
           transfer_buffer_size - kStartingOffset,
           helper,
           static_cast<char*>(transfer_buffer) + kStartingOffset),
       transfer_buffer_id_(transfer_buffer_id),
+      angle_pack_reverse_row_order_status(kUnknownExtensionStatus),
       pack_alignment_(4),
       unpack_alignment_(4),
       unpack_flip_y_(false),
+      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),
       sharing_resources_(share_resources),
@@ skipping 85 matching lines @@
 
 void GLES2Implementation::FreeUnusedSharedMemory() {
   mapped_memory_->FreeUnused();
 }
 
 void GLES2Implementation::WaitForCmd() {
   TRACE_EVENT0("gpu", "GLES2::WaitForCmd");
   helper_->CommandBufferHelper::Finish();
 }
 
+namespace {
+bool IsExtensionAvailable(GLES2Implementation* gles2, const char ext[]) {
+  const char* extensions = reinterpret_cast<const char*>(
+      gles2->GetString(GL_EXTENSIONS));
+  int length = strlen(ext);
+  while (true) {
+    int n = strcspn(extensions, " ");
+    if (n == length && 0 == strncmp(ext, extensions, length)) {
+      return true;
+    }
+    if ('\0' == extensions[n]) {
+      return false;
+    }
+    extensions += n+1;
+  }
+}
+}
+
+bool GLES2Implementation::IsAnglePackReverseRowOrderAvailable() {
+  switch (angle_pack_reverse_row_order_status) {
+    case kAvailableExtensionStatus:
+      return true;
+    case kUnavailableExtensionStatus:
+      return false;
+    default:
+      if (IsExtensionAvailable(this, "GL_ANGLE_pack_reverse_row_order")) {
+          angle_pack_reverse_row_order_status = kAvailableExtensionStatus;
+          return true;
+      } else {
+          angle_pack_reverse_row_order_status = kUnavailableExtensionStatus;
+          return false;
+      }
+  }
+}
+
 GLenum GLES2Implementation::GetError() {
   GPU_CLIENT_LOG("[" << this << "] glGetError()");
   GLenum err = GetGLError();
   GPU_CLIENT_LOG("returned " << GLES2Util::GetStringError(err));
   return err;
 }
 
 GLenum GLES2Implementation::GetGLError() {
   TRACE_EVENT0("gpu", "GLES2::GetGLError");
   // Check the GL error first, then our wrapped error.
@@ skipping 553 matching lines @@
   switch (pname) {
     case GL_PACK_ALIGNMENT:
         pack_alignment_ = param;
         break;
     case GL_UNPACK_ALIGNMENT:
         unpack_alignment_ = param;
         break;
     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;
   }
   helper_->PixelStorei(pname, param);
 }
 
 
 void GLES2Implementation::VertexAttribPointer(
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
     const void* ptr) {
@@ skipping 734 matching lines @@
       GLsizeiptr part_size =
           unpadded_row_size + padded_row_size * (num_rows - 1);
       void* buffer = transfer_buffer_.Alloc(part_size);
       *result = 0;  // mark as failed.
       helper_->ReadPixels(
           xoffset, yoffset, width, num_rows, format, type,
           transfer_buffer_id_, transfer_buffer_.GetOffset(buffer),
           result_shm_id(), result_shm_offset());
       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;
+        } 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);
         for (GLint yy = 0; yy < num_rows; ++yy) {
-          memcpy(dest, src, unpadded_row_size);
-          dest += padded_row_size;
+          memcpy(rows_dst, src, unpadded_row_size);
+          rows_dst += padded_row_size;
           src += padded_row_size;
         }
+        if (!pack_reverse_row_order_) {
+          dest = rows_dst;
+        }
       }
       transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
       // If it was not marked as successful exit.
       if (*result == 0) {
         return;
       }
       yoffset += num_rows;
       height -= num_rows;
     }
   } else {
     // Transfer by sub rows. Because GL has no maximum texture dimensions.
     GLES2Util::ComputeImageDataSize(
        1, 1, format, type, pack_alignment_, &temp_size);
     GLsizeiptr element_size = temp_size;
     max_size -= max_size % element_size;
     GLint max_sub_row_pixels = max_size / element_size;
+    if (pack_reverse_row_order_) {
+      // start at the last row when flipping y.
+      dest = dest + (height - 1) * padded_row_size;
+    }
     for (; height; --height) {
       GLint temp_width = width;
       GLint temp_xoffset = xoffset;
       int8* row_dest = dest;
       while (temp_width) {
         GLint num_pixels = std::min(width, max_sub_row_pixels);
         GLsizeiptr part_size = num_pixels * element_size;
         void* buffer = transfer_buffer_.Alloc(part_size);
         *result = 0;  // mark as failed.
         helper_->ReadPixels(
             temp_xoffset, yoffset, temp_width, 1, format, type,
             transfer_buffer_id_, transfer_buffer_.GetOffset(buffer),
             result_shm_id(), result_shm_offset());
         WaitForCmd();
         if (*result != 0) {
           memcpy(row_dest, buffer, part_size);
         }
         transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
         // If it was not marked as successful exit.
         if (*result == 0) {
           return;
         }
         row_dest += part_size;
         temp_xoffset += num_pixels;
         temp_width -= num_pixels;
       }
       ++yoffset;
-      dest += padded_row_size;
+      dest += pack_reverse_row_order_ ? -padded_row_size : padded_row_size;
     }
   }
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_LOG("[" << this << "] glActiveTexture("
       << GLES2Util::GetStringEnum(texture) << ")");
   GLuint texture_index = texture - GL_TEXTURE0;
   if (texture_index >=
       static_cast<GLuint>(gl_state_.max_combined_texture_image_units)) {
@@ skipping 474 matching lines @@
   GPU_CLIENT_LOG("  returned " << result);
   return reinterpret_cast<const GLchar*>(result);
 }
 
 void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
   GPU_CLIENT_LOG("[" << this << "] glRequestExtensionCHROMIUM("
                  << extension << ")");
   SetBucketAsCString(kResultBucketId, extension);
   helper_->RequestExtensionCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
+  if (kUnavailableExtensionStatus == angle_pack_reverse_row_order_status &&
+      !strcmp(extension, "GL_ANGLE_pack_reverse_row_order")) {
+    angle_pack_reverse_row_order_status = kUnknownExtensionStatus;

[bsalomon, 2011/11/28 14:00:40]

I wasn't too sure about this.

+  }
 }
 
 void GLES2Implementation::RateLimitOffscreenContextCHROMIUM() {
   GPU_CLIENT_LOG("[" << this << "] glRateLimitOffscreenCHROMIUM()");
   // Wait if this would add too many rate limit tokens.
   if (rate_limit_tokens_.size() == kMaxSwapBuffers) {
     helper_->WaitForToken(rate_limit_tokens_.front());
     rate_limit_tokens_.pop();
   }
   rate_limit_tokens_.push(helper_->InsertToken());
@@ skipping 127 matching lines @@
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu