The great shader refactor: Add YUV support to the uber shader

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 369 matching lines @@
 
   source += "}\n";
   return header + source;
 }
 
 FragmentShader::FragmentShader() {}
 
 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)
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_2D_LUT_AS_3D_FROM_YUV)
     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(source)));
 }
 
 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) {
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_2D_LUT_AS_3D_FROM_YUV) {
     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");
@@ skipping 11 matching lines @@
     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();
+      uniforms.push_back("y_texture");
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_UV)
+        uniforms.push_back("uv_texture");
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
+        uniforms.push_back("u_texture");
+        uniforms.push_back("v_texture");
+      }
+      if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE)
+        uniforms.push_back("a_texture");
+      uniforms.push_back("ya_clamp_rect");
+      uniforms.push_back("uv_clamp_rect");
+      uniforms.push_back("yuv_matrix");
+      uniforms.push_back("yuv_adj");
       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 17 matching lines @@
     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();
+      y_texture_location_ = locations[index++];
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_UV)
+        uv_texture_location_ = locations[index++];
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
+        u_texture_location_ = locations[index++];
+        v_texture_location_ = locations[index++];
+      }
+      if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE)
+        a_texture_location_ = locations[index++];
+      ya_clamp_rect_location_ = locations[index++];
+      uv_clamp_rect_location_ = locations[index++];
+      yuv_matrix_location_ = locations[index++];
+      yuv_adj_location_ = locations[index++];
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       color_location_ = locations[index++];
       break;
   }
   DCHECK_EQ(index, locations.size());
 }
 
 std::string FragmentShader::SetBlendModeFunctions(
     const std::string& shader_string) const {
@@ skipping 312 matching lines @@
         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();
+      HDR("uniform SamplerType y_texture;");
+      SRC("vec2 ya_clamped =");
+      SRC("    max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));");
+      SRC("vec2 uv_clamped =");
+      SRC("    max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));");
+      SRC("vec3 yuv;");
+      SRC("yuv.x = TextureLookup(y_texture, ya_clamped).x;");
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_UV) {
+        HDR("uniform SamplerType uv_texture;");
+        SRC("yuv.yz = TextureLookup(uv_texture, uv_clamped).xy;");
+      }
+      if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
+        HDR("uniform SamplerType u_texture;");
+        HDR("uniform SamplerType v_texture;");
+        SRC("yuv.y = TextureLookup(u_texture, uv_clamped).x;");
+        SRC("yuv.z = TextureLookup(v_texture, uv_clamped).x;");
+      }
+      if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE)
+        HDR("uniform SamplerType a_texture;");
+      HDR("uniform vec4 ya_clamp_rect;");
+      HDR("uniform vec4 uv_clamp_rect;");
+      HDR("uniform mat3 yuv_matrix;");
+      HDR("uniform vec3 yuv_adj;");
+      HDR("varying TexCoordPrecision vec2 v_yaTexCoord;");
+      HDR("varying TexCoordPrecision vec2 v_uvTexCoord;");
+      SRC("vec4 texColor = vec4(yuv_matrix * (yuv + yuv_adj), 1.0);");
       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.
@@ skipping 62 matching lines @@
     SRC("// Apply alpha from uniform, varying, aa, and mask.");
     std::string line = "  texColor = texColor";
     if (has_varying_alpha_)
       line += " * v_alpha";
     if (has_uniform_alpha_)
       line += " * alpha";
     if (aa_mode_ == USE_AA)
       line += " * aa";
     if (mask_mode_ != NO_MASK)
       line += " * maskColor.a";
+    if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE)
+      line += " * TextureLookup(a_texture, ya_clamped).x";
     line += ";\n";
     source += line;
   }
 
   // Write the fragment color.
   SRC("// Write the fragment color");
   switch (frag_color_mode_) {
     case FRAG_COLOR_MODE_DEFAULT:
       DCHECK_EQ(blend_mode_, BLEND_MODE_NONE);
       SRC("gl_FragColor = texColor;");
@@ skipping 34 matching lines @@
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
-  if (!use_nv12_) {
+  if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
     u_texture_location_ = locations[1];
     v_texture_location_ = locations[2];
-  } else {
+  }
+  if (uv_texture_mode_ == UV_TEXTURE_MODE_UV) {
     uv_texture_location_ = locations[3];
   }
-  if (use_alpha_texture_) {
+  if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE) {
     a_texture_location_ = locations[4];
   }
-  if (use_color_lut_) {
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_2D_LUT_AS_3D_FROM_YUV) {
     lut_texture_location_ = locations[5];
     resource_multiplier_location_ = locations[6];
     resource_offset_location_ = locations[7];
-  } else {
+  }
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_NONE) {
     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 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;
   });
 
   std::string functions = "";
-  if (use_nv12_) {
+  if (uv_texture_mode_ == UV_TEXTURE_MODE_UV) {
     head += "  uniform SamplerType uv_texture;\n";
     functions += SHADER0([]() {
       vec2 GetUV(vec2 uv_clamped) {
         return TextureLookup(uv_texture, uv_clamped).xy;
       }
     });
-  } else {
+  }
+  if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
     head += "  uniform SamplerType u_texture;\n";
     head += "  uniform SamplerType v_texture;\n";
     functions += SHADER0([]() {
       vec2 GetUV(vec2 uv_clamped) {
         return vec2(TextureLookup(u_texture, uv_clamped).x,
                     TextureLookup(v_texture, uv_clamped).x);
       }
     });
   }
 
-  if (use_alpha_texture_) {
+  if (yuv_alpha_texture_mode_ == YUV_HAS_ALPHA_TEXTURE) {
     head += "  uniform SamplerType a_texture;\n";
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) {
         return alpha * TextureLookup(a_texture, ya_clamped).x;
       }
     });
   } else {
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) { return alpha; }
     });
   }
 
-  if (use_color_lut_) {
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_2D_LUT_AS_3D_FROM_YUV) {
     head += "  uniform sampler2D lut_texture;\n";
     head += "  uniform float resource_multiplier;\n";
     head += "  uniform float resource_offset;\n";
     functions += SHADER0([]() {
       vec4 LUT(sampler2D sampler, vec3 pos, float size) {
         pos *= size - 1.0;
         // Select layer
         float layer = min(floor(pos.z), size - 2.0);
         // Compress the xy coordinates so they stay within
         // [0.5 .. 31.5] / 17 (assuming a LUT size of 17^3)
         pos.xy = (pos.xy + vec2(0.5)) / size;
         pos.y = (pos.y + layer) / size;
         return mix(texture2D(sampler, pos.xy),
                    texture2D(sampler, pos.xy + vec2(0, 1.0 / size)),
                    pos.z - layer);
       }
 
       vec3 yuv2rgb(vec3 yuv) {
         yuv = (yuv - vec3(resource_offset)) * resource_multiplier;
         return LUT(lut_texture, yuv, 17.0).xyz;
       }
     });
-  } else {
+  }
+  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_NONE) {
     head += "  uniform mat3 yuv_matrix;\n";
     head += "  uniform vec3 yuv_adj;\n";
     functions += SHADER0([]() {
       vec3 yuv2rgb(vec3 yuv) { return yuv_matrix * (yuv + yuv_adj); }
     });
   }
 
   functions += SHADER0([]() {
     void main() {
       vec2 ya_clamped =
           max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
       float y_raw = TextureLookup(y_texture, ya_clamped).x;
       vec2 uv_clamped =
           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