gpu: Add async pixel transfer interface, stub and tests.

gpu/command_buffer/service/gles2_cmd_decoder.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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 37 matching lines @@
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/stream_texture.h"
 #include "gpu/command_buffer/service/stream_texture_manager.h"
 #include "gpu/command_buffer/service/texture_definition.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
+#include "ui/gl/async_pixel_transfer_delegate.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #if defined(OS_MACOSX)
 #include "ui/surface/io_surface_support_mac.h"
 #endif
 
 #if !defined(GL_DEPTH24_STENCIL8)
 #define GL_DEPTH24_STENCIL8 0x88F0
 #endif
@@ skipping 3431 matching lines @@
   if (info->target() != 0 && info->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
   if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
-  if (info->target() == 0) {
-    texture_manager()->SetInfoTarget(info, target);
+
+  if (!info->IsAsyncTransferTexture()) {
+    if (info->target() == 0) {
+      texture_manager()->SetInfoTarget(info, target);
+    }
+    glBindTexture(target, info->service_id());
+  } else {
+    // If the texture has async transfers, they must be complete.
+    if (info->AsyncTransferIsInProgress()) {
+      SetGLError(GL_INVALID_OPERATION,
+               "glBindTexture", "async transfer already in progress");
+      return;
+    }
+
+    if (info->target() == 0) {
+      texture_manager()->SetInfoTarget(info, target);
+    }
+
+    // Bind the GL texture, and perform any custom binding.
+    info->BindAsyncTransferTexture(target);
+
+    // We now know the transfer texture is cleared.
+    texture_manager()->SetLevelCleared(info, target, 0);
   }
-  glBindTexture(target, info->service_id());
+
+
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = info;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = info;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
@@ skipping 5817 matching lines @@
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
 
-  // TODO(epenner): Do this via an async task.
-  return DoTexImage2D(
-      target, level, internal_format, width, height, border, format, type,
-      pixels, pixels_size);
+  // We only support async uploads to 2D textures for now.
+  if (target != GL_TEXTURE_2D) {
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+    return error::kNoError;
+  }
+
+  // We only support uploads to level zero for now.
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "level != 0");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+    return error::kNoError;
+  }
+
+  // We only support one async transfer in progress.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info || info->AsyncTransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        "glAsyncTexImage2D", "transfer already in progress");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+  }
+
+  // We know the memory/size is safe, so get the real shared
+  // memory since it might need to be duped to prevent
+  // use-after-free issues.
+  Buffer buffer = GetSharedMemoryBuffer(c.pixels_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.pixels_shm_offset;
+  uint32 shm_data_size = pixels_size;
+
+  gfx::AsyncPixelTransferDelegate::Get()->AsyncTexImage2D(
+      info->AsyncTransferState(),
+      target, level, internal_format,
+      width, height, border, format, type,
+      shared_memory, shm_size, shm_data_offset, shm_data_size);
+
+  return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM(
     uint32 immediate_data_size, const gles2::AsyncTexSubImage2DCHROMIUM& c) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleAsyncTexSubImage2DCHROMIUM");
 
   // TODO: This is a copy of HandleTexSubImage2D validation. Merge
   // as much of it as possible.
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
@@ skipping 17 matching lines @@
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
     return error::kNoError;
   }
   if (height < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "height < 0");
     return error::kNoError;
   }
   if (!validators_->texture_format.IsValid(format)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", format, "format");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexSubImage2DCHROMIUM"

     return error::kNoError;
   }
   if (!validators_->pixel_type.IsValid(type)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

     return error::kNoError;
   }
-  if (pixels == NULL) {
+
+  // TexSubImage must have valid pixels.
+  if (pixels == NULL)

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

     return error::kOutOfBounds;

[greggman, 2012/12/06 06:52:00]

Does this need to be death or should it be SetGLError(GL_INVALID_OPERATION,
...)?

[epenner, 2012/12/08 03:15:04]

It's an SetGLError now when no transfer buffer is provided.

+
+  // We only support async uploads to 2D textures for now.
+  if (target != GL_TEXTURE_2D) {
+    SetGLErrorInvalidEnum("glTexSubImage2D", type, "type");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+    return error::kNoError;
   }
 
-  // TODO(epenner): Do this via an async task.
-  DoTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type, pixels);
+  // We only support uploads to level zero for now.
+  if (level != 0) {
+    SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "level != 0");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+    return error::kNoError;
+  }
+
+  // We only support one async transfer in progress.
+  TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
+  if (!info || info->AsyncTransferIsInProgress()) {
+    SetGLError(GL_INVALID_OPERATION,
+        "glTexSubImage2D", "transfer already in progress");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+  }
+
+  // It would be nice to do this async as well, but that way we can't
+  // be sure the texture is cleared after this call. So better to do it
+  // immediately (it's easy to avoid this penalty anyway).
+  GLsizei tex_width = 0;
+  GLsizei tex_height = 0;
+  bool ok = info->GetLevelSize(target, level, &tex_width, &tex_height);
+  DCHECK(ok);
+  if (xoffset != 0 || yoffset != 0 ||
+      width != tex_width || height != tex_height) {
+    if (!texture_manager()->ClearTextureLevel(this, info, target, level)) {
+      SetGLError(GL_OUT_OF_MEMORY, "glTexSubImage2D", "dimensions too big");

[greggman, 2012/12/06 06:52:00]

"glAsyncTexImage2DCHROMIUM"

[epenner, 2012/12/08 03:15:04]

Done.

+      return error::kNoError;
+    }
+    // The level is certainly cleared now. In the full update case
+    // we wait until the texture is used to mark it as cleared,
+    // since by then the async transfer must be complete.
+    texture_manager()->SetLevelCleared(info, target, level);
+  }
+
+  // We know the memory/size is safe, so get the real shared
+  // memory since it might need to be duped to prevent
+  // use-after-free issues.
+  Buffer buffer = GetSharedMemoryBuffer(c.data_shm_id);
+  base::SharedMemory* shared_memory = buffer.shared_memory;
+  uint32 shm_size = buffer.size;
+  uint32 shm_data_offset = c.data_shm_offset;
+  uint32 shm_data_size = data_size;
+
+  gfx::AsyncPixelTransferDelegate::Get()->AsyncTexSubImage2D(
+      info->AsyncTransferState(),
+      target, level, xoffset, yoffset,
+      width, height, format, type,
+      shared_memory, shm_size, shm_data_offset, shm_data_size);
+
   return error::kNoError;
 }
 
 // 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/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu