Use SkICC in gfx::ICCProfile and gfx::ColorSpace

ui/gfx/color_transform.cc

 // Copyright (c) 2016 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/color_transform.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/transform.h"
 #include "third_party/qcms/src/qcms.h"
 
 #ifndef THIS_MUST_BE_INCLUDED_AFTER_QCMS_H
 extern "C" {
 #include "third_party/qcms/src/chain.h"
 };
 #endif
 
 namespace gfx {
 
+float EvalSkTransferFn(const SkColorSpaceTransferFn& fn, float x) {
+  if (x < 0)
+    return 0;
+  if (x < fn.fD)
+    return fn.fC * x + fn.fF;
+  return powf(fn.fA * x + fn.fB, fn.fG) + fn.fE;
+}
+
 Transform Invert(const Transform& t) {
   Transform ret = t;
   if (!t.GetInverse(&ret)) {
     LOG(ERROR) << "Inverse should alsways be possible.";
   }
   return ret;
 }
 
-GFX_EXPORT Transform GetPrimaryMatrix(ColorSpace::PrimaryID id) {
-  SkColorSpacePrimaries primaries = {0};
-  switch (id) {
-    case ColorSpace::PrimaryID::CUSTOM:
-      NOTREACHED();
-
-    case ColorSpace::PrimaryID::RESERVED0:
-    case ColorSpace::PrimaryID::RESERVED:
-    case ColorSpace::PrimaryID::UNSPECIFIED:
-    case ColorSpace::PrimaryID::UNKNOWN:
-    case ColorSpace::PrimaryID::BT709:
-      // BT709 is our default case. Put it after the switch just
-      // in case we somehow get an id which is not listed in the switch.
-      // (We don't want to use "default", because we want the compiler
-      //  to tell us if we forgot some enum values.)
-      primaries.fRX = 0.640f;
-      primaries.fRY = 0.330f;
-      primaries.fGX = 0.300f;
-      primaries.fGY = 0.600f;
-      primaries.fBX = 0.150f;
-      primaries.fBY = 0.060f;
-      primaries.fWX = 0.3127f;
-      primaries.fWY = 0.3290f;
-      break;
-
-    case ColorSpace::PrimaryID::BT470M:
-      primaries.fRX = 0.67f;
-      primaries.fRY = 0.33f;
-      primaries.fGX = 0.21f;
-      primaries.fGY = 0.71f;
-      primaries.fBX = 0.14f;
-      primaries.fBY = 0.08f;
-      primaries.fWX = 0.31f;
-      primaries.fWY = 0.316f;
-      break;
-
-    case ColorSpace::PrimaryID::BT470BG:
-      primaries.fRX = 0.64f;
-      primaries.fRY = 0.33f;
-      primaries.fGX = 0.29f;
-      primaries.fGY = 0.60f;
-      primaries.fBX = 0.15f;
-      primaries.fBY = 0.06f;
-      primaries.fWX = 0.3127f;
-      primaries.fWY = 0.3290f;
-      break;
-
-    case ColorSpace::PrimaryID::SMPTE170M:
-    case ColorSpace::PrimaryID::SMPTE240M:
-      primaries.fRX = 0.630f;
-      primaries.fRY = 0.340f;
-      primaries.fGX = 0.310f;
-      primaries.fGY = 0.595f;
-      primaries.fBX = 0.155f;
-      primaries.fBY = 0.070f;
-      primaries.fWX = 0.3127f;
-      primaries.fWY = 0.3290f;
-      break;
-
-    case ColorSpace::PrimaryID::FILM:
-      primaries.fRX = 0.681f;
-      primaries.fRY = 0.319f;
-      primaries.fGX = 0.243f;
-      primaries.fGY = 0.692f;
-      primaries.fBX = 0.145f;
-      primaries.fBY = 0.049f;
-      primaries.fWX = 0.310f;
-      primaries.fWY = 0.136f;
-      break;
-
-    case ColorSpace::PrimaryID::BT2020:
-      primaries.fRX = 0.708f;
-      primaries.fRY = 0.292f;
-      primaries.fGX = 0.170f;
-      primaries.fGY = 0.797f;
-      primaries.fBX = 0.131f;
-      primaries.fBY = 0.046f;
-      primaries.fWX = 0.3127f;
-      primaries.fWY = 0.3290f;
-      break;
-
-    case ColorSpace::PrimaryID::SMPTEST428_1:
-      primaries.fRX = 1.0f;
-      primaries.fRY = 0.0f;
-      primaries.fGX = 0.0f;
-      primaries.fGY = 1.0f;
-      primaries.fBX = 0.0f;
-      primaries.fBY = 0.0f;
-      primaries.fWX = 1.0f / 3.0f;
-      primaries.fWY = 1.0f / 3.0f;
-      break;
-
-    case ColorSpace::PrimaryID::SMPTEST431_2:
-      primaries.fRX = 0.680f;
-      primaries.fRY = 0.320f;
-      primaries.fGX = 0.265f;
-      primaries.fGY = 0.690f;
-      primaries.fBX = 0.150f;
-      primaries.fBY = 0.060f;
-      primaries.fWX = 0.314f;
-      primaries.fWY = 0.351f;
-      break;
-
-    case ColorSpace::PrimaryID::SMPTEST432_1:
-      primaries.fRX = 0.680f;
-      primaries.fRY = 0.320f;
-      primaries.fGX = 0.265f;
-      primaries.fGY = 0.690f;
-      primaries.fBX = 0.150f;
-      primaries.fBY = 0.060f;
-      primaries.fWX = 0.3127f;
-      primaries.fWY = 0.3290f;
-      break;
-
-    case ColorSpace::PrimaryID::XYZ_D50:
-      primaries.fRX = 1.0f;
-      primaries.fRY = 0.0f;
-      primaries.fGX = 0.0f;
-      primaries.fGY = 1.0f;
-      primaries.fBX = 0.0f;
-      primaries.fBY = 0.0f;
-      primaries.fWX = 0.34567f;
-      primaries.fWY = 0.35850f;
-      break;
-  }
-
-  SkMatrix44 matrix;
-  primaries.toXYZD50(&matrix);
-  return Transform(matrix);
-}
-
-GFX_EXPORT float FromLinear(ColorSpace::TransferID id, float v) {
+float FromLinear(ColorSpace::TransferID id, float v) {
   switch (id) {
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
       // Should already be handled.
-      NOTREACHED();
-    case ColorSpace::TransferID::CUSTOM:
-    // TODO(hubbe): Actually implement custom transfer functions.
-    case ColorSpace::TransferID::RESERVED0:
-    case ColorSpace::TransferID::RESERVED:
-    case ColorSpace::TransferID::UNSPECIFIED:
-    case ColorSpace::TransferID::UNKNOWN:
-    // All unknown values default to BT709
-
-    case ColorSpace::TransferID::BT709:
-    case ColorSpace::TransferID::SMPTE170M:
-    case ColorSpace::TransferID::BT2020_10:
-    case ColorSpace::TransferID::BT2020_12:
-      // BT709 is our "default" cause, so put the code after the switch
-      // to avoid "control reaches end of non-void function" errors.
       break;
 
-    case ColorSpace::TransferID::GAMMA22:
-      v = fmax(0.0f, v);
-      return powf(v, 1.0f / 2.2f);
-
-    case ColorSpace::TransferID::GAMMA28:
-      v = fmax(0.0f, v);
-      return powf(v, 1.0f / 2.8f);
-
-    case ColorSpace::TransferID::SMPTE240M: {
-      v = fmax(0.0f, v);
-      float a = 1.11157219592173128753f;
-      float b = 0.02282158552944503135f;
-      if (v <= b) {
-        return 4.0f * v;
-      } else {
-        return a * powf(v, 0.45f) - (a - 1.0f);
-      }
-    }
-
-    case ColorSpace::TransferID::LINEAR:
-      return v;
-
     case ColorSpace::TransferID::LOG:
       if (v < 0.01f)
         return 0.0f;
       return 1.0f + log(v) / log(10.0f) / 2.0f;
 
     case ColorSpace::TransferID::LOG_SQRT:
       if (v < sqrt(10.0f) / 1000.0f)
         return 0.0f;
       return 1.0f + log(v) / log(10.0f) / 2.5f;
 
@@ skipping 15 matching lines @@
       float l = 0.0045f;
       if (v < -l) {
         return -(a * powf(-4.0f * v, 0.45f) + (a - 1.0f)) / 4.0f;
       } else if (v <= b) {
         return 4.5f * v;
       } else {
         return a * powf(v, 0.45f) - (a - 1.0f);
       }
     }
 
-    case ColorSpace::TransferID::IEC61966_2_1: {  // SRGB
-      v = fmax(0.0f, v);
-      float a = 1.055f;
-      float b = 0.0031308f;
-      if (v < b) {
-        return 12.92f * v;
-      } else {
-        return a * powf(v, 1.0f / 2.4f) - (a - 1.0f);
-      }
-    }
     case ColorSpace::TransferID::SMPTEST2084: {
       // Go from scRGB levels to 0-1.
       v *= 80.0f / 10000.0f;
       v = fmax(0.0f, v);
       float m1 = (2610.0f / 4096.0f) / 4.0f;
       float m2 = (2523.0f / 4096.0f) * 128.0f;
       float c1 = 3424.0f / 4096.0f;
       float c2 = (2413.0f / 4096.0f) * 32.0f;
       float c3 = (2392.0f / 4096.0f) * 32.0f;
       return powf((c1 + c2 * powf(v, m1)) / (1.0f + c3 * powf(v, m1)), m2);
     }
 
-    case ColorSpace::TransferID::SMPTEST428_1:
-      v = fmax(0.0f, v);
-      return powf(48.0f * v + 52.37f, 1.0f / 2.6f);
-
     // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
     case ColorSpace::TransferID::ARIB_STD_B67: {
       const float a = 0.17883277f;
       const float b = 0.28466892f;
       const float c = 0.55991073f;
       v = fmax(0.0f, v);
       if (v <= 1)
         return 0.5f * sqrtf(v);
       else
         return a * log(v - b) + c;
     }
 
-    // Chrome-specific values below
-    case ColorSpace::TransferID::GAMMA24:
-      v = fmax(0.0f, v);
-      return powf(v, 1.0f / 2.4f);
+    default:
+      // Handled by SkColorSpaceTransferFn.
+      break;
   }
-
-  v = fmax(0.0f, v);
-  float a = 1.099296826809442f;
-  float b = 0.018053968510807f;
-  if (v <= b) {
-    return 4.5f * v;
-  } else {
-    return a * powf(v, 0.45f) - (a - 1.0f);
-  }
+  NOTREACHED();
+  return 0;
 }
 
-GFX_EXPORT float ToLinear(ColorSpace::TransferID id, float v) {
+float ToLinear(ColorSpace::TransferID id, float v) {
   switch (id) {
-    case ColorSpace::TransferID::CUSTOM:
-    // TODO(hubbe): Actually implement custom transfer functions.
-    case ColorSpace::TransferID::RESERVED0:
-    case ColorSpace::TransferID::RESERVED:
-    case ColorSpace::TransferID::UNSPECIFIED:
-    case ColorSpace::TransferID::UNKNOWN:
-    // All unknown values default to BT709
-
-    case ColorSpace::TransferID::BT709:
-    case ColorSpace::TransferID::SMPTE170M:
-    case ColorSpace::TransferID::BT2020_10:
-    case ColorSpace::TransferID::BT2020_12:
-      // BT709 is our "default" cause, so put the code after the switch
-      // to avoid "control reaches end of non-void function" errors.
-      break;
-
-    case ColorSpace::TransferID::GAMMA22:
-      v = fmax(0.0f, v);
-      return powf(v, 2.2f);
-
-    case ColorSpace::TransferID::GAMMA28:
-      v = fmax(0.0f, v);
-      return powf(v, 2.8f);
-
-    case ColorSpace::TransferID::SMPTE240M: {
-      v = fmax(0.0f, v);
-      float a = 1.11157219592173128753f;
-      float b = 0.02282158552944503135f;
-      if (v <= FromLinear(ColorSpace::TransferID::SMPTE240M, b)) {
-        return v / 4.0f;
-      } else {
-        return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
-      }
-    }
-
-    case ColorSpace::TransferID::LINEAR:
-      return v;
-
     case ColorSpace::TransferID::LOG:
       if (v < 0.0f)
         return 0.0f;
       return powf(10.0f, (v - 1.0f) * 2.0f);
 
     case ColorSpace::TransferID::LOG_SQRT:
       if (v < 0.0f)
         return 0.0f;
       return powf(10.0f, (v - 1.0f) * 2.5f);
 
@@ skipping 15 matching lines @@
       float l = 0.0045f;
       if (v < FromLinear(ColorSpace::TransferID::BT1361_ECG, -l)) {
         return -powf((1.0f - a - v * 4.0f) / a, 1.0f / 0.45f) / 4.0f;
       } else if (v <= FromLinear(ColorSpace::TransferID::BT1361_ECG, b)) {
         return v / 4.5f;
       } else {
         return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
       }
     }
 
-    case ColorSpace::TransferID::IEC61966_2_1: {  // SRGB
-      v = fmax(0.0f, v);
-      float a = 1.055f;
-      float b = 0.0031308f;
-      if (v < FromLinear(ColorSpace::TransferID::IEC61966_2_1, b)) {
-        return v / 12.92f;
-      } else {
-        return powf((v + a - 1.0f) / a, 2.4f);
-      }
-    }
-
     case ColorSpace::TransferID::SMPTEST2084: {
       v = fmax(0.0f, v);
       float m1 = (2610.0f / 4096.0f) / 4.0f;
       float m2 = (2523.0f / 4096.0f) * 128.0f;
       float c1 = 3424.0f / 4096.0f;
       float c2 = (2413.0f / 4096.0f) * 32.0f;
       float c3 = (2392.0f / 4096.0f) * 32.0f;
       v = powf(
           fmax(powf(v, 1.0f / m2) - c1, 0) / (c2 - c3 * powf(v, 1.0f / m2)),
           1.0f / m1);
       // This matches the scRGB definition that 1.0 means 80 nits.
       // TODO(hubbe): It would be *nice* if 1.0 meant more than that, but
       // that might be difficult to do right now.
       v *= 10000.0f / 80.0f;
       return v;
     }
 
-    case ColorSpace::TransferID::SMPTEST428_1:
-      return (powf(v, 2.6f) - 52.37f) / 48.0f;
-
-    // Chrome-specific values below
-    case ColorSpace::TransferID::GAMMA24:
-      v = fmax(0.0f, v);
-      return powf(v, 2.4f);
-
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
       v = fmax(0.0f, v);
       return fmin(2.3f * pow(v, 2.8f), v / 5.0f + 0.8f);
 
     // Spec: http://www.arib.or.jp/english/html/overview/doc/2-STD-B67v1_0.pdf
     case ColorSpace::TransferID::ARIB_STD_B67: {
       v = fmax(0.0f, v);
       const float a = 0.17883277f;
       const float b = 0.28466892f;
       const float c = 0.55991073f;
       float v_ = 0.0f;
       if (v <= 0.5f) {
         v_ = (v * 2.0f) * (v * 2.0f);
       } else {
         v_ = exp((v - c) / a) + b;
       }
       return v_;
     }
+
+    default:
+      // Handled by SkColorSpaceTransferFn.
+      break;
   }
-
-  v = fmax(0.0f, v);
-  float a = 1.099296826809442f;
-  float b = 0.018053968510807f;
-  if (v < FromLinear(ColorSpace::TransferID::BT709, b)) {
-    return v / 4.5f;
-  } else {
-    return powf((v + a - 1.0f) / a, 1.0f / 0.45f);
-  }
+  NOTREACHED();
+  return 0;
 }
 
 GFX_EXPORT Transform GetTransferMatrix(ColorSpace::MatrixID id) {
   // Default values for BT709;
   float Kr = 0.2126f;
   float Kb = 0.0722f;
   switch (id) {
     case ColorSpace::MatrixID::RGB:
       return Transform();
 
@@ skipping 166 matching lines @@
     for (size_t i = 0; i < num; i++)
       matrix_.TransformPoint(colors + i);
   }
 
  private:
   Transform matrix_;
 };
 
 class ColorTransformFromLinear : public ColorTransformInternal {
  public:
-  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer)
-      : transfer_(transfer) {}
+  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer,
+                                    const SkColorSpaceTransferFn& fn,
+                                    bool fn_valid)
+      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {}
   bool Prepend(ColorTransformInternal* prev) override {
     return prev->Join(*this);
   }
 
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
 
   void transform(ColorTransform::TriStim* colors, size_t num) override {
-    for (size_t i = 0; i < num; i++) {
-      colors[i].set_x(FromLinear(transfer_, colors[i].x()));
-      colors[i].set_y(FromLinear(transfer_, colors[i].y()));
-      colors[i].set_z(FromLinear(transfer_, colors[i].z()));
+    if (fn_valid_) {
+      for (size_t i = 0; i < num; i++) {
+        colors[i].set_x(EvalSkTransferFn(fn_, colors[i].x()));
+        colors[i].set_y(EvalSkTransferFn(fn_, colors[i].y()));
+        colors[i].set_z(EvalSkTransferFn(fn_, colors[i].z()));
+      }
+    } else {
+      for (size_t i = 0; i < num; i++) {
+        colors[i].set_x(FromLinear(transfer_, colors[i].x()));
+        colors[i].set_y(FromLinear(transfer_, colors[i].y()));
+        colors[i].set_z(FromLinear(transfer_, colors[i].z()));
+      }
     }
   }
 
  private:
   friend class ColorTransformToLinear;
   ColorSpace::TransferID transfer_;
+  SkColorSpaceTransferFn fn_;
+  bool fn_valid_ = false;
 };
 
 class ColorTransformToLinear : public ColorTransformInternal {
  public:
-  explicit ColorTransformToLinear(ColorSpace::TransferID transfer)
-      : transfer_(transfer) {}
+  explicit ColorTransformToLinear(ColorSpace::TransferID transfer,
+                                  const SkColorSpaceTransferFn& fn,
+                                  bool fn_valid)
+      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {}
 
   bool Prepend(ColorTransformInternal* prev) override {
     return prev->Join(*this);
   }
 
   static bool IsGamma22(ColorSpace::TransferID transfer) {
     switch (transfer) {
       // We don't need to check BT709 here because it's been translated into
       // SRGB in ColorSpaceToColorSpaceTransform::ColorSpaceToLinear below.
       case ColorSpace::TransferID::GAMMA22:
@@ skipping 15 matching lines @@
   }
 
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
 
   // Assumes BT2020 primaries.
   static float Luma(const ColorTransform::TriStim& c) {
     return c.x() * 0.2627f + c.y() * 0.6780f + c.z() * 0.0593f;
   }
 
   void transform(ColorTransform::TriStim* colors, size_t num) override {
-    if (transfer_ == ColorSpace::TransferID::SMPTEST2084_NON_HDR) {
+    if (fn_valid_) {
+      for (size_t i = 0; i < num; i++) {
+        colors[i].set_x(EvalSkTransferFn(fn_, colors[i].x()));
+        colors[i].set_y(EvalSkTransferFn(fn_, colors[i].y()));
+        colors[i].set_z(EvalSkTransferFn(fn_, colors[i].z()));
+      }
+    } else if (transfer_ == ColorSpace::TransferID::SMPTEST2084_NON_HDR) {
       for (size_t i = 0; i < num; i++) {
         ColorTransform::TriStim ret(ToLinear(transfer_, colors[i].x()),
                                     ToLinear(transfer_, colors[i].y()),
                                     ToLinear(transfer_, colors[i].z()));
         if (Luma(ret) > 0.0) {
           ColorTransform::TriStim smpte2084(
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].x()),
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].y()),
               ToLinear(ColorSpace::TransferID::SMPTEST2084, colors[i].z()));
           smpte2084.Scale(Luma(ret) / Luma(smpte2084));
           ret = smpte2084;
         }
         colors[i] = ret;
       }
     } else {
       for (size_t i = 0; i < num; i++) {
         colors[i].set_x(ToLinear(transfer_, colors[i].x()));
         colors[i].set_y(ToLinear(transfer_, colors[i].y()));
         colors[i].set_z(ToLinear(transfer_, colors[i].z()));
       }
     }
   }
 
  private:
   ColorSpace::TransferID transfer_;
+  SkColorSpaceTransferFn fn_;
+  bool fn_valid_ = false;
 };
 
 // BT2020 Constant Luminance is different than most other
 // ways to encode RGB values as YUV. The basic idea is that
 // transfer functions are applied on the Y value instead of
 // on the RGB values. However, running the transfer function
 // on the U and V values doesn't make any sense since they
 // are centered at 0.5. To work around this, the transfer function
 // is applied to the Y, R and B values, and then the U and V
 // values are calculated from that.
@@ skipping 135 matching lines @@
   void disable_optimizations() { disable_optimizations_ = true; }
 
  private:
   bool disable_optimizations_ = false;
   std::vector<std::unique_ptr<ColorTransformInternal>> transforms_;
 };
 
 class ColorSpaceToColorSpaceTransform {
  public:
   static Transform GetPrimaryTransform(const ColorSpace& c) {
-    if (c.primaries_ == ColorSpace::PrimaryID::CUSTOM) {
-      return Transform(c.custom_primary_matrix_[0], c.custom_primary_matrix_[1],
-                       c.custom_primary_matrix_[2], c.custom_primary_matrix_[3],
-                       c.custom_primary_matrix_[4], c.custom_primary_matrix_[5],
-                       c.custom_primary_matrix_[6], c.custom_primary_matrix_[7],
-                       c.custom_primary_matrix_[8], c.custom_primary_matrix_[9],
-                       c.custom_primary_matrix_[10],
-                       c.custom_primary_matrix_[11], 0.0f, 0.0f, 0.0f, 1.0f);
-    } else {
-      return GetPrimaryMatrix(c.primaries_);
-    }
+    SkMatrix44 sk_matrix;
+    c.GetPrimaryMatrix(&sk_matrix);
+    return Transform(sk_matrix);
   }
 
   static void ColorSpaceToColorSpace(ColorSpace from,
                                      ColorSpace to,
                                      ColorTransform::Intent intent,
                                      TransformBuilder* builder) {
     if (intent == ColorTransform::Intent::INTENT_PERCEPTUAL) {
       switch (from.transfer_) {
         case ColorSpace::TransferID::UNSPECIFIED:
         case ColorSpace::TransferID::BT709:
@@ skipping 22 matching lines @@
             from.transfer_ = ColorSpace::TransferID::GAMMA24;
           }
           break;
 
         default:  // Do nothing
           break;
       }
 
       // TODO(hubbe): shrink gamuts here (never stretch gamuts)
     }
+
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         GetRangeAdjustMatrix(from.range_, from.matrix_)));
+
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetTransferMatrix(from.matrix_))));
-    builder->Append(base::MakeUnique<ColorTransformToLinear>(from.transfer_));
+
+    SkColorSpaceTransferFn to_linear_fn;
+    bool to_linear_fn_valid = from.GetTransferFunction(&to_linear_fn);
+    builder->Append(base::MakeUnique<ColorTransformToLinear>(
+        from.transfer_, to_linear_fn, to_linear_fn_valid));
+
     if (from.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
       // BT2020 CL is a special case.
       builder->Append(base::MakeUnique<ColorTransformFromBT2020CL>());
     }
     builder->Append(
         base::MakeUnique<ColorTransformMatrix>(GetPrimaryTransform(from)));
 
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetPrimaryTransform(to))));
     if (to.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
       // BT2020 CL is a special case.
       builder->Append(base::MakeUnique<ColorTransformToBT2020CL>());
     }
 
