Add glCopyCompressedTextureCHROMIUM

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 <cmath>
@@ skipping 951 matching lines @@
                              GLuint dest_id,
                              GLenum internal_format,
                              GLenum dest_type);
 
   void DoCopySubTextureCHROMIUM(GLenum target,
                                 GLuint source_id,
                                 GLuint dest_id,
                                 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,
       GLint levels,
       GLenum internal_format,
       GLsizei width,
       GLsizei height);
 
   void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
   void DoProduceTextureDirectCHROMIUM(GLuint texture, GLenum target,
@@ skipping 708 matching lines @@
   bool ValidateCompressedTexSubDimensions(
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height, GLenum format,
     Texture* texture);
   bool ValidateCopyTextureCHROMIUM(const char* function_name,
                                    GLenum target,
                                    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(
       const char* filename, int line, const std::string& msg);
 
   const FeatureInfo::FeatureFlags& features() const {
     return feature_info_->feature_flags();
   }
 
   const FeatureInfo::Workarounds& workarounds() const {
@@ skipping 9806 matching lines @@
                              source_internal_format == GL_LUMINANCE_ALPHA ||
                              source_internal_format == GL_BGRA_EXT;
   if (!valid_source_format || !valid_dest_format) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "invalid internal format");
     return false;
   }
   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,
                                              GLenum internal_format,
                                              GLenum dest_type) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
 
   TextureRef* source_texture_ref = GetTexture(source_id);
   TextureRef* dest_texture_ref = GetTexture(dest_id);
   Texture* source_texture = source_texture_ref->texture();
@@ skipping 270 matching lines @@
         this, source_texture->target(), source_texture->service_id(),
         source_internal_format, dest_texture->service_id(),
         dest_internal_format, xoffset, yoffset, dest_width, dest_height,
         source_width, source_height, unpack_flip_y_, unpack_premultiply_alpha_,
         unpack_unpremultiply_alpha_);
   }
 
   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:
       return GL_UNSIGNED_SHORT_5_6_5;
     case GL_RGBA4:
       return GL_UNSIGNED_SHORT_4_4_4_4;
     case GL_RGB5_A1:
       return GL_UNSIGNED_SHORT_5_5_5_1;
     case GL_RGB8_OES:
       return GL_UNSIGNED_BYTE;
@@ skipping 1131 matching lines @@
   }
 }
 
 // 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