color: Add analytic transfer functions in shaders

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 <algorithm>
 #include <cmath>
 #include <list>
 #include <memory>
@@ skipping 17 matching lines @@
 using std::log;
 using std::max;
 using std::min;
 using std::pow;
 using std::sqrt;
 
 namespace gfx {
 
 namespace {
 
+std::string Str(float f) {
+  return base::StringPrintf("%+1.8e", f);
+}
+
 // Helper for scoped QCMS profiles.
 struct QcmsProfileDeleter {
   void operator()(qcms_profile* p) {
     if (p) {
       qcms_profile_release(p);
     }
   }
 };
 using ScopedQcmsProfile = std::unique_ptr<qcms_profile, QcmsProfileDeleter>;
 
@@ skipping 172 matching lines @@
 
 Transform GetPrimaryTransform(const gfx::ColorSpace& color_space) {
   SkMatrix44 primary_matrix;
   color_space.GetPrimaryMatrix(&primary_matrix);
   return Transform(primary_matrix);
 }
 
 }  // namespace
 
 class ColorTransformMatrix;
+class ColorTransformSkTransferFn;
 class ColorTransformFromLinear;
 class ColorTransformToBT2020CL;
 class ColorTransformFromBT2020CL;
 class ColorTransformNull;
 class QCMSColorTransform;
 
 class ColorTransformStep {
  public:
   ColorTransformStep() {}
   virtual ~ColorTransformStep() {}
   virtual ColorTransformFromLinear* GetFromLinear() { return nullptr; }
   virtual ColorTransformToBT2020CL* GetToBT2020CL() { return nullptr; }
   virtual ColorTransformFromBT2020CL* GetFromBT2020CL() { return nullptr; }
+  virtual ColorTransformSkTransferFn* GetSkTransferFn() { return nullptr; }
   virtual ColorTransformMatrix* GetMatrix() { return nullptr; }
   virtual ColorTransformNull* GetNull() { return nullptr; }
   virtual QCMSColorTransform* GetQCMS() { return nullptr; }
 
   // Join methods, returns true if the |next| transform was successfully
   // assimilated into |this|.
   // If Join() returns true, |next| is no longer needed and can be deleted.
   virtual bool Join(ColorTransformStep* next) { return false; }
 
   // Return true if this is a null transform.
@@ skipping 77 matching lines @@
 
   void Transform(ColorTransform::TriStim* colors, size_t num) const override {
     for (size_t i = 0; i < num; i++)
       matrix_.TransformPoint(colors + i);
   }
 
   bool CanAppendShaderSource() override { return true; }
 
   void AppendShaderSource(std::string* result) override {
     const SkMatrix44& m = matrix_.matrix();
-    SRC("color = mat3(%1.8e, %1.8e, %1.8e, %1.8e, %1.8e, %1.8e, %1.8e, %1.8e, "
-        "%1.8e) * color;",
-        m.get(0, 0), m.get(1, 0), m.get(2, 0),   // column 1
-        m.get(0, 1), m.get(1, 1), m.get(2, 1),   // column 2
-        m.get(0, 2), m.get(1, 2), m.get(2, 2));  // column 3
-    SRC("color += vec3(%1.8e, %1.8e, %1.8e);", m.get(0, 3), m.get(1, 3),
-        m.get(2, 3));
+    SRC("color = mat3(%+1.8e, %+1.8e, %+1.8e,",  // column 1
+        m.get(0, 0), m.get(1, 0), m.get(2, 0));
+    SRC("             %+1.8e, %+1.8e, %+1.8e,",  // column 2
+        m.get(0, 1), m.get(1, 1), m.get(2, 1));
+    SRC("             %+1.8e, %+1.8e, %+1.8e) * color;",  // column 3
+        m.get(0, 2), m.get(1, 2), m.get(2, 2));
+    SRC("color = vec3(%+1.8e, %+1.8e, %+1.8e) + color;",  // column 4
+        m.get(0, 3), m.get(1, 3), m.get(2, 3));
   }
 
  private:
   class Transform matrix_;
 };
 
+class ColorTransformSkTransferFn : public ColorTransformStep {
+ public:
+  explicit ColorTransformSkTransferFn(const SkColorSpaceTransferFn& fn)
+      : fn_(fn) {}
+  ColorTransformSkTransferFn* GetSkTransferFn() override { return this; }
+
+  bool Join(ColorTransformStep* next_untyped) override {
+    ColorTransformSkTransferFn* next = next_untyped->GetSkTransferFn();
+    if (!next)
+      return false;
+    if (SkTransferFnsApproximatelyCancel(fn_, next->fn_)) {
+      // Set to be the identity.
+      fn_.fA = 1;
+      fn_.fB = 0;
+      fn_.fC = 1;
+      fn_.fD = 0;
+      fn_.fE = 0;
+      fn_.fF = 0;
+      fn_.fG = 1;
+      return true;
+    }
+    return false;
+  }
+
+  bool IsNull() override { return SkTransferFnIsApproximatelyIdentity(fn_); }
+
+  void Transform(ColorTransform::TriStim* colors, size_t num) const override {
+    for (size_t i = 0; i < num; i++) {
+      colors[i].set_x(SkTransferFnEval(fn_, colors[i].x()));
+      colors[i].set_y(SkTransferFnEval(fn_, colors[i].y()));
+      colors[i].set_z(SkTransferFnEval(fn_, colors[i].z()));
+    }
+  }
+
+  bool CanAppendShaderSource() override { return true; }
+
+  void AppendShaderSourceChannel(std::string* result, const char* value) {
+    const float kEpsilon = 1.f / 1024.f;
+
+    // Construct the linear segment
+    //   linear = C * x + F
+    // Elide operations that will be close to the identity.
+    std::string linear = value;
+    if (std::abs(fn_.fC - 1.f) > kEpsilon)
+      linear = Str(fn_.fC) + " * " + linear;
+    if (std::abs(fn_.fF) > kEpsilon)
+      linear = linear + " + " + Str(fn_.fF);
+
+    // Construct the nonlinear segment.
+    //   nonlinear = pow(A * x + B, G) + E
+    // Elide operations (especially the pow) that will be close to the
+    // identity.
+    std::string nonlinear = value;
+    if (std::abs(fn_.fA - 1.f) > kEpsilon)
+      nonlinear = Str(fn_.fA) + " * " + nonlinear;
+    if (std::abs(fn_.fB) > kEpsilon)
+      nonlinear = nonlinear + " + " + Str(fn_.fB);
+    if (std::abs(fn_.fG - 1.f) > kEpsilon)
+      nonlinear = "pow(" + nonlinear + ", " + Str(fn_.fG) + ")";
+    if (std::abs(fn_.fE) > kEpsilon)
+      nonlinear = nonlinear + " + " + Str(fn_.fE);
+
+    // Add both parts, skpping the if clause if possible.
+    if (fn_.fD > kEpsilon) {
+      SRC("if (%s < %f)", value, fn_.fD);
+      SRC("  %s = %s;", value, linear.c_str());
+      SRC("else");
+      SRC("  %s = %s;", value, nonlinear.c_str());
+    } else {
+      SRC("%s = %s;", value, nonlinear.c_str());
+    }
+  }
+
+  void AppendShaderSource(std::string* result) override {
+    // Append the transfer function for each channel.
+    AppendShaderSourceChannel(result, "color.r");
+    AppendShaderSourceChannel(result, "color.g");
+    AppendShaderSourceChannel(result, "color.b");
+  }
+
+ private:
+  SkColorSpaceTransferFn fn_;
+};
+
 class ColorTransformFromLinear : public ColorTransformStep {
  public:
-  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer,
-                                    const SkColorSpaceTransferFn& fn,
-                                    bool fn_valid)
-      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {
-    if (transfer_ == ColorSpace::TransferID::LINEAR_HDR)
-      transfer_ = ColorSpace::TransferID::LINEAR;
-  }
+  explicit ColorTransformFromLinear(ColorSpace::TransferID transfer)
+      : transfer_(transfer) {}
   ColorTransformFromLinear* GetFromLinear() override { return this; }
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
   void Transform(ColorTransform::TriStim* colors, size_t num) const override {
-    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()));
-      }
+    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 ColorTransformStep {
  public:
-  explicit ColorTransformToLinear(ColorSpace::TransferID transfer,
-                                  const SkColorSpaceTransferFn& fn,
-                                  bool fn_valid)
-      : transfer_(transfer), fn_(fn), fn_valid_(fn_valid) {
-    if (transfer_ == ColorSpace::TransferID::LINEAR_HDR)
-      transfer_ = ColorSpace::TransferID::LINEAR;
-  }
-
-  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:
-      case ColorSpace::TransferID::IEC61966_2_1:  // SRGB
-        return true;
-
-      default:
-        return false;
-    }
-  }
+  explicit ColorTransformToLinear(ColorSpace::TransferID transfer)
+      : transfer_(transfer) {}
 
   bool Join(ColorTransformStep* next_untyped) override {
     ColorTransformFromLinear* next = next_untyped->GetFromLinear();
     if (!next)
       return false;
-    // TODO(ccameron): Use SkTransferFnsApproximatelyCancel and
-    // SkTransferFnIsApproximatelyIdentity to merge parametric transfer
-    // functions.
-    if (transfer_ == next->transfer_ ||
-        (IsGamma22(transfer_) && IsGamma22(next->transfer_))) {
+    if (transfer_ == next->transfer_) {
       transfer_ = ColorSpace::TransferID::LINEAR;
       return true;
     }
     return false;
   }
 
   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;
   }
 
   static ColorTransform::TriStim ClipToWhite(ColorTransform::TriStim& c) {
     float maximum = max(max(c.x(), c.y()), c.z());
     if (maximum > 1.0f) {
       float l = Luma(c);
       c.Scale(1.0f / maximum);
       ColorTransform::TriStim white(1.0f, 1.0f, 1.0f);
       white.Scale((1.0f - 1.0f / maximum) * l / Luma(white));
       ColorTransform::TriStim black(0.0f, 0.0f, 0.0f);
       c += white - black;
     }
     return c;
   }
 
   void Transform(ColorTransform::TriStim* colors, size_t num) const override {
-    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) {
+    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 = ClipToWhite(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 126 matching lines @@
 
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(Invert(GetTransferMatrix(from))));
 
   // If the target color space is not defined, just apply the adjust and
   // tranfer matrices.
   if (!to.IsValid())
     return;
 
   SkColorSpaceTransferFn to_linear_fn;
-  bool to_linear_fn_valid = from.GetTransferFunction(&to_linear_fn);
-  steps_.push_back(base::MakeUnique<ColorTransformToLinear>(
-      from.transfer_, to_linear_fn, to_linear_fn_valid));
+  if (from.GetTransferFunction(&to_linear_fn)) {
+    steps_.push_back(
+        base::MakeUnique<ColorTransformSkTransferFn>(to_linear_fn));
+  } else {
+    steps_.push_back(base::MakeUnique<ColorTransformToLinear>(from.transfer_));
+  }
 
   if (from.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
     // BT2020 CL is a special case.
     steps_.push_back(base::MakeUnique<ColorTransformFromBT2020CL>());
   }
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(GetPrimaryTransform(from)));
 
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(Invert(GetPrimaryTransform(to))));
   if (to.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
     // BT2020 CL is a special case.
     steps_.push_back(base::MakeUnique<ColorTransformToBT2020CL>());
   }
 
   SkColorSpaceTransferFn from_linear_fn;
-  bool from_linear_fn_valid = to.GetInverseTransferFunction(&from_linear_fn);
-  steps_.push_back(base::MakeUnique<ColorTransformFromLinear>(
-      to.transfer_, from_linear_fn, from_linear_fn_valid));
+  if (to.GetInverseTransferFunction(&from_linear_fn)) {
+    steps_.push_back(
+        base::MakeUnique<ColorTransformSkTransferFn>(from_linear_fn));
+  } else {
+    steps_.push_back(base::MakeUnique<ColorTransformFromLinear>(to.transfer_));
+  }
 
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(GetTransferMatrix(to)));
 
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(Invert(GetRangeAdjustMatrix(to))));
 }
 
 class QCMSColorTransform : public ColorTransformStep {
  public:
@@ skipping 154 matching lines @@
     const ColorSpace& to,
     Intent intent) {
   return std::unique_ptr<ColorTransform>(
       new ColorTransformInternal(from, to, intent));
 }
 
 ColorTransform::ColorTransform() {}
 ColorTransform::~ColorTransform() {}
 
 }  // namespace gfx