Decompress ETC texture data when there is no native support.

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 46 matching lines @@
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/sampler_manager.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/command_buffer/service/transform_feedback_manager.h"
 #include "gpu/command_buffer/service/vertex_array_manager.h"
 #include "gpu/command_buffer/service/vertex_attrib_manager.h"
+#include "third_party/angle/src/image_util/loadimage.h"
 #include "third_party/smhasher/src/City.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/overlay_transform.h"
 #include "ui/gfx/transform.h"
 #include "ui/gl/ca_renderer_layer_params.h"
@@ skipping 11398 matching lines @@
     {8, 5},
     {8, 6},
     {8, 8},
     {10, 5},
     {10, 6},
     {10, 8},
     {10, 10},
     {12, 10},
     {12, 12}};
 
+bool CheckETCFormatSupport(const FeatureInfo& featureInfo) {
+  const gl::GLVersionInfo& versionInfo = featureInfo.gl_version_info();
+  return versionInfo.IsAtLeastGL(4, 3) || versionInfo.IsAtLeastGLES(3, 0) ||
+         featureInfo.feature_flags().arb_es3_compatibility;
+}
+
+using CompressedFormatSupportCheck = bool (*)(const FeatureInfo&);
+using CompressedFormatDecompressionFunction = void (*)(size_t width,
+                                                       size_t height,
+                                                       size_t depth,
+                                                       const uint8_t* input,
+                                                       size_t inputRowPitch,
+                                                       size_t inputDepthPitch,
+                                                       uint8_t* output,
+                                                       size_t outputRowPitch,
+                                                       size_t outputDepthPitch);
+
+struct CompressedFormatInfo {
+  GLenum format;
+  uint32_t block_size;
+  uint32_t bytes_per_block;
+  CompressedFormatSupportCheck support_check;
+  CompressedFormatDecompressionFunction decompression_function;
+  GLenum decompressed_internal_format;
+  GLenum decompressed_format;
+  GLenum decompressed_type;
+};
+
+const CompressedFormatInfo kCompressedFormatInfoArray[] = {
+    {
+        GL_COMPRESSED_R11_EAC, 4, 8, CheckETCFormatSupport,
+        angle::LoadEACR11ToR8, GL_R8, GL_RED, GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_SIGNED_R11_EAC, 4, 8, CheckETCFormatSupport,
+        angle::LoadEACR11SToR8, GL_R8_SNORM, GL_RED, GL_BYTE,
+    },
+    {
+        GL_COMPRESSED_RG11_EAC, 4, 16, CheckETCFormatSupport,
+        angle::LoadEACRG11ToRG8, GL_RG8, GL_RG, GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_SIGNED_RG11_EAC, 4, 16, CheckETCFormatSupport,
+        angle::LoadEACRG11SToRG8, GL_RG8_SNORM, GL_RG, GL_BYTE,
+    },
+    {
+        GL_COMPRESSED_RGB8_ETC2, 4, 8, CheckETCFormatSupport,
+        angle::LoadETC2RGB8ToRGBA8, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_SRGB8_ETC2, 4, 8, CheckETCFormatSupport,
+        angle::LoadETC2SRGB8ToRGBA8, GL_SRGB8_ALPHA8, GL_SRGB_ALPHA,
+        GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_RGBA8_ETC2_EAC, 4, 16, CheckETCFormatSupport,
+        angle::LoadETC2RGBA8ToRGBA8, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 4, 8,
+        CheckETCFormatSupport, angle::LoadETC2RGB8A1ToRGBA8, GL_RGBA8, GL_RGBA,
+        GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 4, 16, CheckETCFormatSupport,
+        angle::LoadETC2SRGBA8ToSRGBA8, GL_SRGB8_ALPHA8, GL_SRGB_ALPHA,
+        GL_UNSIGNED_BYTE,
+    },
+    {
+        GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 4, 8,
+        CheckETCFormatSupport, angle::LoadETC2SRGB8A1ToRGBA8, GL_SRGB8_ALPHA8,
+        GL_SRGB_ALPHA, GL_UNSIGNED_BYTE,
+    },
+};
+
+const CompressedFormatInfo* GetCompressedFormatInfo(GLenum format) {
+  for (size_t i = 0; i < arraysize(kCompressedFormatInfoArray); i++) {
+    if (kCompressedFormatInfoArray[i].format == format) {
+      return &kCompressedFormatInfoArray[i];
+    }
+  }
+  return nullptr;
+}
+
+uint32_t GetCompressedFormatRowPitch(const CompressedFormatInfo& info,
+                                     uint32_t width) {
+  uint32_t num_blocks_wide = (width + info.block_size - 1) / info.block_size;
+  return num_blocks_wide * info.bytes_per_block;
+}
+
+uint32_t GetCompressedFormatDepthPitch(const CompressedFormatInfo& info,
+                                       uint32_t width,
+                                       uint32_t height) {
+  uint32_t num_blocks_high = ((height + info.block_size - 1) / info.block_size);

[piman, 2016/07/08 19:30:39]

nit: no need for the outer set of parens.

[Geoff Lang, 2016/07/11 19:19:07]

Done.

+  return num_blocks_high * GetCompressedFormatRowPitch(info, width);
+}
+
+std::unique_ptr<uint8_t[]> DecompressTextureData(
+    const ContextState& state,
+    const CompressedFormatInfo& info,
+    uint32_t width,
+    uint32_t height,
+    uint32_t depth,
+    GLsizei image_size,
+    const void* data) {
+  uint32_t output_pixel_size = GLES2Util::ComputeImageGroupSize(
+      info.decompressed_format, info.decompressed_type);
+  std::unique_ptr<uint8_t[]> decompressed_data(
+      new uint8_t[output_pixel_size * width * height]);
+
+  // If a PBO is bound, map it to decompress the data.
+  const void* input_data = data;
+  if (state.bound_pixel_unpack_buffer) {
+    input_data = glMapBufferRange(GL_PIXEL_UNPACK_BUFFER,

[piman, 2016/07/08 19:30:39]

The buffer might already be mapped, in which case glMapBufferRange will fail.
You can check if it's already mapped with
state.bound_pixel_unpack_buffer->GetMappedRange(), in which case raising
GL_INVALID_OPERATION should be ok.

Also, we would want to bounds check (data, data+image_size) against the the
buffer size to avoid trying to map outside the buffer (which would fail).
Lastly, mapping may fail because of GL_OUT_OF_MEMORY, in which case we shouldn't
continue - instead pass the GL_OUT_OF_MEMORY to the client, I think.

[Geoff Lang, 2016/07/11 19:19:08]

I updated the validation code to cover these cases.  I incorrectly assumed that
they were already handled.

+                                  reinterpret_cast<GLintptr>(data), image_size,
+                                  GL_MAP_READ_BIT);
+  }
+
+  info.decompression_function(
+      width, height, depth, reinterpret_cast<const uint8_t*>(input_data),

[piman, 2016/07/08 19:30:39]

nit: static_cast instead of reinterpret_cast

[Geoff Lang, 2016/07/11 19:19:08]

Done.

+      GetCompressedFormatRowPitch(info, width),
+      GetCompressedFormatDepthPitch(info, width, height),
+      decompressed_data.get(), output_pixel_size * width,
+      output_pixel_size * width * height);
+
+  if (state.bound_pixel_unpack_buffer) {
+    glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);

[piman, 2016/07/08 19:30:39]

glUnmapBuffer is allowed to fail, corrupting the data (sigh...). If that
happens, I think we should lose the context, similarly to what we do in
HandleUnmapBuffer.

[Geoff Lang, 2016/07/11 19:19:08]

Done, I had to modify the command buffer generation script to allow the errors
to propagate all the way back.

+  }
+
+  return decompressed_data;
+}
+
+void PushDecompressedTextureUnpackState() {
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+  glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, 0);
+  glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);

