Tile Compression

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 "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 3759 matching lines @@
     uint32 async_token = NextAsyncUploadToken();
     buffer->set_last_async_upload_token(async_token);
     helper_->AsyncTexSubImage2DCHROMIUM(
         target, level, xoffset, yoffset, width, height, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset,
         async_token,
         async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
   }
 }
 
+void GLES2Implementation::AsyncCompressedTexImage2DCHROMIUM(
+    GLenum target,
+    GLint level,
+    GLint internalformat,
+    GLsizei width,
+    GLsizei height,
+    GLint border,
+    GLsizei imagesize,
+    const void* pixels) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG(
+      "[" << GetLogPrefix() << "] glCompressedTexImage2D("
+          << GLES2Util::GetStringTextureTarget(target) << ", " << level << ", "
+          << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
+          << width << ", " << height << ", " << border << ", " << imagesize
+          << ", " << static_cast<const void*>(pixels) << ")");
+  if (level < 0 || height < 0 || width < 0) {
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "dimension < 0");
+    return;
+  }
+  if (border != 0) {
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "border != 0");
+    return;
+  }
+
+  int calculated_imagesize = 0;
+  if (!GLES2Util::ComputeCompressedImageSize(width, height, internalformat,
+                                             &calculated_imagesize) ||
+      calculated_imagesize != imagesize) {
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D",
+               "imagesize is not consistent");
+    return;
+  }
+
+  // If there's no data/buffer just issue the AsyncTexImage2D
+  if (!pixels && !bound_pixel_unpack_transfer_buffer_id_) {
+    helper_->AsyncCompressedTexImage2DCHROMIUM(
+        target, level, internalformat, width, height, imagesize, 0, 0, 0, 0, 0);
+    return;
+  }
+
+  if (!EnsureAsyncUploadSync()) {
+    SetGLError(GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
+    return;
+  }
+
+  // Otherwise, async uploads require a transfer buffer to be bound.
+  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
+  // the buffer before the transfer is finished. (Currently such
+  // synchronization has to be handled manually.)
+  GLuint offset = ToGLuint(pixels);
+  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+      bound_pixel_unpack_transfer_buffer_id_,
+      "glAsyncCompressedTexImage2DCHROMIUM", offset, imagesize);
+  if (buffer && buffer->shm_id() != -1) {
+    uint32 async_token = NextAsyncUploadToken();
+    buffer->set_last_async_upload_token(async_token);
+    helper_->AsyncCompressedTexImage2DCHROMIUM(
+        target, level, internalformat, width, height, imagesize,
+        buffer->shm_id(), buffer->shm_offset() + offset, async_token,
+        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
+  }
+}
+
+void GLES2Implementation::AsyncCompressedTexSubImage2DCHROMIUM(
+    GLenum target,
+    GLint level,
+    GLint xoffset,
+    GLint yoffset,
+    GLsizei width,
+    GLsizei height,
+    GLenum format,
+    GLsizei imagesize,
+    const void* pixels) {
+  GPU_CLIENT_SINGLE_THREAD_CHECK();
+  GPU_CLIENT_LOG(
+      "[" << GetLogPrefix() << "] glAsyncCompressedTexSubImage2DCHROMIUM("
+          << GLES2Util::GetStringTextureTarget(target) << ", " << level << ", "
+          << xoffset << ", " << yoffset << ", " << width << ", " << height
+          << ", " << GLES2Util::GetStringTextureFormat(format) << ", "
+          << imagesize << ", " << static_cast<const void*>(pixels) << ")");
+  if (level < 0 || height < 0 || width < 0) {
+    SetGLError(GL_INVALID_VALUE, "glAsyncCompressedTexSubImage2DCHROMIUM",
+               "dimension < 0");
+    return;
+  }
+
+  int calculated_imagesize = 0;
+  if (!GLES2Util::ComputeCompressedImageSize(width, height, format,
+                                             &calculated_imagesize) ||
+      calculated_imagesize != imagesize) {
+    SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D",
+               "imagesize is not consistent");
+    return;
+  }
+
+  if (!EnsureAsyncUploadSync()) {
+    SetGLError(GL_OUT_OF_MEMORY, "glCompressedTexSubImage2D", "out of memory");
+    return;
+  }
+
+  // Async uploads require a transfer buffer to be bound.
+  // TODO(hubbe): Make MapBufferCHROMIUM block if someone tries to re-use
+  // the buffer before the transfer is finished. (Currently such
+  // synchronization has to be handled manually.)
+  GLuint offset = ToGLuint(pixels);
+  BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
+      bound_pixel_unpack_transfer_buffer_id_,
+      "glAsyncCompressedTexSubImage2DCHROMIUM", offset, imagesize);
+  if (buffer && buffer->shm_id() != -1) {
+    uint32 async_token = NextAsyncUploadToken();
+    buffer->set_last_async_upload_token(async_token);
+    helper_->AsyncCompressedTexSubImage2DCHROMIUM(
+        target, level, xoffset, yoffset, width, height, format, imagesize,
+        buffer->shm_id(), buffer->shm_offset() + offset, async_token,
+        async_upload_sync_shm_id_, async_upload_sync_shm_offset_);
+  }
+}
+
 void GLES2Implementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitAsyncTexImage2DCHROMIUM("
       << GLES2Util::GetStringTextureTarget(target) << ")");
   helper_->WaitAsyncTexImage2DCHROMIUM(target);
   CheckGLError();
 }
 
 void GLES2Implementation::WaitAllAsyncTexImage2DCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
@@ skipping 195 matching lines @@
   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 "gpu/command_buffer/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu