Revert of cmaa, gpu: use R8 image texture when GL_NV_image_formats is available.

gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc

 // Copyright 2016 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_apply_framebuffer_attachment_cmaa_intel.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_gl_api_implementation.h"
 #include "ui/gl/gl_version_info.h"
 
 #define SHADER(Src) #Src
 
 namespace gpu {
 namespace gles2 {
 
 ApplyFramebufferAttachmentCMAAINTELResourceManager::
     ApplyFramebufferAttachmentCMAAINTELResourceManager()
     : initialized_(false),
       textures_initialized_(false),
       is_in_gamma_correct_mode_(false),
       supports_usampler_(true),
       supports_r8_image_(true),
+      supports_r8_read_format_(true),
       is_gles31_compatible_(false),
       frame_id_(0),
       width_(0),
       height_(0),
       edges0_shader_(0),
       edges1_shader_(0),
       edges_combine_shader_(0),
       process_and_apply_shader_(0),
       debug_display_edges_shader_(0),
       cmaa_framebuffer_(0),
@@ skipping 13 matching lines @@
     ~ApplyFramebufferAttachmentCMAAINTELResourceManager() {
   Destroy();
 }
 
 void ApplyFramebufferAttachmentCMAAINTELResourceManager::Initialize(
     gles2::GLES2Decoder* decoder) {
   DCHECK(decoder);
   is_gles31_compatible_ =
       decoder->GetGLContext()->GetVersionInfo()->IsAtLeastGLES(3, 1);
 
-  if (is_gles31_compatible_) {
-    supports_r8_image_ =
-        decoder->GetGLContext()->HasExtension("GL_NV_image_formats");
+  // Check if RGBA8UI is supported as an FBO colour target with depth.
+  // If not supported, GLSL needs to convert the data to/from float so there is
+  // a small extra cost.
+  {
+    GLuint rgba8ui_texture = 0, depth_texture = 0;
+    glGenTextures(1, &rgba8ui_texture);
+    glBindTexture(GL_TEXTURE_2D, rgba8ui_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8UI, 4, 4);
 
-    // ES 3.0 requires GL_RGBA8UI is color renderable.
-    supports_usampler_ = true;
-  } else {
-    // CMAA requires GL_ARB_shader_image_load_store for GL, and it requires r8
-    // image texture.
-    DCHECK(decoder->GetGLContext()->HasExtension(
-        "GL_ARB_shader_image_load_store"));
-    supports_r8_image_ = true;
+    glGenTextures(1, &depth_texture);
+    glBindTexture(GL_TEXTURE_2D, depth_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT16, 4, 4);
 
-    // Check if RGBA8UI is supported as an FBO colour target with depth.
-    // If not supported, GLSL needs to convert the data to/from float so there
-    // is a small extra cost.
-    {
-      glActiveTexture(GL_TEXTURE0);
+    // Create the FBO
+    GLuint rgba8ui_framebuffer = 0;
+    glGenFramebuffersEXT(1, &rgba8ui_framebuffer);
+    glBindFramebufferEXT(GL_FRAMEBUFFER, rgba8ui_framebuffer);
 
-      GLuint rgba8ui_texture = 0, depth_texture = 0;
-      glGenTextures(1, &rgba8ui_texture);
-      glBindTexture(GL_TEXTURE_2D, rgba8ui_texture);
-      glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8UI, 4, 4);
+    // Bind to the FBO to test support
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, rgba8ui_texture, 0);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                              GL_TEXTURE_2D, depth_texture, 0);
+    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 
-      glGenTextures(1, &depth_texture);
-      glBindTexture(GL_TEXTURE_2D, depth_texture);
-      glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_DEPTH_COMPONENT16, 4, 4);
+    supports_usampler_ = (status == GL_FRAMEBUFFER_COMPLETE);
 
-      // Create the FBO
-      GLuint rgba8ui_framebuffer = 0;
-      glGenFramebuffersEXT(1, &rgba8ui_framebuffer);
-      glBindFramebufferEXT(GL_FRAMEBUFFER, rgba8ui_framebuffer);
+    glDeleteFramebuffersEXT(1, &rgba8ui_framebuffer);
+    glDeleteTextures(1, &rgba8ui_texture);
+    glDeleteTextures(1, &depth_texture);
+  }
 
-      // Bind to the FBO to test support
-      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                                GL_TEXTURE_2D, rgba8ui_texture, 0);
-      glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                                GL_TEXTURE_2D, depth_texture, 0);
-      GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
+  // Check to see if R8 images are supported
+  // If not supported, images are bound as R32F for write targets, not R8.
+  {
+    GLuint r8_texture = 0;
+    glGenTextures(1, &r8_texture);
+    glBindTexture(GL_TEXTURE_2D, r8_texture);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, GL_R8, 4, 4);
 
-      supports_usampler_ = (status == GL_FRAMEBUFFER_COMPLETE);
+    glGetError();  // reset all previous errors
+    glBindImageTextureEXT(0, r8_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R8);
+    if (glGetError() != GL_NO_ERROR)
+      supports_r8_image_ = false;
 
-      glDeleteFramebuffersEXT(1, &rgba8ui_framebuffer);
-      glDeleteTextures(1, &rgba8ui_texture);
-      glDeleteTextures(1, &depth_texture);
+    glDeleteTextures(1, &r8_texture);
+  }
 
-      decoder->RestoreTextureUnitBindings(0);
-      decoder->RestoreActiveTexture();
-      decoder->RestoreFramebufferBindings();
+  // Check if R8 GLSL read formats are supported.
+  // If not supported, r32f is used instead.
+  {
+    const char shader_source[] =
+        SHADER(layout(r8) restrict writeonly uniform highp image2D g_r8Image;
+               void main() {
+                 imageStore(g_r8Image, ivec2(0, 0), vec4(1.0, 0.0, 0.0, 0.0));
+               });
+
+    GLuint shader = CreateShader(GL_FRAGMENT_SHADER, "", shader_source);
+    supports_r8_read_format_ = (shader != 0);
+    if (shader != 0) {
+      glDeleteShader(shader);
     }
   }
 
   VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
           << "Supports USampler is " << (supports_usampler_ ? "true" : "false");
   VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
           << "Supports R8 Images is "
           << (supports_r8_image_ ? "true" : "false");
+  VLOG(1) << "ApplyFramebufferAttachmentCMAAINTEL: "
+          << "Supports R8 Read Format is "
+          << (supports_r8_read_format_ ? "true" : "false");
 
   // Create the shaders
   std::ostringstream defines, edge1, edge2, combineEdges, blur, displayEdges,
       cmaa_frag;
 
   cmaa_frag << cmaa_frag_s1_ << cmaa_frag_s2_;
   std::string cmaa_frag_string = cmaa_frag.str();
   const char* cmaa_frag_c_str = cmaa_frag_string.c_str();
 
   if (supports_usampler_) {
     defines << "#define SUPPORTS_USAMPLER2D\n";
   }
 
   if (is_in_gamma_correct_mode_) {
     defines << "#define IN_GAMMA_CORRECT_MODE\n";
   }
 
-  if (supports_r8_image_) {
+  if (supports_r8_read_format_) {
     defines << "#define EDGE_READ_FORMAT r8\n";
   } else {
     defines << "#define EDGE_READ_FORMAT r32f\n";
   }
 
   displayEdges << defines.str() << "#define DISPLAY_EDGES\n";
   debug_display_edges_shader_ =
       CreateProgram(displayEdges.str().c_str(), vert_str_, cmaa_frag_c_str);
 
   edge1 << defines.str() << "#define DETECT_EDGES1\n";
@@ skipping 460 matching lines @@
 }
 
 GLuint ApplyFramebufferAttachmentCMAAINTELResourceManager::CreateShader(
     GLenum type,
     const char* defines,
     const char* source) {
   GLuint shader = glCreateShader(type);
 
   const char header_es31[] =
       "#version 310 es                                                      \n";
-  const char header_gl130[] =
+  const char header_gl30[] =
       "#version 130                                                         \n"
       "#extension GL_ARB_shading_language_420pack  : require                \n"
       "#extension GL_ARB_texture_gather            : require                \n"
       "#extension GL_ARB_explicit_uniform_location : require                \n"
       "#extension GL_ARB_explicit_attrib_location  : require                \n"
       "#extension GL_ARB_shader_image_load_store   : require                \n";
 
-  std::ostringstream header;
+  const char* header = NULL;
   if (is_gles31_compatible_) {
-    header << header_es31;
-    if (supports_r8_image_)
-      header << "#extension GL_NV_image_formats : require\n";
+    header = header_es31;
   } else {
-    header << header_gl130;
+    header = header_gl30;
   }
 
-  const char* source_array[4] = {header.str().c_str(), defines, "\n", source};
+  const char* source_array[4] = {header, defines, "\n", source};
   glShaderSource(shader, 4, source_array, NULL);
 
   glCompileShader(shader);
 
   GLint compile_result;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_result);
   if (compile_result == 0) {
 #if DCHECK_IS_ON()
     GLint info_log_length;
     glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);
@@ skipping 1224 matching lines @@
     \n#endif\n
     \n#if defined DISPLAY_EDGES\n
       DisplayEdges();
     \n#endif\n
     }
   );
 /* clang-format on */
 
 }  // namespace gles2
 }  // namespace gpu