[Zhenyao Mo, 2016/07/08 22:40:29]

nit: the above three lines can be put inside the condition if a unpack buffer is
bound (otherwise we haven't really sent the ROW_LENGTH and IMAGE_HEIGHT to
driver). I feel this should also be handled in ContextState like the Pop* one.

[Geoff Lang, 2016/07/11 19:19:08]

Done, moved all the logic into ContextState.

+}
+
+void PopDecompressedTextureUnpackState(const ContextState& state) {
+  state.RestoreUnpackState();
+}
+
 bool IsValidDXTSize(GLint level, GLsizei size) {
   // TODO(zmo): Linux NVIDIA driver does allow size of 1 and 2 on level 0.
   // However, the WebGL conformance test and blink side code forbid it.
   // For now, let's be on the cautious side. If all drivers behaves the same
   // as Linux NVIDIA, then we can remove this limitation.
   return (level && size == 1) ||
          (level && size == 2) ||
          !(size % kS3TCBlockWidth);
 }
 
@@ skipping 403 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage2D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   std::unique_ptr<int8_t[]> zero;
-  if (!data) {
+  if (!state_.bound_pixel_unpack_buffer && !data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage2D");
-  glCompressedTexImage2D(
-      target, level, internal_format, width, height, border, image_size, data);
+
+  const CompressedFormatInfo* format_info =
+      GetCompressedFormatInfo(internal_format);
+  if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
+    std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
+        state_, *format_info, width, height, 1, image_size, data);
+    PushDecompressedTextureUnpackState();
+    glTexImage2D(target, level, format_info->decompressed_internal_format,
+                 width, height, border, format_info->decompressed_format,
+                 format_info->decompressed_type, decompressed_data.get());
+    PopDecompressedTextureUnpackState(state_);
+  } else {
+    glCompressedTexImage2D(target, level, internal_format, width, height,
+                           border, image_size, data);
+  }
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage2D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, 1, border, 0, 0,
                                     gfx::Rect(width, height));
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
@@ skipping 44 matching lines @@
     LOCAL_SET_GL_ERROR(
         GL_OUT_OF_MEMORY, "glCompressedTexImage3D", "out of memory");
     return error::kNoError;
   }
 
   if (texture->IsAttachedToFramebuffer()) {
     framebuffer_state_.clear_state_dirty = true;
   }
 
   std::unique_ptr<int8_t[]> zero;
-  if (!data) {
+  if (!state_.bound_pixel_unpack_buffer && !data) {
     zero.reset(new int8_t[image_size]);
     memset(zero.get(), 0, image_size);
     data = zero.get();
   }
   LOCAL_COPY_REAL_GL_ERRORS_TO_WRAPPER("glCompressedTexImage3D");
-  glCompressedTexImage3D(target, level, internal_format, width, height, depth,
-                         border, image_size, data);
+  const CompressedFormatInfo* format_info =
+      GetCompressedFormatInfo(internal_format);
+  if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
+    std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
+        state_, *format_info, width, height, depth, image_size, data);
+    PushDecompressedTextureUnpackState();
+    glTexImage3D(target, level, format_info->decompressed_internal_format,
+                 width, height, depth, border, format_info->decompressed_format,
+                 format_info->decompressed_type, decompressed_data.get());
+    PopDecompressedTextureUnpackState(state_);
+  } else {
+    glCompressedTexImage3D(target, level, internal_format, width, height, depth,
+                           border, image_size, data);
+  }
   GLenum error = LOCAL_PEEK_GL_ERROR("glCompressedTexImage3D");
   if (error == GL_NO_ERROR) {
     texture_manager()->SetLevelInfo(texture_ref, target, level, internal_format,
                                     width, height, depth, border, 0, 0,
                                     gfx::Rect(width, height));
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
@@ skipping 44 matching lines @@
                                           target, level, xoffset, yoffset,
                                           zoffset, width, height, depth,
                                           format, texture)) {
     return;
   }
 
   // Note: There is no need to deal with texture cleared tracking here
   // because the validation above means you can only get here if the level
   // is already a matching compressed format and in that case
   // CompressedTexImage3D already cleared the texture.
-  glCompressedTexSubImage3D(
-      target, level, xoffset, yoffset, zoffset, width, height, depth, format,
-      image_size, data);
+
+  const CompressedFormatInfo* format_info =
+      GetCompressedFormatInfo(internal_format);
+  if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
+    std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
+        state_, *format_info, width, height, depth, image_size, data);
+    PushDecompressedTextureUnpackState();
+    glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height,
+                    depth, format_info->decompressed_format,
+                    format_info->decompressed_type, decompressed_data.get());
+    PopDecompressedTextureUnpackState(state_);
+  } else {
+    glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
+                              height, depth, format, image_size, data);
+  }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(uint32_t immediate_data_size,
                                                 const void* cmd_data) {
   const gles2::cmds::TexImage2D& c =
       *static_cast<const gles2::cmds::TexImage2D*>(cmd_data);
@@ skipping 228 matching lines @@
     // We can skip the clear if we're uploading the entire level.
     if (xoffset == 0 && yoffset == 0 &&
         width == level_width && height == level_height) {
       texture_manager()->SetLevelCleared(texture_ref, target, level, true);
     } else {
       texture_manager()->ClearTextureLevel(this, texture_ref, target, level);
     }
     DCHECK(texture->IsLevelCleared(target, level));
   }
 
-  glCompressedTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, image_size, data);
+  const CompressedFormatInfo* format_info =
+      GetCompressedFormatInfo(internal_format);
+  if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
+    std::unique_ptr<uint8_t[]> decompressed_data = DecompressTextureData(
+        state_, *format_info, width, height, 1, image_size, data);
+    PushDecompressedTextureUnpackState();
+    glTexSubImage2D(target, level, xoffset, yoffset, width, height,
+                    format_info->decompressed_format,
+                    format_info->decompressed_type, decompressed_data.get());
+    PopDecompressedTextureUnpackState(state_);
+  } else {
+    glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height,
+                              format, image_size, data);
+  }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 static void Clip(
     GLint start, GLint range, GLint sourceRange,
     GLint* out_start, GLint* out_range) {
   DCHECK(out_start);
@@ skipping 2776 matching lines @@
       if (target == GL_TEXTURE_3D)
         level_depth = std::max(1, level_depth >> 1);
     }
     if (!estimated_size.IsValid() ||
         !EnsureGPUMemoryAvailable(estimated_size.ValueOrDefault(0))) {
       LOCAL_SET_GL_ERROR(GL_OUT_OF_MEMORY, function_name, "out of memory");
       return;
     }
   }
 
+  GLenum compatibility_internal_format = internal_format;
+  const CompressedFormatInfo* format_info =
+      GetCompressedFormatInfo(internal_format);
+  if (format_info != nullptr && !format_info->support_check(*feature_info_)) {
+    compatibility_internal_format = format_info->decompressed_internal_format;
+  }
+
   // TODO(zmo): We might need to emulate TexStorage using TexImage or
   // CompressedTexImage on Mac OSX where we expose ES3 APIs when the underlying
   // driver is lower than 4.2 and ARB_texture_storage extension doesn't exist.
   if (dimension == ContextState::k2D) {
-    glTexStorage2DEXT(target, levels, internal_format, width, height);
+    glTexStorage2DEXT(target, levels, compatibility_internal_format, width,
+                      height);
   } else {
-    glTexStorage3D(target, levels, internal_format, width, height, depth);
+    glTexStorage3D(target, levels, compatibility_internal_format, width, height,
+                   depth);
   }
 
   {
     GLsizei level_width = width;
     GLsizei level_height = height;
     GLsizei level_depth = depth;
     GLenum adjusted_format =
         feature_info_->IsES3Enabled() ? internal_format : format;
     for (int ii = 0; ii < levels; ++ii) {
       if (target == GL_TEXTURE_CUBE_MAP) {
@@ skipping 1988 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 "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu