GPU client side changes for GpuMemoryBuffers

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 <GLES2/gl2extchromium.h>
 #include "../client/buffer_tracker.h"
+#include "../client/gpu_memory_buffer.h"
+#include "../client/gpu_memory_buffer_factory.h"
+#include "../client/gpu_memory_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 "../client/vertex_array_object_manager.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
@@ skipping 62 matching lines @@
       unpack_skip_pixels_(0),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_read_framebuffer_(0),
       bound_renderbuffer_(0),
       current_program_(0),
       bound_array_buffer_id_(0),
       bound_pixel_pack_transfer_buffer_id_(0),
       bound_pixel_unpack_transfer_buffer_id_(0),
+      bound_gpu_memory_buffer_id_(0),
       error_bits_(0),
       debug_(false),
       use_count_(0),
       current_query_(NULL),
-      error_message_callback_(NULL) {
+      error_message_callback_(NULL),
+      gpu_memory_buffer_factory_(NULL) {

[greggman, 2013/05/03 23:48:01]

as this is a scoped_ptr initialization to null is not needed

[kaanb, 2013/05/06 18:20:53]

Done.

   GPU_DCHECK(helper);
   GPU_DCHECK(transfer_buffer);
 
   char temp[128];
   sprintf(temp, "%p", static_cast<void*>(this));
   this_in_hex_ = std::string(temp);
 
   GPU_CLIENT_LOG_CODE_BLOCK({
     debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUClientLogging);
@@ skipping 50 matching lines @@
       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()));
+  gpu_memory_buffer_tracker_.reset(new GpuMemoryBufferTracker(
+      gpu_memory_buffer_factory_.get()));
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   GetIdHandler(id_namespaces::kBuffers)->MakeIds(
       this, kClientSideArrayId, arraysize(reserved_ids_), &reserved_ids_[0]);
 #endif
 
   vertex_array_object_manager_.reset(new VertexArrayObjectManager(
       static_state_.int_state.max_vertex_attribs,
       reserved_ids_[0],
       reserved_ids_[1]));
@@ skipping 437 matching lines @@
         *params = bound_read_framebuffer_;
         return true;
       }
       return false;
     case GL_RENDERBUFFER_BINDING:
       if (share_group_->bind_generates_resource()) {
         *params = bound_renderbuffer_;
         return true;
       }
       return false;
+    case GL_IMAGE_BUFFER_BINDING_CHROMIUM:
+      *params = bound_gpu_memory_buffer_id_;

[greggman, 2013/05/03 23:48:01]

can you gate this on if there is a factory? If no factor return don't set *param
and return false

[kaanb, 2013/05/06 18:20:53]

Done.

+      return true;
     default:
       return false;
   }
 }
 
 bool GLES2Implementation::GetBooleanvHelper(GLenum pname, GLboolean* params) {
   // TODO(gman): Make this handle pnames that return more than 1 value.
   GLint value;
   if (!GetHelper(pname, &value)) {
     return false;
@@ skipping 595 matching lines @@
     }
   }
 
   GPU_DCHECK_EQ(total_size, offset);
 
   helper_->ShaderSourceBucket(shader, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
+void GLES2Implementation::GetBoundGpuMemoryBuffer(
+    const char* function_name, GLuint* buffer_id) {
+  *buffer_id = bound_gpu_memory_buffer_id_;
+
+  if (*buffer_id == 0) {
+    SetGLError(GL_INVALID_OPERATION, function_name, "no buffer bound");
+  }
+
+  return;

[greggman, 2013/05/03 23:48:01]

no need for return in void function?

[kaanb, 2013/05/06 18:20:53]

Done.

+}
+
 void GLES2Implementation::BufferDataHelper(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferData", "size < 0");
     return;
   }
 
   GLuint buffer_id;
   if (GetBoundPixelTransferBuffer(target, "glBufferData", &buffer_id)) {
     if (!buffer_id) {
@@ skipping 764 matching lines @@
   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_flipy "
             "GL_CHROMIUM_map_sub "
             "GL_CHROMIUM_shallow_flush "
             "GL_EXT_unpack_subimage";
+        if (gpu_memory_buffer_factory_ != NULL) {
+          str += " ";
+          str += "GL_CHROMIUM_gpu_memory_buffer";
+        }
         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 225 matching lines @@
 
 void GLES2Implementation::GenVertexArraysOESHelper(
     GLsizei n, const GLuint* arrays) {
   vertex_array_object_manager_->GenVertexArrays(n, arrays);
 }
 
 void GLES2Implementation::GenQueriesEXTHelper(
     GLsizei /* n */, const GLuint* /* queries */) {
 }
 
+void GLES2Implementation::GenImageBuffersHelper(
+    GLsizei /* n */, const GLuint* /* queries */) {
+}
+
 // NOTE #1: On old versions of OpenGL, calling glBindXXX with an unused id
 // generates a new resource. On newer versions of OpenGL they don't. The code
 // related to binding below will need to change if we switch to the new OpenGL
 // model. Specifically it assumes a bind will succeed which is always true in
 // the old model but possibly not true in the new model if another context has
 // deleted the resource.
 
 bool GLES2Implementation::BindBufferHelper(
     GLenum target, GLuint buffer) {
   // TODO(gman): See note #1 above.
   bool changed = false;
   switch (target) {
     case GL_ARRAY_BUFFER:
       if (bound_array_buffer_id_ != buffer) {
         bound_array_buffer_id_ = buffer;
         changed = true;
       }
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
       changed = vertex_array_object_manager_->BindElementArray(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;
+    case GL_IMAGE_BUFFER_CHROMIUM:
+      bound_gpu_memory_buffer_id_ = buffer;

[reveman, 2013/05/03 22:45:00]

The id returned from GenImageBuffers/GenImage is not a buffer object and we
can't just use it as such. To map a GpuMemoryBuffer I think we need to either
add a new Map interface for images or create some API that bridge it to real
buffer objects. It might be better to do this in a separate patch. 

[kaanb, 2013/05/06 18:20:53]

I was thinking I could just store the buffer_id and the image_id within a
cc::ResourceProvider::Resource. I think we should discuss it in today's meeting.

+      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 214 matching lines @@
   vertex_array_object_manager_->DeleteVertexArrays(n, arrays);
   if (!GetIdHandler(id_namespaces::kVertexArrays)->FreeIds(
       this, n, arrays, &GLES2Implementation::DeleteVertexArraysOESStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteVertexArraysOES", "id not created by this context.");
     return;
   }
 }
 
+void GLES2Implementation::DeleteImageBuffersHelper(
+    GLsizei n, const GLuint* imagebuffers) {
+  if (!GetIdHandler(id_namespaces::kImageBuffers)->FreeIds(
+      this, n, imagebuffers, &GLES2Implementation::DeleteImageBuffersStub)) {
+    SetGLError(
+        GL_INVALID_VALUE,
+        "glDeleteImageBuffers", "id not created by this context.");
+    return;
+  }
+
+  for (GLsizei ii = 0; ii < n; ++ii) {
+    if (imagebuffers[ii] == bound_gpu_memory_buffer_id_) {
+      bound_gpu_memory_buffer_id_ = 0;
+    }
+
+    GpuMemoryBuffer* gpu_buffer =
+        gpu_memory_buffer_tracker_->GetBuffer(imagebuffers[ii]);
+    if (gpu_buffer) {
+      gpu_memory_buffer_tracker_->RemoveBuffer(imagebuffers[ii]);
+    }
+  }
+}
+
+void GLES2Implementation::DeleteImageBuffersStub(
+    GLsizei n, const GLuint* imagebuffers) {
+  helper_->DeleteImageBuffersImmediate(n, imagebuffers);
+}
+
 void GLES2Implementation::DeleteVertexArraysOESStub(
     GLsizei n, const GLuint* arrays) {
   helper_->DeleteVertexArraysOESImmediate(n, arrays);
 }
 
 void GLES2Implementation::DeleteTexturesStub(
     GLsizei n, const GLuint* textures) {
   helper_->DeleteTexturesImmediate(n, textures);
 }
 
@@ skipping 835 matching lines @@
         SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
         return NULL;
       }
       break;
     case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
       if (access != GL_WRITE_ONLY) {
         SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
         return NULL;
       }
       break;
+    case GL_IMAGE_BUFFER_CHROMIUM:
+      break;
     default:
       SetGLError(
           GL_INVALID_ENUM, "glMapBufferCHROMIUM", "invalid target");
       return NULL;
   }
+
   GLuint buffer_id;
-  GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id);
-  if (!buffer_id) {
-    return NULL;
+  switch(target) {
+    case GL_IMAGE_BUFFER_CHROMIUM: {
+      GetBoundGpuMemoryBuffer("glMapBufferCHROMIUM", &buffer_id);
+      if (buffer_id == 0) {
+        return NULL;
+      }
+      GpuMemoryBuffer* gpu_buffer =
+          gpu_memory_buffer_tracker_->GetBuffer(buffer_id);
+      if (!gpu_buffer) {
+        SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM",
+            "invalid GPU memory buffer");
+        return NULL;
+      }
+      GpuMemoryBuffer::AccessMode mode = GpuMemoryBuffer::READ_ONLY;
+      switch(access) {
+        case GL_WRITE_ONLY:
+          mode = GpuMemoryBuffer::WRITE_ONLY;
+          break;
+        case GL_READ_ONLY:
+          mode = GpuMemoryBuffer::READ_ONLY;
+          break;
+          // TODO(kaanb): should we add GL_READ_WRITE to gl2ext.h?
+        default:
+          SetGLError(
+              GL_INVALID_ENUM, "glMapBufferCHROMIUM",
+                  "invalid GPU access mode");
+          return NULL;
+      }
+
+      if (gpu_buffer->IsMapped()) {
+        SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM",
+            "already mapped");
+        return NULL;
+      }
+
+      void* mapped_buffer = NULL;
+      gpu_buffer->Map(mode, &mapped_buffer);
+      CheckGLError();
+      return mapped_buffer;
+    }
+    case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: {
+      GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id);
+      if (!buffer_id) {
+        return NULL;
+      }
+      BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
+      if (!buffer) {
+        SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM",
+            "invalid buffer");
+        return NULL;
+      }
+      if (buffer->mapped()) {
+        SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM",
+            "already mapped");
+        return NULL;
+      }
+      // Here we wait for previous transfer operations to be finished.
+      // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
+      // with this method of synchronization. Until this is fixed,
+      // MapBufferCHROMIUM will not block even if the transfer is not ready
+      // for these calls.
+      if (buffer->transfer_ready_token()) {
+        helper_->WaitForToken(buffer->transfer_ready_token());
+        buffer->set_transfer_ready_token(0);
+      }
+      buffer->set_mapped(true);
+
+      GPU_DCHECK(buffer->address());
+      GPU_CLIENT_LOG("  returned " << buffer->address());
+      CheckGLError();
+      return buffer->address();
+    }
+    default:
+      return NULL;
   }