-    builder->Append(base::MakeUnique<ColorTransformFromLinear>(to.transfer_));
+    SkColorSpaceTransferFn from_linear_fn;
+    bool from_linear_fn_valid = to.GetInverseTransferFunction(&from_linear_fn);
+    builder->Append(base::MakeUnique<ColorTransformFromLinear>(
+        to.transfer_, from_linear_fn, from_linear_fn_valid));
+
     builder->Append(
         base::MakeUnique<ColorTransformMatrix>(GetTransferMatrix(to.matrix_)));
+
     builder->Append(base::MakeUnique<ColorTransformMatrix>(
         Invert(GetRangeAdjustMatrix(to.range_, to.matrix_))));
   }
 };
 
 class QCMSColorTransform : public ColorTransformInternal {
  public:
   // Takes ownership of the profiles
   QCMSColorTransform(qcms_profile* from, qcms_profile* to)
       : from_(from), to_(to) {}
@@ skipping 75 matching lines @@
       from_profile ? ColorSpace::CreateXYZD50() : from,
       to_profile ? ColorSpace::CreateXYZD50() : to, intent, &builder);
   if (to_profile) {
     builder.Append(std::unique_ptr<ColorTransformInternal>(
         new QCMSColorTransform(GetXYZD50Profile(), to_profile)));
   }
 
   return builder.GetTransform();
 }
 
+// static
+float ColorTransform::ToLinearForTesting(ColorSpace::TransferID transfer,
+                                         float v) {
+  ColorSpace space(ColorSpace::PrimaryID::BT709, transfer,
+                   ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+  SkColorSpaceTransferFn to_linear_fn;
+  bool to_linear_fn_valid = space.GetTransferFunction(&to_linear_fn);
+  ColorTransformToLinear to_linear_transform(transfer, to_linear_fn,
+                                             to_linear_fn_valid);
+  TriStim color(v, v, v);
+  to_linear_transform.transform(&color, 1);
+  return color.x();
+}
+
+// static
+float ColorTransform::FromLinearForTesting(ColorSpace::TransferID transfer,
+                                           float v) {
+  ColorSpace space(ColorSpace::PrimaryID::BT709, transfer,
+                   ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL);
+  SkColorSpaceTransferFn from_linear_fn;
+  bool from_linear_fn_valid = space.GetInverseTransferFunction(&from_linear_fn);
+
+  ColorTransformFromLinear from_linear_transform(transfer, from_linear_fn,
+                                                 from_linear_fn_valid);
+  TriStim color(v, v, v);
+  from_linear_transform.transform(&color, 1);
+  return color.x();
+}
+
 }  // namespace gfx