The great shader refactor: Merge YUV shader class

cc/output/shader.cc

 // Copyright 2011 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 "cc/output/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 148 matching lines @@
                                             int* highp_threshold_cache,
                                             int highp_threshold_min,
                                             const gfx::Size& max_size) {
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache,
                                    highp_threshold_min,
                                    max_size.width(),
                                    max_size.height());
 }
 
-VertexShaderBase::VertexShaderBase() {}
+VertexShader::VertexShader() {}
 
-void VertexShaderBase::Init(GLES2Interface* context,
-                            unsigned program,
-                            int* base_uniform_index) {
+void VertexShader::Init(GLES2Interface* context,
+                        unsigned program,
+                        int* base_uniform_index) {
   std::vector<const char*> uniforms;
   std::vector<int> locations;
 
   switch (tex_coord_transform_) {
     case TEX_COORD_TRANSFORM_NONE:
       break;
     case TEX_COORD_TRANSFORM_VEC4:
     case TEX_COORD_TRANSFORM_TRANSLATED_VEC4:
       uniforms.push_back("vertexTexTransform");
       break;
@@ skipping 46 matching lines @@
   if (has_vertex_opacity_)
     vertex_opacity_location_ = locations[index++];
   if (aa_mode_ == USE_AA) {
     viewport_location_ = locations[index++];
     edge_location_ = locations[index++];
   }
   if (position_source_ == POSITION_SOURCE_ATTRIBUTE_INDEXED_UNIFORM)
     quad_location_ = locations[index++];
 }
 
-std::string VertexShaderBase::GetShaderString() const {
+std::string VertexShader::GetShaderString() const {
   // We unconditionally use highp in the vertex shader since
   // we are unlikely to be vertex shader bound when drawing large quads.
   // Also, some vertex shaders mutate the texture coordinate in such a
   // way that the effective precision might be lower than expected.
   std::string header = "#define TexCoordPrecision highp\n";
   std::string source = "void main() {\n";
 
   // Define the size of quads for attribute indexed uniform arrays.
   if (use_uniform_arrays_) {
     header += base::StringPrintf("#define NUM_QUADS %d\n",
@@ skipping 124 matching lines @@
   if (has_dummy_variables_) {
     HDR("uniform TexCoordPrecision vec2 dummy_uniform;");
     HDR("varying TexCoordPrecision vec2 dummy_varying;");
     SRC("dummy_varying = dummy_uniform;");
   }
 
   source += "}\n";
   return header + source;
 }
 
-FragmentShaderBase::FragmentShaderBase() {}
+FragmentShader::FragmentShader() {}
 
-std::string FragmentShaderBase::GetShaderString() const {
+std::string FragmentShader::GetShaderString() const {
+  // TODO(ccameron): Merge YUV shaders into the main shader generator.
+  std::string source;
+  if (input_color_type_ == INPUT_COLOR_SOURCE_YUV_TEXTURES)
+    source = GetShaderStringYUVVideo();
+  else
+    source = GetShaderSource();
+
   TexCoordPrecision precision = tex_coord_precision_;
   // The AA shader values will use TexCoordPrecision.
   if (aa_mode_ == USE_AA && precision == TEX_COORD_PRECISION_NA)
     precision = TEX_COORD_PRECISION_MEDIUM;
   return SetFragmentTexCoordPrecision(
-      precision, SetFragmentSamplerType(
-                     sampler_type_, SetBlendModeFunctions(GetShaderSource())));
+      precision,
+      SetFragmentSamplerType(sampler_type_, SetBlendModeFunctions(source)));
 }
 
-void FragmentShaderBase::Init(GLES2Interface* context,
-                              unsigned program,
-                              int* base_uniform_index) {
+void FragmentShader::Init(GLES2Interface* context,
+                          unsigned program,
+                          int* base_uniform_index) {
+  // TODO(ccameron): Merge YUV shaders into the main shader generator.
+  if (input_color_type_ == INPUT_COLOR_SOURCE_YUV_TEXTURES) {
+    InitYUVVideo(context, program, base_uniform_index);
+    return;
+  }
+
   std::vector<const char*> uniforms;
   std::vector<int> locations;
   if (has_blend_mode()) {
     uniforms.push_back("s_backdropTexture");
     uniforms.push_back("s_originalBackdropTexture");
     uniforms.push_back("backdropRect");
   }
   if (mask_mode_ != NO_MASK) {
     uniforms.push_back("s_mask");
     uniforms.push_back("maskTexCoordScale");
     uniforms.push_back("maskTexCoordOffset");
   }
   if (has_color_matrix_) {
     uniforms.push_back("colorMatrix");
     uniforms.push_back("colorOffset");
   }
   if (has_uniform_alpha_)
     uniforms.push_back("alpha");
   if (has_background_color_)
     uniforms.push_back("background_color");
   switch (input_color_type_) {
     case INPUT_COLOR_SOURCE_RGBA_TEXTURE:
       uniforms.push_back("s_texture");
       if (has_rgba_fragment_tex_transform_)
         uniforms.push_back("fragmentTexTransform");
       break;
+    case INPUT_COLOR_SOURCE_YUV_TEXTURES:
+      NOTREACHED();
+      break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       uniforms.push_back("color");
       break;
   }
 
   locations.resize(uniforms.size());
 
   GetProgramUniformLocations(context, program, uniforms.size(), uniforms.data(),
                              locations.data(), base_uniform_index);
 
@@ skipping 15 matching lines @@
   if (has_uniform_alpha_)
     alpha_location_ = locations[index++];
   if (has_background_color_)
     background_color_location_ = locations[index++];
   switch (input_color_type_) {
     case INPUT_COLOR_SOURCE_RGBA_TEXTURE:
       sampler_location_ = locations[index++];
       if (has_rgba_fragment_tex_transform_)
         fragment_tex_transform_location_ = locations[index++];
       break;
+    case INPUT_COLOR_SOURCE_YUV_TEXTURES:
+      NOTREACHED();
+      break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       color_location_ = locations[index++];
       break;
   }
   DCHECK_EQ(index, locations.size());
 }
 
-std::string FragmentShaderBase::SetBlendModeFunctions(
+std::string FragmentShader::SetBlendModeFunctions(
     const std::string& shader_string) const {
   if (shader_string.find("ApplyBlendMode") == std::string::npos)
     return shader_string;
 
   if (!has_blend_mode()) {
     return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
@@ skipping 31 matching lines @@
       vec4 dst = GetBackdropColor(mask);
       return Blend(src, dst);
     }
   });
 
   return "precision mediump float;" + GetHelperFunctions() +
          GetBlendFunction() + kUniforms + mixFunction +
          kFunctionApplyBlendMode + shader_string;
 }
 
-std::string FragmentShaderBase::GetHelperFunctions() const {
+std::string FragmentShader::GetHelperFunctions() const {
   static const std::string kFunctionHardLight = SHADER0([]() {
     vec3 hardLight(vec4 src, vec4 dst) {
       vec3 result;
       result.r =
           (2.0 * src.r <= src.a)
               ? (2.0 * src.r * dst.r)
               : (src.a * dst.a - 2.0 * (dst.a - dst.r) * (src.a - src.r));
       result.g =
           (2.0 * src.g <= src.a)
               ? (2.0 * src.g * dst.g)
@@ skipping 140 matching lines @@
     case BLEND_MODE_SATURATION:
       return kFunctionLum + kFunctionSat;
     case BLEND_MODE_COLOR:
     case BLEND_MODE_LUMINOSITY:
       return kFunctionLum;
     default:
       return std::string();
   }
 }
 
-std::string FragmentShaderBase::GetBlendFunction() const {
+std::string FragmentShader::GetBlendFunction() const {
   return "vec4 Blend(vec4 src, vec4 dst) {"
          "    vec4 result;"
          "    result.a = src.a + (1.0 - src.a) * dst.a;" +
          GetBlendFunctionBodyForRGB() +
          "    return result;"
          "}";
 }
 
-std::string FragmentShaderBase::GetBlendFunctionBodyForRGB() const {
+std::string FragmentShader::GetBlendFunctionBodyForRGB() const {
   switch (blend_mode_) {
     case BLEND_MODE_NORMAL:
       return "result.rgb = src.rgb + dst.rgb * (1.0 - src.a);";
     case BLEND_MODE_SCREEN:
       return "result.rgb = src.rgb + (1.0 - src.rgb) * dst.rgb;";
     case BLEND_MODE_LIGHTEN:
       return "result.rgb = max((1.0 - src.a) * dst.rgb + src.rgb,"
              "                 (1.0 - dst.a) * src.rgb + dst.rgb);";
     case BLEND_MODE_OVERLAY:
       return "result.rgb = hardLight(dst, src);";
@@ skipping 52 matching lines @@
              "result.rgb = set_luminance(dst.rgb * src.a,"
              "                           srcDstAlpha.a,"
              "                           srcDstAlpha.rgb);"
              "result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;";
     case BLEND_MODE_NONE:
       NOTREACHED();
   }
   return "result = vec4(1.0, 0.0, 0.0, 1.0);";
 }
 
-std::string FragmentShaderBase::GetShaderSource() const {
+std::string FragmentShader::GetShaderSource() const {
   std::string header = "precision mediump float;\n";
   std::string source = "void main() {\n";
 
   // Read the input into vec4 texColor.
   switch (input_color_type_) {
     case INPUT_COLOR_SOURCE_RGBA_TEXTURE:
       if (ignore_sampler_type_)
         HDR("uniform sampler2D s_texture;");
       else
         HDR("uniform SamplerType s_texture;");
       HDR("varying TexCoordPrecision vec2 v_texCoord;");
       if (has_rgba_fragment_tex_transform_) {
         HDR("uniform TexCoordPrecision vec4 fragmentTexTransform;");
         SRC("// Transformed texture lookup");
         SRC("TexCoordPrecision vec2 texCoord =");
         SRC("    clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +");
         SRC("   fragmentTexTransform.xy;");
         SRC("vec4 texColor = TextureLookup(s_texture, texCoord);");
         DCHECK(!ignore_sampler_type_);
       } else {
         SRC("// Texture lookup");
         if (ignore_sampler_type_)
           SRC("vec4 texColor = texture2D(s_texture, v_texCoord);");
         else
           SRC("vec4 texColor = TextureLookup(s_texture, v_texCoord);");
       }
       break;
+    case INPUT_COLOR_SOURCE_YUV_TEXTURES:
+      NOTREACHED();
+      break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       DCHECK(!ignore_sampler_type_);
       DCHECK(!has_rgba_fragment_tex_transform_);
       HDR("uniform vec4 color;");
       SRC("// Uniform color");
       SRC("vec4 texColor = color;");
       break;
   }
   // Apply the color matrix to texColor.
   if (has_color_matrix_) {
@@ skipping 88 matching lines @@
         SRC("gl_FragColor = ApplyBlendMode(texColor, maskColor.w);");
       else
         SRC("gl_FragColor = ApplyBlendMode(texColor, 0.0);");
       break;
   }
   source += "}\n";
 
   return header + source;
 }
 
-FragmentShaderYUVVideo::FragmentShaderYUVVideo() {}
-
-void FragmentShaderYUVVideo::Init(GLES2Interface* context,
+void FragmentShader::InitYUVVideo(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "uv_texture",
       "a_texture",
       "lut_texture",
       "resource_multiplier",
@@ skipping 28 matching lines @@
     resource_offset_location_ = locations[7];
   } else {
     yuv_matrix_location_ = locations[8];
     yuv_adj_location_ = locations[9];
   }
   alpha_location_ = locations[10];
   ya_clamp_rect_location_ = locations[11];
   uv_clamp_rect_location_ = locations[12];
 }
 
-std::string FragmentShaderYUVVideo::GetShaderSource() const {
+std::string FragmentShader::GetShaderStringYUVVideo() const {
   std::string head = SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_yaTexCoord;
     varying TexCoordPrecision vec2 v_uvTexCoord;
     uniform SamplerType y_texture;
     uniform float alpha;
     uniform vec4 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
@@ skipping 70 matching lines @@
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return head + functions;
 }
 
 }  // namespace cc