-  BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
-  if (!buffer) {
-    SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer");
-    return NULL;
-  }
-  if (buffer->mapped()) {
-    SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "already mapped");
-    return NULL;
-  }
-  // Here we wait for previous transfer operations to be finished.
-  // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
-  // with this method of synchronization. Until this is fixed,
-  // MapBufferCHROMIUM will not block even if the transfer is not ready
-  // for these calls.
-  if (buffer->transfer_ready_token()) {
-    helper_->WaitForToken(buffer->transfer_ready_token());
-    buffer->set_transfer_ready_token(0);
-  }
-  buffer->set_mapped(true);
-
-  GPU_DCHECK(buffer->address());
-  GPU_CLIENT_LOG("  returned " << buffer->address());
-  CheckGLError();
-  return buffer->address();
+  return NULL;
 }
 
 GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
       "[" << GetLogPrefix() << "] glUnmapBufferCHROMIUM(" << target << ")");
   GLuint buffer_id;
-  if (!GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id)) {
-    SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target");
+  switch(target) {
+    case GL_IMAGE_BUFFER_CHROMIUM: {
+      GetBoundGpuMemoryBuffer("glUnmapBufferCHROMIUM", &buffer_id);
+      if (buffer_id == 0) {
+        break;
+      }
+      GpuMemoryBuffer* gpu_buffer =
+          gpu_memory_buffer_tracker_->GetBuffer(buffer_id);
+
+      if (!gpu_buffer->IsMapped()) {
+        SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "not mapped");
+        break;
+      }
+      gpu_buffer->Unmap();
+      return true;
+    }
+    case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
+    case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM: {
+      if (!GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM",
+          &buffer_id)) {
+        SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target");
+        break;
+      }
+      if (!buffer_id) {
+        break;
+      }
+      BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
+      if (!buffer) {
+        SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM",
+            "invalid buffer");
+        break;
+      }
+      if (!buffer->mapped()) {
+        SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "not mapped");
+        break;
+      }
+      buffer->set_mapped(false);
+      return true;
+    }
+    default:
+      SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target");
   }
-  if (!buffer_id) {
-    return false;
-  }
-  BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
-  if (!buffer) {
-    SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "invalid buffer");
-    return false;
-  }
-  if (!buffer->mapped()) {
-    SetGLError(GL_INVALID_OPERATION, "glMapBufferCHROMIUM", "not mapped");
-    return false;
-  }
-  buffer->set_mapped(false);
   CheckGLError();
-  return true;
+  return false;
 }
 
 void GLES2Implementation::AsyncTexImage2DCHROMIUM(
     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("[" << GetLogPrefix() << "] glTexImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
@@ skipping 94 matching lines @@
   helper_->WaitAsyncTexImage2DCHROMIUM(target);
   CheckGLError();
 }
 
 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM");
   return helper_->InsertSyncPointCHROMIUM();
 }
 
+void GLES2Implementation::CreateGpuMemoryBuffer2DCHROMIUMHelper(
+    GLuint image_id, GLint width, GLint height) {
+  if (width < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCreateGpuMemoryBuffer2DCHROMIUM",
+               "width < 0");
+    return;
+  }
+
+  if (height < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCreateGpuMemoryBuffer2DCHROMIUM",
+               "height < 0");
+    return;
+  }
+
+  if (gpu_memory_buffer_tracker_->GetBuffer(image_id) != NULL) {
+    SetGLError(GL_INVALID_VALUE, "glCreateGpuMemoryBuffer2DCHROMIUM",
+               "existing image_id");
+    return;
+  }
+
+  if (width != 0 && height != 0) {
+    // Create new buffer.
+    gpu_memory_buffer_tracker_->CreateBuffer(image_id, width, height);
+  }
+}
+
+void GLES2Implementation::CreateGpuMemoryBuffer2DCHROMIUM(
+    GLuint image_id, GLint width, GLint height) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateGpuMemoryBuffer2DCHROMIUM("
+      << image_id << ", "
+      << width << ", "
+      << height << ")");
+  CreateGpuMemoryBuffer2DCHROMIUMHelper(image_id, width, height);
+  CheckGLError();
+}
+
 // 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