Towards deleting YUV to RGB computation redundancy

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 2081 matching lines @@
 
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0],
              frame->projection_matrix *
                  quad->shared_quad_state->quad_to_target_transform);
   gl_->UniformMatrix4fv(program->matrix_location(), 1, false, &gl_matrix[0]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
+namespace {
+
+float RelativeError(float a, float b) {
+  return std::abs(a - b) / std::max(1.f, std::abs(a + b));
+}
+
+}  // 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) {
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
@@ skipping 17 matching lines @@
   };
 
   // Same as above, but without the head and footroom.
   float yuv_adjust_full[3] = {
       0.0f, -128.f, -128.f,
   };
 
   float* yuv_to_rgb = NULL;
   float* yuv_adjust = NULL;
 
+  gfx::ColorSpace gfx_color_space;
   switch (color_space) {
     case YUVVideoDrawQuad::REC_601:
       yuv_to_rgb = yuv_to_rgb_rec601;
       yuv_adjust = yuv_adjust_constrained;
+      gfx_color_space = gfx::ColorSpace::CreateREC601();
       break;
     case YUVVideoDrawQuad::REC_709:
       yuv_to_rgb = yuv_to_rgb_rec709;
       yuv_adjust = yuv_adjust_constrained;
+      gfx_color_space = gfx::ColorSpace::CreateREC709();
       break;
     case YUVVideoDrawQuad::JPEG:
       yuv_to_rgb = yuv_to_rgb_jpeg;
       yuv_adjust = yuv_adjust_full;
+      gfx_color_space = gfx::ColorSpace::CreateJpeg();
       break;
   }
 
   // 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;
 
   for (int i = 0; i < 3; ++i) {
     yuv_adjust_with_offset[i] =
         yuv_adjust[i] * adjustment_multiplier / resource_multiplier -
         resource_offset;
   }
+
+  // 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);
+
+  // 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);
+  }
+
+  // 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);
+    }
+    DCHECK_LT(RelativeError(yuv_adjust_with_offset[i], adjust[i]), kEpsilon);
+  }
 }
 
 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());
@@ skipping 1420 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