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 406 matching lines @@
       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),
       current_program_(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 57 matching lines @@
   util_.set_num_compressed_texture_formats(
       static_state_.int_state.num_compressed_texture_formats);
   util_.set_num_shader_binary_formats(
       static_state_.int_state.num_shader_binary_formats);
 
   texture_units_.reset(
       new TextureUnit[
           static_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(
       static_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 341 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:
+      *params = bound_pixel_unpack_transfer_buffer_id_;
+      return true;
     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 644 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 30 matching lines @@
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   if (size == 0) {
     return;
   }
 
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData", "size < 0");
     return;
   }
 
+  if (target == GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM) {
+    BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+        bound_pixel_unpack_transfer_buffer_id_);
+    if (!buffer) {
+      SetGLError(GL_INVALID_VALUE, "glBufferSubData", "unknown buffer");
+      return;
+    }
+
+    int32 end = 0;
+    int32 buffer_size = buffer->size();
+    if (!SafeAddInt32(offset, size, &end) || end > buffer_size) {

[greggman, 2012/11/20 18:57:42]

technically you don't need safeadd on the renderer side. If the renderer, which
is untrusted code, does something bad it crashes. For example 
glBufferSubData(target, offset, 1, NULL) will crash

no need to change it per-se I just thought I'd point it out.

[reveman, 2012/11/20 23:24:30]

Ok, makes sense.

+      SetGLError(GL_INVALID_VALUE, "glBufferSubData", "out of range");
+      return;
+    }
+
+    if (data)
+      memcpy(static_cast<uint8_t*>(buffer->address()) + offset, data, size);
+    return;
+  }
+
   ScopedTransferBufferPtr buffer(size, helper_, transfer_buffer_);
   BufferSubDataHelperImpl(target, offset, size, data, &buffer);
 }
 
 void GLES2Implementation::BufferSubDataHelperImpl(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data,
     ScopedTransferBufferPtr* buffer) {
   GPU_DCHECK(buffer);
   GPU_DCHECK_GT(size, 0);
 
@@ skipping 18 matching lines @@
 void GLES2Implementation::BufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
 }
 
+BufferTracker::Buffer*
+GLES2Implementation::GetBoundPixelUnpackTransferBufferIfValid(
+    const char* function_name, GLuint offset, GLsizei size)
+{
+  BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(
+      bound_pixel_unpack_transfer_buffer_id_);
+  if (!buffer) {
+    SetGLError(GL_INVALID_VALUE, function_name, "invalid buffer");

[greggman, 2012/11/20 18:57:42]

INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return NULL;
+  }
+  if (buffer->mapped()) {
+    SetGLError(GL_INVALID_VALUE, function_name, "buffer mapped");

[greggman, 2012/11/20 18:57:42]

GL_INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return NULL;
+  }
+  if ((buffer->size() - offset) < static_cast<GLuint>(size)) {
+    SetGLError(GL_INVALID_VALUE, function_name, "unpack size to large");
+    return NULL;
+  }
+  return buffer;
+}
+
 void GLES2Implementation::CompressedTexImage2D(
     GLenum target, GLint level, GLenum internalformat, GLsizei width,
     GLsizei height, GLint border, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCompressedTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << GLES2Util::GetStringCompressedTextureFormat(internalformat) << ", "
       << 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_) {
+    GLuint offset = ToGLuint(data);
+    BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+        "glCompressedTexImage2D", offset, image_size);
+    if (buffer)
+      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_) {
+    GLuint offset = ToGLuint(data);
+    BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+        "glCompressedTexSubImage2D", offset, image_size);
+    if (buffer)
+      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_) {
+    GLuint offset = ToGLuint(pixels);
+    BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+        "glTexImage2D", offset, size);
+    if (buffer)
+      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_) {
+    GLuint offset = ToGLuint(pixels);
+    BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+        "glTexSubImage2D", offset, temp_size);
+    if (buffer)
+      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 503 matching lines @@
         bound_array_buffer_id_ = buffer;
         changed = true;
       }
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       if (bound_element_array_buffer_id_ != buffer) {
         bound_element_array_buffer_id_ = buffer;
         changed = true;
       }
       break;
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
+      bound_pixel_unpack_transfer_buffer_id_ = buffer;
+      break;
     default:
       changed = true;
       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);
   return changed;
 }
 
@@ skipping 101 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 949 matching lines @@
 void GLES2Implementation::TraceBeginCHROMIUM(const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTraceBeginCHROMIUM("
                  << name << ")");
 
   SetBucketAsCString(kResultBucketId, name);
   helper_->TraceBeginCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
+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");

[greggman, 2012/11/20 18:57:42]

GL_INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return NULL;
+  }
+  if (buffer->mapped()) {
+    SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "already mapped");

[greggman, 2012/11/20 18:57:42]

GL_INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return NULL;
+  }
+  buffer->set_mapped(true);
+
+  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");

[greggman, 2012/11/20 18:57:42]

GL_INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return false;
+  }
+  if (!buffer->mapped()) {
+    SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "not mapped");

[greggman, 2012/11/20 18:57:42]

GL_INVALID_OPERATION

[reveman, 2012/11/20 23:24:30]

Done.

+    return false;
+  }
+  buffer->set_mapped(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