cc: Separate YUV from LUT color conversion

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 2095 matching lines @@
 }
 
 }  // namespace
 
 // TODO(ccameron): This has been replicated in ui/gfx/color_transform.cc. Delete
 // one of the instances.
 void ComputeYUVToRGBMatrices(YUVVideoDrawQuad::ColorSpace color_space,
                              uint32_t bits_per_channel,
                              float resource_multiplier,
                              float resource_offset,
-                             float* yuv_to_rgb_multiplied,
-                             float* yuv_adjust_with_offset) {
+                             ColorConversionMode color_conversion_mode,
+                             float* yuv_to_rgb_matrix) {
+  float yuv_to_rgb_multiplied[9];
+  float yuv_adjust_with_offset[3];
+
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
   float yuv_to_rgb_rec601[9] = {
       1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
   };
   float yuv_to_rgb_jpeg[9] = {
       1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414f, 0.0f,
   };
   float yuv_to_rgb_rec709[9] = {
@@ skipping 37 matching lines @@
 
   // Formula according to BT.601-7 section 2.5.3.
   DCHECK_LE(YUVVideoDrawQuad::kMinBitsPerChannel, bits_per_channel);
   DCHECK_LE(bits_per_channel, YUVVideoDrawQuad::kMaxBitsPerChannel);
   float adjustment_multiplier =
       (1 << (bits_per_channel - 8)) * 1.0f / ((1 << bits_per_channel) - 1);
 
   for (int i = 0; i < 9; ++i)
     yuv_to_rgb_multiplied[i] = yuv_to_rgb[i] * resource_multiplier;
 
+  float yuv_adjust_with_offset_untransformed[3];
   for (int i = 0; i < 3; ++i) {
-    yuv_adjust_with_offset[i] =
+    yuv_adjust_with_offset_untransformed[i] =
         yuv_adjust[i] * adjustment_multiplier / resource_multiplier -
         resource_offset;
   }
 
+  for (int i = 0; i < 3; ++i) {
+    yuv_adjust_with_offset[i] = 0;
+    for (int j = 0; j < 3; ++j) {
+      yuv_adjust_with_offset[i] += yuv_to_rgb_multiplied[3 * j + i] *
+                                   yuv_adjust_with_offset_untransformed[j];
+    }
+  }
+
   // TODO(ccameron): Delete the above code, and just the below code instead.
   // Compute the matrix |full_transform| which converts input YUV values to RGB
   // values.
   SkMatrix44 full_transform;
 
   // Start with the resource adjust.
   full_transform.setScale(resource_multiplier, resource_multiplier,
                           resource_multiplier);
   full_transform.preTranslate(-resource_offset, -resource_offset,
                               -resource_offset);
 
+  // If we're using a LUT for conversion, we only need the resource adjust,
+  // so just return this matrix.
+  if (color_conversion_mode == COLOR_CONVERSION_MODE_LUT) {
+    full_transform.asColMajorf(yuv_to_rgb_matrix);
+    return;
+  }
+
   // Then apply the range adjust.
   {
     SkMatrix44 range_adjust;
     gfx_color_space.GetRangeAdjustMatrix(&range_adjust);
     full_transform.postConcat(range_adjust);
   }
 
   // Then apply the YUV to RGB full_transform.
   {
     SkMatrix44 rgb_to_yuv;
     gfx_color_space.GetTransferMatrix(&rgb_to_yuv);
     SkMatrix44 yuv_to_rgb;
     rgb_to_yuv.invert(&yuv_to_rgb);
     full_transform.postConcat(yuv_to_rgb);
   }
 
-  // For the upcoming DCHECKs, convert from the form
-  //   rgb = A*yuv+b
-  // to the form
-  //   rgb = A*(yuv+b)
-  float adjust[4] = {0, 0, 0, 0};
-  {
-    SkMatrix44 full_transform_inverse;
-    full_transform.invert(&full_transform_inverse);
-    float adjust_preimage[4] = {full_transform.get(0, 3),
-                                full_transform.get(1, 3),
-                                full_transform.get(2, 3), 0};
-    full_transform_inverse.mapScalars(adjust_preimage, adjust);
-  }
+  SkMatrix44 full_transform_old;
+  full_transform_old.set3x3RowMajorf(yuv_to_rgb_multiplied);
+  full_transform_old.transpose();
+  full_transform_old.postTranslate(yuv_adjust_with_offset[0],
+                                   yuv_adjust_with_offset[1],
+                                   yuv_adjust_with_offset[2]);
 
   // TODO(ccameron): The gfx::ColorSpace-based approach produces some pixel
   // differences. For the initial checkin, DCHECK that the parameters are
   // very close. The subsequent checkins will delete the old path.
   const float kEpsilon = 1.f / 255.f;
-  for (int i = 0; i < 3; ++i) {
-    for (int j = 0; j < 3; ++j) {
-      DCHECK_LT(RelativeError(yuv_to_rgb_multiplied[3 * j + i],
-                              full_transform.get(i, j)),
-                kEpsilon);
+  for (int i = 0; i < 4; ++i) {
+    for (int j = 0; j < 4; ++j) {
+      DCHECK_LT(
+          RelativeError(full_transform_old.get(i, j), full_transform.get(i, j)),
+          kEpsilon);
     }
-    DCHECK_LT(RelativeError(yuv_adjust_with_offset[i], adjust[i]), kEpsilon);
   }
+  full_transform_old.asColMajorf(yuv_to_rgb_matrix);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   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_LUT
           : COLOR_CONVERSION_MODE_NONE;
   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) {
@@ skipping 75 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 (color_conversion_mode == COLOR_CONVERSION_MODE_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->yuv_and_resource_matrix_location(), -1);
+  float yuv_to_rgb_matrix[16] = {0};
+  ComputeYUVToRGBMatrices(quad->color_space, quad->bits_per_channel,
+                          quad->resource_multiplier, quad->resource_offset,
+                          color_conversion_mode, yuv_to_rgb_matrix);
+  gl_->UniformMatrix4fv(program->yuv_and_resource_matrix_location(), 1, 0,
+                        yuv_to_rgb_matrix);
 
   // 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) {
     DrawQuadGeometry(frame->projection_matrix,
@@ skipping 1284 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