Add glCopyCompressedTextureCHROMIUM

gpu/command_buffer/service/gles2_cmd_decoder.cc

Index: gpu/command_buffer/service/gles2_cmd_decoder.cc
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index 29d4d5d14e6925ecb99c98dca01097106bcc69b1..8bd16b31ef54fa08bffdd8e9c1ca81575b0f1127 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -969,6 +969,13 @@ class GLES2DecoderImpl : public GLES2Decoder,
                                 GLint xoffset,
                                 GLint yoffset);
 
+  void DoCopyCompressedTextureCHROMIUM(GLenum target,
+                                       GLuint source_id,
+                                       GLuint dest_id,
+                                       GLenum internal_format,
+                                       GLenum dest_type,
+                                       GLsizei source_size);
+
   // Wrapper for TexStorage2DEXT.
   void DoTexStorage2DEXT(
       GLenum target,
@@ -1697,6 +1704,11 @@ class GLES2DecoderImpl : public GLES2Decoder,
                                    TextureRef* source_texture_ref,
                                    TextureRef* dest_texture_ref,
                                    GLenum dest_internal_format);
+  bool ValidateCopyCompressedTextureCHROMIUM(const char* function_name,
+                                             GLenum target,
+                                             TextureRef* source_texture_ref,
+                                             TextureRef* dest_texture_ref,
+                                             GLenum dest_internal_format);
 
   void RenderWarning(const char* filename, int line, const std::string& msg);
   void PerformanceWarning(
@@ -11523,6 +11535,67 @@ bool GLES2DecoderImpl::ValidateCopyTextureCHROMIUM(
   return true;
 }
 
+bool GLES2DecoderImpl::ValidateCopyCompressedTextureCHROMIUM(
+    const char* function_name,
+    GLenum target,
+    TextureRef* source_texture_ref,
+    TextureRef* dest_texture_ref,
+    GLenum dest_internal_format) {
+  if (!source_texture_ref || !dest_texture_ref) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "unknown texture id");
+    return false;
+  }
+
+  if (GL_TEXTURE_2D != target) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
+                       "invalid texture target");
+    return false;
+  }
+
+  Texture* source_texture = source_texture_ref->texture();
+  Texture* dest_texture = dest_texture_ref->texture();
+  if (source_texture == dest_texture) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "source and destination textures are the same");
+    return false;
+  }
+
+  if (dest_texture->target() != GL_TEXTURE_2D ||
+      (source_texture->target() != GL_TEXTURE_2D &&
+       source_texture->target() != GL_TEXTURE_RECTANGLE_ARB &&
+       source_texture->target() != GL_TEXTURE_EXTERNAL_OES)) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name,
+                       "invalid texture target binding");
+    return false;
+  }
+
+  GLenum source_type = 0;
+  GLenum source_internal_format = 0;
+  source_texture->GetLevelType(source_texture->target(), 0, &source_type,
+                               &source_internal_format);
+
+  if (dest_internal_format != source_internal_format) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "source and destination formats doesn't match");
+    return false;
+  }
+
+  bool valid_format =
+      dest_internal_format == GL_ATC_RGB_AMD ||
+      dest_internal_format == GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD ||
+      dest_internal_format == GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
+      dest_internal_format == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT ||
+      dest_internal_format == GL_ETC1_RGB8_OES;
+
+  if (!valid_format) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
+                       "invalid internal format");
+    return false;
+  }
+
+  return true;
+}
+
 void GLES2DecoderImpl::DoCopyTextureCHROMIUM(GLenum target,
                                              GLuint source_id,
                                              GLuint dest_id,
@@ -11813,6 +11886,160 @@ void GLES2DecoderImpl::DoCopySubTextureCHROMIUM(GLenum target,
   DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
 }
 
+void GLES2DecoderImpl::DoCopyCompressedTextureCHROMIUM(GLenum target,
+                                                       GLuint source_id,
+                                                       GLuint dest_id,
+                                                       GLenum internal_format,
+                                                       GLenum dest_type,
+                                                       GLsizei source_size) {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyCompressedTextureCHROMIUM");
+
+  TextureRef* source_texture_ref = GetTexture(source_id);
+  TextureRef* dest_texture_ref = GetTexture(dest_id);
+  Texture* source_texture = source_texture_ref->texture();
+  Texture* dest_texture = dest_texture_ref->texture();
+  int source_width = 0;
+  int source_height = 0;
+  gfx::GLImage* image =
+      source_texture->GetLevelImage(source_texture->target(), 0);
+  if (image) {
+    gfx::Size size = image->GetSize();
+    source_width = size.width();
+    source_height = size.height();
+    if (source_width <= 0 || source_height <= 0) {
+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_VALUE,
+          "glCopyCompressedTextureChromium", "invalid image size");
+      return;
+    }
+  } else {
+    if (!source_texture->GetLevelSize(
+             source_texture->target(), 0, &source_width, &source_height)) {
+      LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
+                         "glCopyCompressedTextureChromium",
+                         "source texture has no level 0");
+      return;
+    }
+
+    // Check that this type of texture is allowed.
+    if (!texture_manager()->ValidForTarget(source_texture->target(), 0,
+                                           source_width, source_height, 1)) {
+      LOCAL_SET_GL_ERROR(
+          GL_INVALID_VALUE, "glCopyCompressedTextureCHROMIUM",
+          "Bad dimensions");
+      return;
+    }
+  }
+
+  GLenum source_type = 0;
+  GLenum source_internal_format = 0;
+  source_texture->GetLevelType(
+      source_texture->target(), 0, &source_type, &source_internal_format);
+
+  if (dest_texture->IsImmutable()) {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
+                       "glCopyCompressedTextureCHROMIUM",
+                       "texture is immutable");
+    return;
+  }
+
+  if (!ValidateCopyCompressedTextureCHROMIUM(
+          "glCopyCompressedTextureCHROMIUM",
+          target,
+          source_texture_ref, dest_texture_ref,
+          internal_format)) {
+    return;
+  }
+
+  // Clear the source texture if necessary.
+  if (!texture_manager()->ClearTextureLevel(this, source_texture_ref,
+                                            source_texture->target(), 0)) {
+    LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, "glCopyCompressedTextureCHROMIUM",
+                       "dimensions too big");
+    return;
+  }
+
+  GLenum dest_type_previous = dest_type;
+  GLenum dest_internal_format = internal_format;
+  int dest_width = 0;
+  int dest_height = 0;
+  bool dest_level_defined =
+      dest_texture->GetLevelSize(GL_TEXTURE_2D, 0, &dest_width, &dest_height);
+
+  if (dest_level_defined) {
+    dest_texture->GetLevelType(GL_TEXTURE_2D, 0, &dest_type_previous,
+                               &dest_internal_format);
+  }
+
+  // Resize the destination texture to the dimensions of the source texture.
+  if (!dest_level_defined || dest_width != source_width ||
+      dest_height != source_height ||
+      dest_internal_format != internal_format ||
+      dest_type_previous != dest_type) {
+    // Ensure that the glCompressedTexImage2D succeeds.
+    LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCopyCompressedTextureCHROMIUM");
+    glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
+    glCompressedTexImage2D(GL_TEXTURE_2D, 0, internal_format, source_width,
+                           source_height, 0, source_size, NULL);
+    GLenum error = LOCAL_PEEK_GL_ERROR("glCopyCompressedTextureCHROMIUM");
+    if (error != GL_NO_ERROR) {
+      RestoreCurrentTextureBindings(&state_, GL_TEXTURE_2D);
+      return;
+    }
+
+    texture_manager()->SetLevelInfo(
+        dest_texture_ref, GL_TEXTURE_2D, 0, internal_format, source_width,
+        source_height, 1, 0, internal_format, dest_type, true);
+  } else {
+    texture_manager()->SetLevelCleared(dest_texture_ref, GL_TEXTURE_2D, 0,
+                                       true);

[piman, 2015/05/28 20:34:27]

We should only do that after we successfully filled the texture.

Same with the SetLevelInfo above, we can't say it's cleared yet.

In any case, no state should be modified if an error is generated.
So in command handlers we typically do all validation first, generate
errors/early return and only then modify state and do the GL calls.

[christiank, 2015/06/05 12:53:31]

Can I keep this code as is, now that I have updated the copy operation
with a fallback mode to always succeed?

+  }
+
+  ScopedModifyPixels modify(dest_texture_ref);
+
+  DCHECK(!unpack_flip_y_);
+  DCHECK(!(unpack_premultiply_alpha_ ^ unpack_unpremultiply_alpha_));

