color: Always use parametric color spaces for raster

ui/gfx/skia_color_space_util.cc

 // Copyright 2017 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 "ui/gfx/skia_color_space_util.h"
 
 #include <algorithm>
 #include <cmath>
+#include <vector>
 
 #include "base/logging.h"
 
 namespace gfx {
 
 namespace {
 
 // Solve for the parameter fC, given the parameter fD, assuming fF is zero.
 void SkTransferFnSolveLinear(SkColorSpaceTransferFn* fn,
                              const float* x,
@@ skipping 194 matching lines @@
   if (std::abs(fn->fG - 1.f) < kRoundEpsilon)
     fn->fG = 1.f;
   return true;
 }
 
 bool SkApproximateTransferFnInternal(const float* x,
                                      const float* t,
                                      size_t n,
                                      SkColorSpaceTransferFn* fn) {
   // First, guess at a value of fD. Assume that the nonlinear segment applies
-  // to all x >= 0.1. This is generally a safe assumption (fD is usually less
+  // to all x >= 0.25. This is generally a safe assumption (fD is usually less
   // than 0.1).
-  fn->fD = 0.1f;
+  fn->fD = 0.25f;
 
   // Do a nonlinear regression on the nonlinear segment. Use a number of guesses
   // for the initial value of fG, because not all values will converge.
   bool nonlinear_fit_converged = false;
   {
     const size_t kNumInitialGammas = 4;
     float initial_gammas[kNumInitialGammas] = {2.f, 1.f, 3.f, 0.5f};
     for (size_t i = 0; i < kNumInitialGammas; ++i) {
       fn->fG = initial_gammas[i];
       fn->fA = 1;
@@ skipping 119 matching lines @@
   fn->fA = 1;
   fn->fB = 0;
   fn->fC = 1;
   fn->fD = 0;
   fn->fE = 0;
   fn->fF = 0;
   fn->fG = 1;
   return false;
 }
 
+bool GFX_EXPORT SkApproximateTransferFn(sk_sp<SkICC> sk_icc,
+                                        float* max_error,
+                                        SkColorSpaceTransferFn* fn) {
+  SkICC::Tables tables;
+  bool got_tables = sk_icc->rawTransferFnData(&tables);
+  if (!got_tables)
+    return false;
+
+  // Merge all channels' tables into a single array.
+  std::vector<float> x;
+  std::vector<float> t;
+  for (size_t c = 0; c < 3; ++c) {
+    SkICC::Channel* channels[3] = {&tables.fRed, &tables.fGreen, &tables.fBlue};
+    SkICC::Channel* channel = channels[c];
+    const float* data = reinterpret_cast<const float*>(
+        tables.fStorage->bytes() + channel->fOffset);
+    for (int i = 0; i < channel->fCount; ++i) {
+      float xi = i / (channel->fCount - 1.f);
+      float ti = data[i];
+      x.push_back(xi);
+      t.push_back(ti);
+    }
+  }
+
+  // Approximate and evalaute.
+  bool converged =
+      SkApproximateTransferFnInternal(x.data(), t.data(), x.size(), fn);
+  if (!converged)
+    return false;
+  *max_error = 0;
+  for (size_t i = 0; i < x.size(); ++i) {
+    float fn_of_xi = gfx::SkTransferFnEval(*fn, x[i]);
+    float error_at_xi = std::abs(t[i] - fn_of_xi);
+    *max_error = std::max(*max_error, error_at_xi);
+  }
+  return true;
+}
+
 bool SkMatrixIsApproximatelyIdentity(const SkMatrix44& m) {
   const float kEpsilon = 1.f / 256.f;
   for (int i = 0; i < 4; ++i) {
     for (int j = 0; j < 4; ++j) {
       float identity_value = i == j ? 1 : 0;
       float value = m.get(i, j);
       if (std::abs(identity_value - value) > kEpsilon)
         return false;
     }
   }
   return true;
 }
 
 }  // namespace gfx