Add support for GL_CHROMIUM_pixel_transfer_buffer_object.

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 <algorithm>
 #include <map>
 #include <queue>
 #include <set>
 #include <limits>
 #include <stdio.h>
 #include <string.h>
 #include <GLES2/gl2ext.h>
+#include "../client/buffer_tracker.h"
 #include "../client/mapped_memory.h"
 #include "../client/program_info_manager.h"
 #include "../client/query_tracker.h"
 #include "../client/transfer_buffer.h"
 #include "../common/gles2_cmd_utils.h"
 #include "../common/trace_event.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
@@ skipping 405 matching lines @@
       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),
+      bound_pixel_unpack_transfer_buffer_id_(0),
       client_side_array_id_(0),
       client_side_element_array_id_(0),
       bound_vertex_array_id_(0),
       error_bits_(0),
       debug_(false),
       use_count_(0),
       current_query_(NULL),
       error_message_callback_(NULL) {
   GPU_DCHECK(helper);
   GPU_DCHECK(transfer_buffer);
@@ skipping 56 matching lines @@
 
   util_.set_num_compressed_texture_formats(
       gl_state_.int_state.num_compressed_texture_formats);
   util_.set_num_shader_binary_formats(
       gl_state_.int_state.num_shader_binary_formats);
 
   texture_units_.reset(
       new TextureUnit[gl_state_.int_state.max_combined_texture_image_units]);
 
   query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
+  buffer_tracker_.reset(new BufferTracker(mapped_memory_.get()));
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   GetIdHandler(id_namespaces::kBuffers)->MakeIds(
       this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
 
   client_side_buffer_helper_.reset(new ClientSideBufferHelper(
       gl_state_.int_state.max_vertex_attribs,
       reserved_ids_[0],
       reserved_ids_[1]));
 #endif
 
   return true;
 }
 
 GLES2Implementation::~GLES2Implementation() {
   // Make sure the queries are finished otherwise we'll delete the
   // shared memory (mapped_memory_) which will free the memory used
   // by the queries. The GPU process when validating that memory is still
   // shared will fail and abort (ie, it will stop running).
   Finish();
   query_tracker_.reset();
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   DeleteBuffers(arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
+  buffer_tracker_.reset();
+
   // The share group needs to be able to use a command buffer to talk
   // to service if it's destroyed so set one for it then release the reference.
   // If it's destroyed it will use this GLES2Implemenation.
   share_group_->SetGLES2ImplementationForDestruction(this);
   share_group_ = NULL;
   // Make sure the commands make it the service.
   Finish();
 }
 
 GLES2CmdHelper* GLES2Implementation::helper() const {
@@ skipping 400 matching lines @@
         *params = bound_array_buffer_id_;
         return true;
       }
       return false;
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
       if (share_group_->bind_generates_resource()) {
         *params = bound_element_array_buffer_id_;
         return true;
       }
       return false;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_BINDING_CHROMIUM:
+      if (share_group_->bind_generates_resource()) {
+        *params = bound_pixel_unpack_transfer_buffer_id_;
+        return true;
+      }
+      return false;
     case GL_ACTIVE_TEXTURE:
       *params = active_texture_unit_ + GL_TEXTURE0;
       return true;
     case GL_TEXTURE_BINDING_2D:
       if (share_group_->bind_generates_resource()) {
         *params = texture_units_[active_texture_unit_].bound_texture_2d;
         return true;
       }
       return false;
     case GL_TEXTURE_BINDING_CUBE_MAP:
@@ skipping 285 matching lines @@
 void GLES2Implementation::BindAttribLocation(
   GLuint program, GLuint index, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindAttribLocation("
       << program << ", " << index << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindAttribLocationBucket(program, index, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
+void GLES2Implementation::BindBuffer(GLenum target, GLuint buffer) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << this << "] glBindBuffer(" <<
+      GLES2Util::GetStringBufferTarget(target) << ", " << buffer << ")");
+  if (IsBufferReservedId(buffer)) {
+    SetGLError(GL_INVALID_OPERATION, "BindBuffer", "buffer reserved id");
+    return;
+  }
+  BindBufferHelper(target, buffer);
+  if (target != GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM)
+    helper_->BindBuffer(target, buffer);
+}
+
 void GLES2Implementation::BindUniformLocationCHROMIUM(
   GLuint program, GLint location, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindUniformLocationCHROMIUM("
       << program << ", " << location << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindUniformLocationCHROMIUMBucket(
       program, location, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
@@ skipping 327 matching lines @@
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   if (size == 0) {
     return;
   }
 
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
 
+  if (target == GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM) {
+    GLuint buffer_id = bound_pixel_unpack_transfer_buffer_id_;
+    if (!buffer_id) {
+      SetGLError(GL_INVALID_VALUE, "glBufferData", "unknown buffer");
+      return;
+    }
+
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
+    if (buffer) {
+      // Free buffer memory, pending the passage of a token.
+      buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken());
+
+      // Remove old buffer.
+      buffer_tracker_->RemoveBuffer(buffer_id);
+    }
+
+    // Create new buffer.
+    buffer = buffer_tracker_->CreateBuffer(buffer_id, size);
+    GPU_DCHECK(buffer);
+    if (data)
+      memcpy(buffer->address(), data, size);
+    return;
+  }
+
   // If there is no data just send BufferData
   if (!data) {
     helper_->BufferData(target, size, 0, 0, usage);
     return;
   }
 
   // See if we can send all at once.
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   if (!buffer.valid()) {
     return;
@@ skipping 86 matching lines @@
       << width << ", " << height << ", " << border << ", "
       << image_size << ", "
       << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
+  // If there's a pixel unpack buffer bound use it when issuing
+  // CompressedTexImage2D.
+  if (bound_pixel_unpack_transfer_buffer_id_) {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "invalid buffer");
+      return;
+    }
+    GLuint offset = ToGLuint(data);
+    if ((buffer->size() - offset) < static_cast<GLuint>(image_size)) {
+      SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D",
+          "unpack size to large");
+      return;
+    }
+    helper_->CompressedTexImage2D(
+        target, level, internalformat, width, height, border, image_size,
+        buffer->shm_id(), buffer->shm_offset() + offset);
+    return;
+  }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexImage2DBucket(
       target, level, internalformat, width, height, border, 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);
 }
 
 void GLES2Implementation::CompressedTexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCompressedTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
       << GLES2Util::GetStringCompressedTextureFormat(format) << ", "
       << image_size << ", "
       << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "dimension < 0");
     return;
   }
+  // If there's a pixel unpack buffer bound use it when issuing
+  // CompressedTexSubImage2D.
+  if (bound_pixel_unpack_transfer_buffer_id_) {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
+          "invalid buffer");
+      return;
+    }
+    GLuint offset = ToGLuint(data);
+    if ((buffer->size() - offset) < static_cast<GLuint>(image_size)) {
+      SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
+          "unpack size to large");
+      return;
+    }
+    helper_->CompressedTexSubImage2D(
+        target, level, xoffset, yoffset, width, height, format, image_size,
+        buffer->shm_id(), buffer->shm_offset() + offset);
+    return;
+  }
   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);
 }
 
 namespace {
@@ skipping 51 matching lines @@
   uint32 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 a pixel unpack buffer bound use it when issuing TexImage2D.
+  if (bound_pixel_unpack_transfer_buffer_id_) {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "glTexImage2D", "invalid buffer");
+      return;
+    }
+    GLuint offset = ToGLuint(pixels);
+    if ((buffer->size() - offset) < size) {
+      SetGLError(GL_INVALID_VALUE, "glTexImage2D", "unpack size to large");
+      return;
+    }
+    helper_->TexImage2D(
+        target, level, internalformat, width, height, border, format, type,
+        buffer->shm_id(), buffer->shm_offset() + offset);
+    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;
@@ skipping 67 matching lines @@
   uint32 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;
   }
 
+  // If there's a pixel unpack buffer bound use it when issuing TexSubImage2D.
+  if (bound_pixel_unpack_transfer_buffer_id_) {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "invalid buffer");
+      return;
+    }
+    GLuint offset = ToGLuint(pixels);
+    if ((buffer->size() - offset) < temp_size) {
+      SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "unpack size to large");
+      return;
+    }
+    helper_->TexSubImage2D(
+        target, level, xoffset, yoffset, width, height, format, type,
+        buffer->shm_id(), buffer->shm_offset() + offset, false);
+    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;
     }
@@ skipping 496 matching lines @@
 void GLES2Implementation::BindBufferHelper(
     GLenum target, GLuint buffer) {
   // TODO(gman): See note #1 above.
   switch (target) {
     case GL_ARRAY_BUFFER:
       bound_array_buffer_id_ = buffer;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       bound_element_array_buffer_id_ = buffer;
       break;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
+      bound_pixel_unpack_transfer_buffer_id_ = buffer;
+      break;
     default:
       break;
   }
   // TODO(gman): There's a bug here. If the target is invalid the ID will not be
   // used even though it's marked it as used here.
   GetIdHandler(id_namespaces::kBuffers)->MarkAsUsedForBind(buffer);
 }
 
 void GLES2Implementation::BindFramebufferHelper(
     GLenum target, GLuint framebuffer) {
@@ skipping 74 matching lines @@
         "glDeleteBuffers", "id not created by this context.");
     return;
   }
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (buffers[ii] == bound_array_buffer_id_) {
       bound_array_buffer_id_ = 0;
     }
     if (buffers[ii] == bound_element_array_buffer_id_) {
       bound_element_array_buffer_id_ = 0;
     }
+    if (buffers[ii] == bound_pixel_unpack_transfer_buffer_id_) {
+      bound_pixel_unpack_transfer_buffer_id_ = 0;
+    }
+
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffers[ii]);
+    if (buffer) {
+      // Free buffer memory, pending the passage of a token.
+      buffer_tracker_->FreePendingToken(buffer, helper_->InsertToken());
+      // Remove buffer.
+      buffer_tracker_->RemoveBuffer(buffers[ii]);
+    }
   }
 }
 
 void GLES2Implementation::DeleteBuffersStub(
     GLsizei n, const GLuint* buffers) {
   helper_->DeleteBuffersImmediate(n, buffers);
 }
 
 
 void GLES2Implementation::DeleteFramebuffersHelper(
@@ skipping 939 matching lines @@
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2Implementation::PopGroupMarkerEXT() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPopGroupMarkerEXT()");
   helper_->PopGroupMarkerEXT();
   debug_marker_manager_.PopGroup();
 }
 
+void* GLES2Implementation::MapBufferCHROMIUM(GLuint target, GLenum access) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferCHROMIUM("
+      << target << ", " << GLES2Util::GetStringEnum(access) << ")");
+  if (target != GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM) {
+    SetGLError(
+        GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target");
+    return NULL;
+  }
+  if (access != GL_WRITE_ONLY) {
+    SetGLError(
+        GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
+    return NULL;
+  }
+  BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+  if (!buffer) {
+    SetGLError(
+        GL_INVALID_VALUE, "glMapBufferCHROMIUM", "invalid buffer");
+    return NULL;
+  }
+
+  GPU_DCHECK(buffer->address());
+  GPU_CLIENT_LOG("  returned " << buffer->address());
+  return buffer->address();
+}
+
+GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG(
+      "[" << GetLogPrefix() << "] glUnmapBufferCHROMIUM(" << target << ")");
+  if (target != GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM) {
+    SetGLError(
+        GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target");
+    return false;
+  }
+  BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+      bound_pixel_unpack_transfer_buffer_id_);
+  if (!buffer) {
+    SetGLError(
+        GL_INVALID_VALUE, "glMapBufferCHROMIUM", "invalid buffer");
+    return false;
+  }
+
+  return true;
+}
+
 // 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 "../client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu