Make LUTs independent of YUV in cc shaders

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 2163 matching lines @@
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
   YUVAlphaTextureMode alpha_texture_mode = quad->a_plane_resource_id()
                                                ? YUV_HAS_ALPHA_TEXTURE
                                                : YUV_NO_ALPHA_TEXTURE;
   UVTextureMode uv_texture_mode =
       quad->v_plane_resource_id() == quad->u_plane_resource_id()
           ? UV_TEXTURE_MODE_UV
           : UV_TEXTURE_MODE_U_V;
-  ColorConversionMode color_conversion_mode =
-      base::FeatureList::IsEnabled(media::kVideoColorManagement)
-          ? COLOR_CONVERSION_MODE_LUT_FROM_YUV
-          : COLOR_CONVERSION_MODE_NONE;
+  bool use_lut = base::FeatureList::IsEnabled(media::kVideoColorManagement);
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, quad->y_plane_resource_id(), GL_TEXTURE1, GL_LINEAR);
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, quad->u_plane_resource_id(), GL_TEXTURE2, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), u_plane_lock.target());
   // TODO(jbauman): Use base::Optional when available.
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> v_plane_lock;
 
   if (uv_texture_mode == UV_TEXTURE_MODE_U_V) {
     v_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->v_plane_resource_id(), GL_TEXTURE3,
         GL_LINEAR));
     DCHECK_EQ(y_plane_lock.target(), v_plane_lock->target());
   }
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;
   if (alpha_texture_mode == YUV_HAS_ALPHA_TEXTURE) {
     a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
         resource_provider_, quad->a_plane_resource_id(), GL_TEXTURE4,
         GL_LINEAR));
     DCHECK_EQ(y_plane_lock.target(), a_plane_lock->target());
   }
 
   // All planes must have the same sampler type.
   SamplerType sampler = SamplerTypeFromTextureTarget(y_plane_lock.target());
 
   const Program* program = GetProgram(
       ProgramKey::YUVVideo(tex_coord_precision, sampler, alpha_texture_mode,
-                           uv_texture_mode, color_conversion_mode));
+                           uv_texture_mode, use_lut));
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   gfx::SizeF ya_tex_scale(1.0f, 1.0f);
   gfx::SizeF uv_tex_scale(1.0f, 1.0f);
   if (sampler != SAMPLER_TYPE_2D_RECT) {
     DCHECK(!quad->ya_tex_size.IsEmpty());
     DCHECK(!quad->uv_tex_size.IsEmpty());
     ya_tex_scale = gfx::SizeF(1.0f / quad->ya_tex_size.width(),
                               1.0f / quad->ya_tex_size.height());
@@ skipping 46 matching lines @@
   gl_->Uniform1i(program->y_texture_location(), 1);
   if (uv_texture_mode == UV_TEXTURE_MODE_UV) {
     gl_->Uniform1i(program->uv_texture_location(), 2);
   } else {
     gl_->Uniform1i(program->u_texture_location(), 2);
     gl_->Uniform1i(program->v_texture_location(), 3);
   }
   if (alpha_texture_mode == YUV_HAS_ALPHA_TEXTURE)
     gl_->Uniform1i(program->a_texture_location(), 4);
 
-  if (color_conversion_mode == COLOR_CONVERSION_MODE_LUT_FROM_YUV) {
+  if (use_lut) {
     ColorLUTCache::LUT lut = color_lut_cache_.GetLUT(quad->video_color_space,
                                                      frame->device_color_space);
     gl_->ActiveTexture(GL_TEXTURE5);
     gl_->BindTexture(GL_TEXTURE_2D, lut.texture);
     gl_->Uniform1i(program->lut_texture_location(), 5);
     gl_->Uniform1f(program->lut_size_location(), lut.size);
     gl_->ActiveTexture(GL_TEXTURE0);
     gl_->Uniform1f(program->resource_multiplier_location(),
                    quad->resource_multiplier);
     gl_->Uniform1f(program->resource_offset_location(), quad->resource_offset);
   } else {
     float yuv_to_rgb_multiplied[9] = {0};
     float yuv_adjust_with_offset[3] = {0};
     ComputeYUVToRGBMatrices(quad->color_space, quad->bits_per_channel,
                             quad->resource_multiplier, quad->resource_offset,
                             yuv_to_rgb_multiplied, yuv_adjust_with_offset);
-    gl_->UniformMatrix3fv(program->yuv_matrix_location(), 1, 0,
-                          yuv_to_rgb_multiplied);
-    gl_->Uniform3fv(program->yuv_adj_location(), 1, yuv_adjust_with_offset);
+    DCHECK_NE(program->color_matrix_location(), -1);
+    DCHECK_NE(program->color_offset_location(), -1);
+
+    float matrix[16];
+    SkMatrix44 m;
+    for (int i = 0; i < 4; ++i) {
+      for (int j = 0; j < 4; ++j) {
+        float x;
+        if (i == 3 && j == 3) {
+          x = 1.0f;
+        } else if (i == 3 || j == 3) {
+          x = 0.0f;
+        } else {
+          x = yuv_to_rgb_multiplied[i * 3 + j];
+        }
+        m.set(j, i, x);
+        matrix[i * 4 + j] = x;
+      }
+    }
+    SkVector4 v(yuv_adjust_with_offset[0], yuv_adjust_with_offset[1],
+                yuv_adjust_with_offset[2], 0.0f);
+    v = m * v;
+    gl_->UniformMatrix4fv(program->color_matrix_location(), 1, false, matrix);
+    gl_->Uniform4fv(program->color_offset_location(), 1, v.fData);
   }
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   auto tile_rect = gfx::RectF(quad->rect);
 
   SetShaderOpacity(quad->shared_quad_state->opacity, program->alpha_location());
   if (!clip_region) {
@@ skipping 1285 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc