Reland of Extend CopyTextureCHROMIUM to more ES 3.0 texture formats.

gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.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_copy_texture_chromium.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
+#include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_version_info.h"
 
 namespace {
 
 const GLfloat kIdentityMatrix[16] = {1.0f, 0.0f, 0.0f, 0.0f,
                                      0.0f, 1.0f, 0.0f, 0.0f,
                                      0.0f, 0.0f, 1.0f, 0.0f,
                                      0.0f, 0.0f, 0.0f, 1.0f};
 
 enum FragmentShaderId {
@@ skipping 56 matching lines @@
     case GL_TEXTURE_EXTERNAL_OES:
       return shader_ids[index][SAMPLER_EXTERNAL_OES];
     default:
       break;
   }
 
   NOTREACHED();
   return shader_ids[0][SAMPLER_2D];
 }
 
-const char* kShaderPrecisionPreamble = "\
-    #ifdef GL_ES\n\
-    precision mediump float;\n\
-    #define TexCoordPrecision mediump\n\
-    #else\n\
-    #define TexCoordPrecision\n\
-    #endif\n";
+const char* kShaderPrecisionPreamble =
+    "#ifdef GL_ES\n"
+    "precision mediump float;\n"
+    "#define TexCoordPrecision mediump\n"
+    "#else\n"
+    "#define TexCoordPrecision\n"
+    "#endif\n";
 
 std::string GetVertexShaderSource(const gl::GLVersionInfo& gl_version_info) {
   std::string source;
 
   // Preamble for core and compatibility mode.
   if (gl_version_info.is_desktop_core_profile) {
-    source += std::string("\
-        #version 150\n\
-        #define ATTRIBUTE in\n\
-        #define VARYING out\n");
+    source += std::string("#version 150\n");

[Zhenyao Mo, 2016/11/14 20:04:50]

This is incorrect.  Now we have
1) desktop core profile (mac)
2) desktop compatibility profile (linux)
3) ES3 profile (ANGLE ES3 on Windows, Android ES3)
4) ES2 profile (ANGLE ES2 on Windows, Android ES2)

I think missing handling 4) is why D3D9 fails.  Also, we don't have Android bots
with ES2, but we definitely don't want to fail that platform because some low
end phone users might still be on it.

I don't understand why your CL doesn't cause failures on Linux, because here you
just put it to ES3 path, and that ES3 shader should not work there.  Can you
investigate it a bit and let me know why?

[qiankun, 2016/11/18 01:25:40]

I updated the shaders per underlying context. I think it's OK to use GLSL for
core profile and compatibility profile, ESSL 1.0 for ES2, and ESSL 3.0 for ES3.

I don't know why previous ES3 shaders succeed to compile on Linux. What I see is
Linux desktop compatibility profile accepts ES3 shaders.

   } else {
-    source += std::string("\
-        #define ATTRIBUTE attribute\n\
-        #define VARYING varying\n");
+    source += std::string("#version 300 es\n");
   }
+  source += std::string(
+      "#define ATTRIBUTE in\n"
+      "#define VARYING out\n");
 
   // Preamble for texture precision.
   source += std::string(kShaderPrecisionPreamble);
 
   // Main shader source.
-  source += std::string("\
-      uniform vec2 u_vertex_dest_mult;\n\
-      uniform vec2 u_vertex_dest_add;\n\
-      uniform vec2 u_vertex_source_mult;\n\
-      uniform vec2 u_vertex_source_add;\n\
-      ATTRIBUTE vec2 a_position;\n\
-      VARYING TexCoordPrecision vec2 v_uv;\n\
-      void main(void) {\n\
-        gl_Position = vec4(0, 0, 0, 1);\n\
-        gl_Position.xy = a_position.xy * u_vertex_dest_mult + \
-                         u_vertex_dest_add;\n\
-        v_uv = a_position.xy * u_vertex_source_mult + u_vertex_source_add;\n\
-      }\n");
+  source += std::string(
+      "uniform vec2 u_vertex_dest_mult;\n"
+      "uniform vec2 u_vertex_dest_add;\n"
+      "uniform vec2 u_vertex_source_mult;\n"
+      "uniform vec2 u_vertex_source_add;\n"
+      "ATTRIBUTE vec2 a_position;\n"
+      "VARYING TexCoordPrecision vec2 v_uv;\n"
+      "void main(void) {\n"
+      "  gl_Position = vec4(0, 0, 0, 1);\n"
+      "  gl_Position.xy = a_position.xy * u_vertex_dest_mult + "
+      "u_vertex_dest_add;\n"
+      "  v_uv = a_position.xy * u_vertex_source_mult + u_vertex_source_add;\n"
+      "}\n");
 
   return source;
 }
 
 std::string GetFragmentShaderSource(const gl::GLVersionInfo& gl_version_info,
                                     bool premultiply_alpha,
                                     bool unpremultiply_alpha,
                                     bool nv_egl_stream_consumer_external,
-                                    GLenum target) {
+                                    GLenum target,
+                                    GLenum source_format,
+                                    GLenum format) {
   std::string source;
 
   // Preamble for core and compatibility mode.
   if (gl_version_info.is_desktop_core_profile) {
-    source += std::string("\
-        #version 150\n\
-        out vec4 frag_color;\n\
-        #define VARYING in\n\
-        #define FRAGCOLOR frag_color\n\
-        #define TextureLookup texture\n");
+    source += std::string("#version 150\n");
   } else {
-    switch (target) {
-      case GL_TEXTURE_2D:
-        source += std::string("#define TextureLookup texture2D\n");
-        break;
-      case GL_TEXTURE_RECTANGLE_ARB:
-        source += std::string("#define TextureLookup texture2DRect\n");
-        break;
-      case GL_TEXTURE_EXTERNAL_OES:
-        source +=
-            std::string("#extension GL_OES_EGL_image_external : enable\n");
+    source += std::string("#version 300 es\n");
+    if (target == GL_TEXTURE_EXTERNAL_OES) {
+      source += std::string("#extension GL_OES_EGL_image_external : enable\n");
 
-        if (nv_egl_stream_consumer_external) {
-          source += std::string(
-              "#extension GL_NV_EGL_stream_consumer_external : enable\n");
-        }
+      if (nv_egl_stream_consumer_external) {
+        source += std::string(
+            "#extension GL_NV_EGL_stream_consumer_external : enable\n");
+      }
+    }
+  }
 
-        source += std::string("#define TextureLookup texture2D\n");
-        break;
-      default:
-        NOTREACHED();
-        break;
+  // Preamble for texture precision.
+  source += std::string(kShaderPrecisionPreamble);
+
+  if (gpu::gles2::GLES2Util::IsSignedIntegerFormat(format)) {
+    source += std::string("#define TextureType ivec4\n");
+    if (gpu::gles2::GLES2Util::IsSignedIntegerFormat(source_format))
+      source += std::string("#define InnerScaleValue 1\n");
+    else if (gpu::gles2::GLES2Util::IsUnsignedIntegerFormat(source_format))
+      source += std::string("#define InnerScaleValue 1u\n");
+    else
+      source += std::string("#define InnerScaleValue 255.0\n");
+    source += std::string("#define OuterScaleValue 1\n");
+  } else if (gpu::gles2::GLES2Util::IsUnsignedIntegerFormat(format)) {
+    source += std::string("#define TextureType uvec4\n");
+    if (gpu::gles2::GLES2Util::IsSignedIntegerFormat(source_format))
+      source += std::string("#define InnerScaleValue 1\n");
+    else if (gpu::gles2::GLES2Util::IsUnsignedIntegerFormat(source_format))
+      source += std::string("#define InnerScaleValue 1u\n");
+    else
+      source += std::string("#define InnerScaleValue 255.0\n");
+    source += std::string("#define OuterScaleValue 1u\n");
+  } else {
+    source += std::string("#define TextureType vec4\n");
+    if (gpu::gles2::GLES2Util::IsSignedIntegerFormat(source_format)) {
+      source += std::string("#define InnerScaleValue 1\n");
+      source += std::string("#define OuterScaleValue (1.0 / 255.0)\n");
+    } else if (gpu::gles2::GLES2Util::IsUnsignedIntegerFormat(source_format)) {
+      source += std::string("#define InnerScaleValue 1u\n");
+      source += std::string("#define OuterScaleValue (1.0 / 255.0)\n");
+    } else {
+      source += std::string("#define InnerScaleValue 1.0\n");
+      source += std::string("#define OuterScaleValue 1.0\n");
     }
-    source += std::string("\
-        #define VARYING varying\n\
-        #define FRAGCOLOR gl_FragColor\n");
   }
+  source += std::string(
+      "out TextureType frag_color;\n"
+      "#define VARYING in\n"
+      "#define FRAGCOLOR frag_color\n"
+      "#define TextureLookup texture\n");
 
   // Preamble for sampler type.
   switch (target) {
     case GL_TEXTURE_2D:
       source += std::string("#define SamplerType sampler2D\n");
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       source += std::string("#define SamplerType sampler2DRect\n");
       break;
     case GL_TEXTURE_EXTERNAL_OES:
       source += std::string("#define SamplerType samplerExternalOES\n");
       break;
     default:
       NOTREACHED();
       break;
   }
 
-  // Preamble for texture precision.
-  source += std::string(kShaderPrecisionPreamble);
-
   // Main shader source.
-  source += std::string("\
-      uniform SamplerType u_sampler;\n\
-      uniform mat4 u_tex_coord_transform;\n\
-      VARYING TexCoordPrecision vec2 v_uv;\n\
-      void main(void) {\n\
-        TexCoordPrecision vec4 uv = u_tex_coord_transform * vec4(v_uv, 0, 1);\n\
-        FRAGCOLOR = TextureLookup(u_sampler, uv.st);\n");
+  source += std::string(
+      "uniform mediump SamplerType u_sampler;\n"
+      "uniform mat4 u_tex_coord_transform;\n"
+      "VARYING TexCoordPrecision vec2 v_uv;\n"
+      "void main(void) {\n"
+      "  TexCoordPrecision vec4 uv = u_tex_coord_transform * vec4(v_uv, 0, "
+      "1);\n"
+      "  vec4 color = TextureLookup(u_sampler, uv.st);\n"
+      "  FRAGCOLOR = TextureType(color * InnerScaleValue) * "
+      "OuterScaleValue;\n");
 
   // Post-processing to premultiply or un-premultiply alpha.
   if (premultiply_alpha) {
-    source += std::string("        FRAGCOLOR.rgb *= FRAGCOLOR.a;\n");
+    source += std::string("FRAGCOLOR.rgb *= FRAGCOLOR.a;\n");
   }
   if (unpremultiply_alpha) {
-    source += std::string("\
-        if (FRAGCOLOR.a > 0.0)\n\
-          FRAGCOLOR.rgb /= FRAGCOLOR.a;\n");
+    source += std::string(
+        "if (FRAGCOLOR.a > 0.0)\n"
+        "  FRAGCOLOR.rgb /= FRAGCOLOR.a;\n");
   }
 
   // Main function end.
-  source += std::string("      }\n");
+  source += std::string("}\n");
 
   return source;
 }
 
+GLenum getIntermediateFormat(GLenum format) {
+  switch (format) {
+    case GL_LUMINANCE_ALPHA:
+    case GL_LUMINANCE:
+    case GL_ALPHA:
+    case GL_R16F:
+    case GL_R32F:
+    case GL_RG16F:
+    case GL_RG32F:
+    case GL_R11F_G11F_B10F:
+    case GL_RGB9_E5:
+    case GL_RGB16F:
+    case GL_RGB32F:
+    case GL_RGBA16F:
+    case GL_RGBA32F:
+      return GL_RGBA;
+    case GL_SRGB8:
+      return GL_SRGB8_ALPHA8;
+    case GL_RGB8UI:
+      return GL_RGBA8UI;
+    default:
+      return format;
+  }
+}
+
 void CompileShader(GLuint shader, const char* shader_source) {
   glShaderSource(shader, 1, &shader_source, 0);
   glCompileShader(shader);
 #ifndef NDEBUG
   GLint compile_status;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);
-  if (GL_TRUE != compile_status)
+  if (GL_TRUE != compile_status) {
     DLOG(ERROR) << "CopyTextureCHROMIUM: shader compilation failure.";
+    char buffer[1024];
+    GLsizei length = 0;
+    glGetShaderInfoLog(shader, sizeof(buffer), &length, buffer);
+    std::string log(buffer, length);
+  }
 #endif
 }
 
 void DeleteShader(GLuint shader) {
   if (shader)
     glDeleteShader(shader);
 }
 
 bool BindFramebufferTexture2D(GLenum target,
                               GLuint texture_id,
@@ skipping 174 matching lines @@
     GLenum source_target,
     GLuint source_id,
     GLenum source_internal_format,
     GLenum dest_target,
     GLuint dest_id,
     GLenum dest_internal_format,
     GLsizei width,
     GLsizei height,
     bool flip_y,
     bool premultiply_alpha,
-    bool unpremultiply_alpha) {
+    bool unpremultiply_alpha,
+    SupportedCopyMethodByFormat method) {
   bool premultiply_alpha_change = premultiply_alpha ^ unpremultiply_alpha;
-  // GL_INVALID_OPERATION is generated if the currently bound framebuffer's
-  // format does not contain a superset of the components required by the base
-  // format of internalformat.
-  // https://www.khronos.org/opengles/sdk/docs/man/xhtml/glCopyTexImage2D.xml
-  bool source_format_contain_superset_of_dest_format =
-      (source_internal_format == dest_internal_format &&
-       source_internal_format != GL_BGRA_EXT) ||
-      (source_internal_format == GL_RGBA && dest_internal_format == GL_RGB);
+
   // GL_TEXTURE_RECTANGLE_ARB on FBO is supported by OpenGL, not GLES2,
   // so restrict this to GL_TEXTURE_2D.
   if (source_target == GL_TEXTURE_2D && dest_target == GL_TEXTURE_2D &&
-      !flip_y && !premultiply_alpha_change &&
-      source_format_contain_superset_of_dest_format) {
+      !flip_y && !premultiply_alpha_change && method == DIRECT_COPY) {
     DoCopyTexImage2D(decoder,
                      source_target,
                      source_id,
                      dest_target,
                      dest_id,
                      dest_internal_format,
                      width,
                      height,
                      framebuffer_);
     return;
   }
 
+  GLenum adjusted_internal_format = getIntermediateFormat(dest_internal_format);
+  GLuint adjusted_texture = dest_id;
+  if (method == DRAW_AND_COPY) {
+    glGenTextures(1, &adjusted_texture);
+    glBindTexture(dest_target, adjusted_texture);
+    GLenum format = TextureManager::ExtractFormatFromStorageFormat(
+        adjusted_internal_format);
+    GLenum type =
+        TextureManager::ExtractTypeFromStorageFormat(adjusted_internal_format);
+
+    glTexImage2D(dest_target, 0, adjusted_internal_format, width, height, 0,
+                 format, type, nullptr);
+  }
   // Use kIdentityMatrix if no transform passed in.
-  DoCopyTextureWithTransform(decoder, source_target, source_id, dest_target,
-                             dest_id, width, height, flip_y, premultiply_alpha,
-                             unpremultiply_alpha, kIdentityMatrix);
+  DoCopyTextureWithTransform(
+      decoder, source_target, source_id, source_internal_format, dest_target,
+      adjusted_texture, adjusted_internal_format, width, height, flip_y,
+      premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
+
+  if (method == DRAW_AND_COPY) {
+    DoCopyTexImage2D(decoder, dest_target, adjusted_texture, dest_target,
+                     dest_id, dest_internal_format, width, height,
+                     framebuffer_);
+  }
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopySubTexture(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
     GLenum source_internal_format,
     GLenum dest_target,
     GLuint dest_id,
     GLenum dest_internal_format,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
     GLsizei source_height,
     bool flip_y,
     bool premultiply_alpha,
-    bool unpremultiply_alpha) {
+    bool unpremultiply_alpha,
+    SupportedCopyMethodByFormat method) {
   bool use_gl_copy_tex_sub_image_2d = true;
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   // glDrawArrays is faster than glCopyTexSubImage2D on IA Mesa driver,
   // although opposite in Android.
   // TODO(dshwang): After Mesa fixes this issue, remove this hack.
   // https://bugs.freedesktop.org/show_bug.cgi?id=98478 crbug.com/535198
   use_gl_copy_tex_sub_image_2d = false;
 #endif
   bool premultiply_alpha_change = premultiply_alpha ^ unpremultiply_alpha;
-  // GL_INVALID_OPERATION is generated if the currently bound framebuffer's
-  // format does not contain a superset of the components required by the base
-  // format of internalformat.
-  // https://www.khronos.org/opengles/sdk/docs/man/xhtml/glCopyTexImage2D.xml
-  bool source_format_contain_superset_of_dest_format =
-      (source_internal_format == dest_internal_format &&
-       source_internal_format != GL_BGRA_EXT) ||
-      (source_internal_format == GL_RGBA && dest_internal_format == GL_RGB);
+
   // GL_TEXTURE_RECTANGLE_ARB on FBO is supported by OpenGL, not GLES2,
   // so restrict this to GL_TEXTURE_2D.
   if (use_gl_copy_tex_sub_image_2d && source_target == GL_TEXTURE_2D &&
       dest_target == GL_TEXTURE_2D && !flip_y && !premultiply_alpha_change &&
-      source_format_contain_superset_of_dest_format) {
+      method == DIRECT_COPY) {
     DoCopyTexSubImage2D(decoder, source_target, source_id, dest_target, dest_id,
                         xoffset, yoffset, x, y, width, height, framebuffer_);
     return;
   }
 
   DoCopySubTextureWithTransform(
       decoder, source_target, source_id, source_internal_format, dest_target,
       dest_id, dest_internal_format, xoffset, yoffset, x, y, width, height,
       dest_width, dest_height, source_width, source_height, flip_y,
       premultiply_alpha, unpremultiply_alpha, kIdentityMatrix);
@@ skipping 14 matching lines @@
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
     GLsizei source_height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     const GLfloat transform_matrix[16]) {
-  DoCopyTextureInternal(decoder, source_target, source_id, dest_target, dest_id,
-      xoffset, yoffset, x, y, width, height, dest_width, dest_height,
-      source_width, source_height, flip_y, premultiply_alpha,
-      unpremultiply_alpha, transform_matrix);
+  DoCopyTextureInternal(
+      decoder, source_target, source_id, source_internal_format, dest_target,
+      dest_id, dest_internal_format, xoffset, yoffset, x, y, width, height,
+      dest_width, dest_height, source_width, source_height, flip_y,
+      premultiply_alpha, unpremultiply_alpha, transform_matrix);
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTextureWithTransform(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLenum source_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLenum dest_format,
     GLsizei width,
     GLsizei height,
     bool flip_y,
     bool premultiply_alpha,
     bool unpremultiply_alpha,
     const GLfloat transform_matrix[16]) {
   GLsizei dest_width = width;
   GLsizei dest_height = height;
-  DoCopyTextureInternal(decoder, source_target, source_id, dest_target, dest_id,
-                        0, 0, 0, 0, width, height, dest_width, dest_height,
-                        width, height, flip_y, premultiply_alpha,
-                        unpremultiply_alpha, transform_matrix);
+  DoCopyTextureInternal(
+      decoder, source_target, source_id, source_format, dest_target, dest_id,
+      dest_format, 0, 0, 0, 0, width, height, dest_width, dest_height, width,
+      height, flip_y, premultiply_alpha, unpremultiply_alpha, transform_matrix);
 }
 
 void CopyTextureCHROMIUMResourceManager::DoCopyTextureInternal(
     const gles2::GLES2Decoder* decoder,
     GLenum source_target,
     GLuint source_id,
+    GLenum source_format,
     GLenum dest_target,
     GLuint dest_id,
+    GLenum dest_format,
     GLint xoffset,
     GLint yoffset,
     GLint x,
     GLint y,
     GLsizei width,
     GLsizei height,
     GLsizei dest_width,
     GLsizei dest_height,
     GLsizei source_width,
     GLsizei source_height,
@@ skipping 46 matching lines @@
       vertex_shader_ = glCreateShader(GL_VERTEX_SHADER);
       std::string source = GetVertexShaderSource(gl_version_info);
       CompileShader(vertex_shader_, source.c_str());
     }
     glAttachShader(info->program, vertex_shader_);
     GLuint* fragment_shader = &fragment_shaders_[fragment_shader_id];
     if (!*fragment_shader) {
       *fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
       std::string source = GetFragmentShaderSource(
           gl_version_info, premultiply_alpha, unpremultiply_alpha,
-          nv_egl_stream_consumer_external_, source_target);
+          nv_egl_stream_consumer_external_, source_target, source_format,
+          dest_format);
       CompileShader(*fragment_shader, source.c_str());
     }
     glAttachShader(info->program, *fragment_shader);
     glBindAttribLocation(info->program, kVertexPositionAttrib, "a_position");
     glLinkProgram(info->program);
 #ifndef NDEBUG
     GLint linked;
     glGetProgramiv(info->program, GL_LINK_STATUS, &linked);
     if (!linked)
       DLOG(ERROR) << "CopyTextureCHROMIUM: program link failure.";
@@ skipping 130 matching lines @@
   decoder->RestoreTextureUnitBindings(0);
   decoder->RestoreActiveTexture();
   decoder->RestoreProgramBindings();
   decoder->RestoreBufferBindings();
   decoder->RestoreFramebufferBindings();
   decoder->RestoreGlobalState();
 }
 
 }  // namespace gles2
 }  // namespace gpu