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 <map>
 #include <set>
@@ skipping 380 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_pack_transfer_buffer_id_(0),
+      bound_pixel_unpack_transfer_buffer_id_(0),
       client_side_array_id_(0),
       client_side_element_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);
   GPU_CLIENT_LOG_CODE_BLOCK({
@@ skipping 50 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();
+  buffer_tracker_.reset();
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   DeleteBuffers(arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
   // 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.
@@ skipping 376 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_PACK_TRANSFER_BUFFER_BINDING_CHROMIUM:
+      if (share_group_->bind_generates_resource()) {
+        *params = bound_pixel_pack_transfer_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 586 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;
   }
 
+  switch (target) {
+  case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:

[greggman, 2012/05/24 20:56:00]

style: case is indented from switch

+  case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: {
+    GLuint buffer_id = target != GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM ?
+        bound_pixel_unpack_transfer_buffer_id_ :
+        bound_pixel_pack_transfer_buffer_id_;
+    if (!buffer_id) {
+      SetGLError(GL_INVALID_VALUE, "glBufferData: unknown buffer");
+      return;
+    }
+    // Remove old buffer.
+    buffer_tracker_->RemoveBuffer(buffer_id);

[greggman, 2012/05/24 20:56:00]

Should this happen inside buffer_tracker as in something like
buffer_tracker_->ResizeBuffer or AllocateBuffer ?  It seems like it would be
nice to avoid reallocation if the buffer is the same size. 

[reveman, 2012/05/25 15:45:10]

I agree. will fix this.

+
+    // Creat new buffer.
+    BufferTracker::Buffer* buffer = buffer_tracker_->CreateBuffer(
+        buffer_id, size);
+    GPU_DCHECK(buffer);
+    if (data)
+      memcpy(buffer->address(), data, size);
+    helper_->BufferData(
+        target, size, buffer->shm_id(), buffer->shm_offset(), usage);
+    return;
+  } break;
+  }
+
   // 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 258 matching lines @@
       << 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;
   }
 
+  if (bound_pixel_unpack_transfer_buffer_id_) {
+    helper_->TexSubImage2D(
+        target, level, xoffset, yoffset, width, height, format, type,
+        0, ToGLuint(pixels), false);
+    return;
+  }
+
   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;
   }
 
@@ skipping 503 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_PACK_TRANSFER_BUFFER_CHROMIUM:
+      bound_pixel_pack_transfer_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 331 matching lines @@
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (access != GL_WRITE_ONLY) {
     SetGLError(GL_INVALID_ENUM, "MapBufferSubDataCHROMIUM: bad access mode");
     return NULL;
   }
   if (offset < 0 || size < 0) {
     SetGLError(GL_INVALID_VALUE, "MapBufferSubDataCHROMIUM: bad range");
     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, "MapBufferSubDataCHROMIUM: out of memory");
-    return NULL;
+  int32 shm_id = 0;
+  unsigned int shm_offset = 0;
+  void* mem = 0;
+  switch (target) {
+  case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:

[greggman, 2012/05/24 20:56:00]

style: indent

+  case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        target == GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM ?
+        bound_pixel_pack_transfer_buffer_id_ :
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "MapBufferSubDataCHROMIUM: invalid buffer");
+      return NULL;
+    }
+    mem = static_cast<uint8*>(buffer->address()) + offset;
+  } break;

[greggman, 2012/05/24 20:56:00]

style: breaks go inside case blocks

[greggman, 2012/05/24 20:56:00]

style: break goes inside case block

+  default:
+    mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
+    if (!mem) {
+      SetGLError(GL_OUT_OF_MEMORY, "MapBufferSubDataCHROMIUM: out of memory");
+      return NULL;
+    }
+    break;
   }
 
   std::pair<MappedBufferMap::iterator, bool> result =
      mapped_buffers_.insert(std::make_pair(
          mem,
          MappedBuffer(
              access, shm_id, mem, shm_offset, target, offset, size)));
   GPU_DCHECK(result.second);
   GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << this << "] glUnmapBufferSubDataCHROMIUM(" << mem << ")");
   MappedBufferMap::iterator it = mapped_buffers_.find(mem);
   if (it == mapped_buffers_.end()) {
     SetGLError(
         GL_INVALID_VALUE, "UnmapBufferSubDataCHROMIUM: buffer not mapped");
     return;
   }
   const MappedBuffer& mb = it->second;
-  helper_->BufferSubData(
-      mb.target, mb.offset, mb.size, mb.shm_id, mb.shm_offset);
-  mapped_memory_->FreePendingToken(mb.shm_memory, helper_->InsertToken());
-  // Flushing after unmap lets the service side start processing commands
-  // sooner. However, on lowend devices, the thread thrashing causes is
-  // worse than the latency hit.
+  switch (mb.target) {
+  case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:

[greggman, 2012/05/24 20:56:00]

indent

+  case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
+    break;
+  default:
+    helper_->BufferSubData(
+        mb.target, mb.offset, mb.size, mb.shm_id, mb.shm_offset);
+    mapped_memory_->FreePendingToken(mb.shm_memory, helper_->InsertToken());
+    // Flushing after unmap lets the service side start processing commands
+    // sooner. However, on lowend devices, the thread thrashing causes is
+    // worse than the latency hit.
 #if !defined(OS_ANDROID) && !defined(OS_CHROMEOS)
-  helper_->CommandBufferHelper::Flush();
+    helper_->CommandBufferHelper::Flush();
 #endif
+    break;
+  }
   mapped_buffers_.erase(it);

[greggman, 2012/05/24 20:56:00]

I'm not sure why you'd erase the buffer here but then I guess like you said
you're going to add new entry points instead of using MapSubBuffer and
UnmapSubBuffer

 }
 
 void* GLES2Implementation::MapTexSubImage2DCHROMIUM(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLsizei width,
      GLsizei height,
      GLenum format,
@@ skipping 562 matching lines @@
   helper_->GenMailboxCHROMIUM(kResultBucketId);
 
   std::vector<GLbyte> result;
   GetBucketContents(kResultBucketId, &result);
 
   std::copy(result.begin(), result.end(), mailbox);
 }
 
 }  // namespace gles2
 }  // namespace gpu