color: Add support for shader generation

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>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/static_geometry_binding.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "ui/gfx/color_transform.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 
 template <size_t size>
 std::string StripLambda(const char(&shader)[size]) {
   // Must contain at least "[]() {}" and trailing null (included in size).
   static_assert(size >= 8,
                 "String passed to StripLambda must be at least 8 characters");
   DCHECK_EQ(strncmp("[]() {", shader, 6), 0);
   DCHECK_EQ(shader[size - 2], '}');
@@ skipping 406 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");
-      uniforms.push_back("yuv_and_resource_matrix");
+      uniforms.push_back("resource_multiplier");
+      uniforms.push_back("resource_offset");
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       uniforms.push_back("color");
       break;
   }
   if (color_conversion_mode_ == COLOR_CONVERSION_MODE_LUT) {
     uniforms.push_back("lut_texture");
     uniforms.push_back("lut_size");
   }
 
@@ skipping 32 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++];
-      yuv_and_resource_matrix_location_ = locations[index++];
+      resource_multiplier_location_ = locations[index++];
+      resource_offset_location_ = locations[index++];
       break;
     case INPUT_COLOR_SOURCE_UNIFORM:
       color_location_ = locations[index++];
       break;
   }
   if (color_conversion_mode_ == COLOR_CONVERSION_MODE_LUT) {
     lut_texture_location_ = locations[index++];
     lut_size_location_ = locations[index++];
   }
   DCHECK_EQ(index, locations.size());
@@ skipping 349 matching lines @@
       if (uv_texture_mode_ == UV_TEXTURE_MODE_U_V) {
         HDR("uniform SamplerType u_texture;");
         HDR("uniform SamplerType v_texture;");
         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;");
-      HDR("uniform mat4 yuv_and_resource_matrix;");
+      HDR("uniform float resource_multiplier;");
+      HDR("uniform float resource_offset;");
       HDR("varying TexCoordPrecision vec2 v_yaTexCoord;");
       HDR("varying TexCoordPrecision vec2 v_uvTexCoord;");
-      SRC("texColor = yuv_and_resource_matrix * texColor;");
+      SRC("texColor.xyz -= vec3(resource_offset);");
+      SRC("texColor.xyz *= resource_multiplier;");
       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 LUT based color conversion.
-  if (color_conversion_mode_ == COLOR_CONVERSION_MODE_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(LutLookup(sampler, pos.xy),");
-    HDR("             LutLookup(sampler, pos.xy + vec2(0, 1.0 / size)),");
-    HDR("             pos.z - layer);");
-    HDR("}");
-    SRC("texColor.xyz = LUT(lut_texture, texColor.xyz, lut_size).xyz;");
+  switch (color_conversion_mode_) {
+    case COLOR_CONVERSION_MODE_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(LutLookup(sampler, pos.xy),");
+      HDR("             LutLookup(sampler, pos.xy + vec2(0, 1.0 / size)),");
+      HDR("             pos.z - layer);");
+      HDR("}");
+      SRC("texColor.rgb = LUT(lut_texture, texColor.xyz, lut_size).xyz;");
+      break;
+    case COLOR_CONVERSION_MODE_SHADER:
+      header += color_transform_->GetShaderSource();
+      SRC("texColor.rgb = DoColorConversion(texColor.xyz);");
+      break;
+    case COLOR_CONVERSION_MODE_NONE:
+      break;
   }
 
   // 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;");
@@ skipping 85 matching lines @@
       else
         SRC("gl_FragColor = ApplyBlendMode(texColor, 0.0);");
       break;
   }
   source += "}\n";
 
   return header + source;
 }
 
 }  // namespace cc