Make LUTs independent of YUV in cc shaders

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 417 matching lines @@
       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");
-      if (color_conversion_mode_ == COLOR_CONVERSION_MODE_LUT_FROM_YUV) {
-        uniforms.push_back("lut_texture");
-        uniforms.push_back("lut_size");
-        uniforms.push_back("resource_multiplier");
-        uniforms.push_back("resource_offset");
-      } else {
-        uniforms.push_back("yuv_matrix");
-        uniforms.push_back("yuv_adj");
-      }
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       uniforms.push_back("color");
       break;
   }
 
+  if (has_resource_offset_) {
+    uniforms.push_back("resource_multiplier");
+    uniforms.push_back("resource_offset");
+  }
+
+  if (has_lut_) {
+    uniforms.push_back("lut_texture");
+    uniforms.push_back("lut_size");
+  }
+
   locations.resize(uniforms.size());
 
   GetProgramUniformLocations(context, program, uniforms.size(), uniforms.data(),
                              locations.data(), base_uniform_index);
 
   size_t index = 0;
   if (has_blend_mode()) {
     backdrop_location_ = locations[index++];
     original_backdrop_location_ = locations[index++];
     backdrop_rect_location_ = locations[index++];
@@ skipping 22 matching lines @@
       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++];
-      if (color_conversion_mode_ == COLOR_CONVERSION_MODE_LUT_FROM_YUV) {
-        lut_texture_location_ = locations[index++];
-        lut_size_location_ = locations[index++];
-        resource_multiplier_location_ = locations[index++];
-        resource_offset_location_ = locations[index++];
-      } else {
-        yuv_matrix_location_ = locations[index++];
-        yuv_adj_location_ = locations[index++];
-      }
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       color_location_ = locations[index++];
       break;
   }
+  if (has_resource_offset_) {
+    resource_multiplier_location_ = locations[index++];
+    resource_offset_location_ = locations[index++];
+  }
+  if (has_lut_) {
+    lut_texture_location_ = locations[index++];
+    lut_size_location_ = locations[index++];
+  }
+
   DCHECK_EQ(index, locations.size());
 }
 
 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;
@@ skipping 322 matching lines @@
       }
       break;
     case INPUT_COLOR_SOURCE_YUV_TEXTURES:
       // Compute the clamped texture coordinates for the YA and UV textures.
       HDR("uniform SamplerType y_texture;");
       SRC("// YUV texture lookup and conversion to RGB.");
       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));");
-      // Read the Y and UV or U and V textures into |yuv|.
-      SRC("vec3 yuv;");
-      SRC("yuv.x = TextureLookup(y_texture, ya_clamped).x;");
+      // Read the Y and UV or U and V textures into |texColor|.
+      // texColor will be converted to RGB using a lut or matrix below.
+      SRC("vec4 texColor;");
+      SRC("texColor.a = 1.0;");
+      SRC("texColor.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;");
+        SRC("texColor.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;");
+        SRC("texColor.y = TextureLookup(u_texture, uv_clamped).x;");
+        SRC("texColor.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;");
-      // Convert YUV to RGB.
-      if (color_conversion_mode_ == COLOR_CONVERSION_MODE_LUT_FROM_YUV) {
-        HDR("uniform sampler2D lut_texture;");
-        HDR("uniform float lut_size;");
-        HDR("uniform float resource_multiplier;");
-        HDR("uniform float resource_offset;");
-        HDR("vec4 LUT(sampler2D sampler, vec3 pos, float size) {");
-        HDR("  pos *= size - 1.0;");
-        HDR("  // Select layer");
-        HDR("  float layer = min(floor(pos.z), size - 2.0);");
-        HDR("  // Compress the xy coordinates so they stay within");
-        HDR("  // [0.5 .. 31.5] / N (assuming a LUT size of 17^3)");
-        HDR("  pos.xy = (pos.xy + vec2(0.5)) / size;");
-        HDR("  pos.y = (pos.y + layer) / size;");
-        HDR("  return mix(texture2D(sampler, pos.xy),");
-        HDR("             texture2D(sampler, pos.xy + vec2(0, 1.0 / size)),");
-        HDR("             pos.z - layer);");
-        HDR("}");
-        HDR("vec3 yuv2rgb(vec3 yuv) {");
-        HDR("  yuv = (yuv - vec3(resource_offset)) * resource_multiplier;");
-        HDR("  return LUT(lut_texture, yuv, lut_size).xyz;");
-        HDR("}");
-      } else {
-        HDR("uniform mat3 yuv_matrix;");
-        HDR("uniform vec3 yuv_adj;");
-        HDR("vec3 yuv2rgb(vec3 yuv) {");
-        HDR("  return yuv_matrix * (yuv + yuv_adj);");
-        HDR("}");
-      }
       HDR("varying TexCoordPrecision vec2 v_yaTexCoord;");
       HDR("varying TexCoordPrecision vec2 v_uvTexCoord;");
-      SRC("vec4 texColor = vec4(yuv2rgb(yuv), 1.0);");
+      // Check that we have something that will convert the YUV to RGB later.
+      DCHECK(has_lut_ || has_color_matrix_);
       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;
   }
+

[ccameron, 2017/02/02 23:38:07]

I'm working on a patch to merge (resource_multiplier and resource_offset) with
(yuv_matrix| and yuv_adj). I'd like to try to merge that in, since I think it'll
make adding your easier.

+  if (has_resource_offset_) {
+    HDR("uniform float resource_multiplier;");
+    HDR("uniform float resource_offset;");
+    SRC("texColor.rgb = (texColor.rgb - vec3(resource_offset)) * ");
+    SRC("    resource_multiplier;");
+  }
+
   // Apply the color matrix to texColor.
   if (has_color_matrix_) {
     HDR("uniform mat4 colorMatrix;");
     HDR("uniform vec4 colorOffset;");
     SRC("// Apply color matrix");
     SRC("float nonZeroAlpha = max(texColor.a, 0.00001);");
     SRC("texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);");
     SRC("texColor = colorMatrix * texColor + colorOffset;");
     SRC("texColor.rgb *= texColor.a;");
     SRC("texColor = clamp(texColor, 0.0, 1.0);");
   }
 
+  if (has_lut_) {
+    HDR("uniform sampler2D lut_texture;");
+    HDR("uniform float lut_size;");
+    HDR("vec4 LUT(sampler2D sampler, vec3 pos, float size) {");
+    HDR("  pos *= size - 1.0;");
+    HDR("  // Select layer");
+    HDR("  float layer = min(floor(pos.z), size - 2.0);");
+    HDR("  // Compress the xy coordinates so they stay within");
+    HDR("  // [0.5 .. 31.5] / N (assuming a LUT size of 17^3)");
+    HDR("  pos.xy = (pos.xy + vec2(0.5)) / size;");
+    HDR("  pos.y = (pos.y + layer) / size;");
+    HDR("  return mix(texture2D(sampler, pos.xy),");
+    HDR("             texture2D(sampler, pos.xy + vec2(0, 1.0 / size)),");
+    HDR("             pos.z - layer);");
+    HDR("}");
+    SRC("texColor.xyz = LUT(lut_texture, texColor.xyz, lut_size).xyz;");
+  }
+
   // Read the mask texture.
   if (mask_mode_ != NO_MASK) {
     HDR("uniform SamplerType s_mask;");
     HDR("uniform vec2 maskTexCoordScale;");
     HDR("uniform vec2 maskTexCoordOffset;");
     SRC("// Read the mask");
     SRC("TexCoordPrecision vec2 maskTexCoord =");
     SRC("    vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,");
     SRC("         maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);");
     SRC("vec4 maskColor = TextureLookup(s_mask, maskTexCoord);");
@@ skipping 71 matching lines @@
       else
         SRC("gl_FragColor = ApplyBlendMode(texColor, 0.0);");
       break;
   }
   source += "}\n";
 
   return header + source;
 }
 
 }  // namespace cc