[piman, 2015/05/28 20:34:27]

These can't be DCHECKed, we can't trust the client. We need to generate an error
in this case instead.

[christiank, 2015/06/05 12:53:31]

Fixed.

+
+  // Try using GLImage::CopyTexImage when possible.
+  if (image) {
+    glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
+    if (image->CopyTexImage(GL_TEXTURE_2D))
+      return;
+  }
+
+  // As a fallback, read back the texture data and upload it again.
+  if (!feature_info_->gl_version_info().is_es) {

[reveman, 2015/05/28 14:06:48]

can you early out at the top of this function if this is not available? this
function should not modify any state unless it's supported.

[christiank, 2015/05/28 14:40:29]

We still want to use GLImage::CopyTexImage on OpenGL ES platforms where we don't
have the glGetCompressedTexImage fallback. So ideally, if I want to early out I
would need to know if GLImage::CopyTexImage will work or not.

I could make an early check like this:
if (!image && feature_info_->gl_version_info().is_es) {
return...

Would that be sufficient? GLImage::CopyTexImage could still fail, but so could
other GL commands as well I suppose.

[reveman, 2015/05/28 16:33:08]

Ok, that's a problem. If a texture is backed by an image is not something the
client should need to be aware of and more importantly- if the image
implementation can handle the copy operation or not is definitely not something
the client should have to be aware of.

We shouldn't have commands that the client can't predict if they will succeed or
not. If the extension is available then proper usage of it should always work
(disregarding oom errors and such).
We need to make this predictable from the clients pov.

How important is it to support this when GetCompressedTexImage is not available?


If that's critical then maybe we can adjust the spec to say that
CompressedCopyTextureCHROMIUM might result in the destination texture being
uncompressed. Not sure how to deal with that in the
CompressedCopySubTextureCHROMIUM case though..

[christiank, 2015/06/01 12:14:16]

It's rather important as Android is my primary driver for the tile compression
feature. I considered switching to using CopyImageSubData (EXT_copy_image)
instead. It's supported on some OpenGL ES devices, but unfortunately very few so
the problem still remains. It would not rule out OpenGL ES completely however.

I can't think of another way to solve this than changing the spec, so I'll try
that. I imagine that I'll have to render the compressed texture to a
framebuffer, then read that data out and re-upload it as a non-compressed
texture. Is that what you had in mind?

+    DoWillUseTexImageIfNeeded(source_texture, source_texture->target());
+
+    scoped_ptr<GLbyte[]> image_data(new GLbyte[source_size]);

[piman, 2015/05/28 20:34:27]

We can't trust source_size from the client. Instead we'd need to keep the size
passed to glCompressedTexImage2D on the source image and use that here.

[christiank, 2015/06/05 12:53:31]

I see. What's the best way of storing the byte size? I looked at using
estimated_size_ in the Texture object. I could update this member from
DoCompressedTexImage2D, but that's insufficient for the GLImage case. Since
GLImage may perform texture uploads I need to update the Texture object
estimated_size_ member on other places as well. Maybe DoBindTexImage2DCHROMIUM
is sufficient to cover that case?

Alternatively I could compute the byte size from the texture width, height and
format. Assuming those values can be trusted?

+    glBindTexture(GL_TEXTURE_2D, source_texture->service_id());
+    glGetCompressedTexImage(GL_TEXTURE_2D, 0, image_data.get());

[reveman, 2015/05/28 14:06:49]

can you add a TRACE_EVENT around this somehow? I understand that the usage we're
interested in will not result in this being called. A trace event here will make
it easier to notice if this is ever being called by accident.

[christiank, 2015/06/05 12:53:31]

I added an event to trace both the inefficient glGetCompressedTexImage and the
non-compressed fallback case.

+
+    glBindTexture(GL_TEXTURE_2D, dest_texture->service_id());
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

[piman, 2015/05/28 20:34:27]

Why do we do these? I don't think they belong.

[christiank, 2015/06/05 12:53:31]

We don't, you're right. Wrong thinking on my part.

+
+    glCompressedTexImage2D(GL_TEXTURE_2D, 0, internal_format, source_width,
+                           source_height, 0, source_size, image_data.get());
+    GLenum error = LOCAL_PEEK_GL_ERROR("glCopyCompressedTextureCHROMIUM");
+    if (error != GL_NO_ERROR) {
+      RestoreCurrentTextureBindings(&state_, GL_TEXTURE_2D);
+      return;
+    }
+
+    texture_manager()->SetLevelInfo(
+        dest_texture_ref, GL_TEXTURE_2D, 0, internal_format, source_width,
+        source_height, 1, 0, internal_format, dest_type, true);
+
+    DoDidUseTexImageIfNeeded(source_texture, source_texture->target());
+  } else {
+    LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glCopyCompressedTextureCHROMIUM",
+                       "platform doesn't support copying compressed textures");
+  }
+}
+
 static GLenum ExtractTypeFromStorageFormat(GLenum internalformat) {
   switch (internalformat) {
     case GL_RGB565: