HDR: Do nonlinear blending in the compositor

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>
 #include <sstream>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "third_party/qcms/src/qcms.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/skia_color_space_util.h"
 #include "ui/gfx/transform.h"
 
 #ifndef THIS_MUST_BE_INCLUDED_AFTER_QCMS_H
 extern "C" {
 #include "third_party/qcms/src/chain.h"
 };
 #endif
 
+using std::abs;
+using std::copysign;
 using std::exp;
 using std::log;
 using std::max;
 using std::min;
 using std::pow;
 using std::sqrt;
 
 namespace gfx {
 
 namespace {
@@ skipping 326 matching lines @@
       *result << ");" << std::endl;
     }
   }
 
  private:
   class Transform matrix_;
 };
 
 class ColorTransformSkTransferFn : public ColorTransformStep {
  public:
-  explicit ColorTransformSkTransferFn(const SkColorSpaceTransferFn& fn)
-      : fn_(fn) {}
+  explicit ColorTransformSkTransferFn(const SkColorSpaceTransferFn& fn,
+                                      bool extended)
+      : fn_(fn), extended_(extended) {}
   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_)) {
+    if (!extended_ && !next->extended_ &&
+        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()));
+      ColorTransform::TriStim& c = colors[i];
+      if (extended_) {
+        c.set_x(copysign(SkTransferFnEval(fn_, abs(c.x())), c.x()));
+        c.set_y(copysign(SkTransferFnEval(fn_, abs(c.y())), c.y()));
+        c.set_z(copysign(SkTransferFnEval(fn_, abs(c.z())), c.z()));
+      } else {
+        c.set_x(SkTransferFnEval(fn_, c.x()));
+        c.set_y(SkTransferFnEval(fn_, c.y()));
+        c.set_z(SkTransferFnEval(fn_, c.z()));
+      }
     }
   }
 
   bool CanAppendShaderSource() override { return true; }
 
-  void AppendShaderSourceChannel(std::stringstream* result, const char* value) {
+  void AppendShaderSourceChannel(std::stringstream* result,
+                                 const std::string& value) {
+    std::string abs_value = "abs(" + 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;
+    std::string nonlinear = extended_ ? abs_value : 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);
+    if (extended_) {
+      if (nonlinear == abs_value)
+        nonlinear = value;
+      else
+        nonlinear = "sign(" + value + ") * (" + nonlinear + ")";
+    }
 
     // Add both parts, skpping the if clause if possible.
     if (fn_.fD > kEpsilon) {
-      *result << "  if (" << value << " < " << Str(fn_.fD) << ")" << std::endl;
+      if (extended_) {
+        *result << "  if (" << abs_value << " < " << Str(fn_.fD) << ")"
+                << std::endl;
+      } else {
+        *result << "  if (" << value << " < " << Str(fn_.fD) << ")"
+                << std::endl;
+      }
       *result << "    " << value << " = " << linear << ";" << std::endl;
       *result << "  else" << std::endl;
       *result << "    " << value << " = " << nonlinear << ";" << std::endl;
     } else {
       *result << "  " << value << " = " << nonlinear << ";" << std::endl;
     }
   }
 
   void AppendShaderSource(std::stringstream* result) override {
     // Append the transfer function for each channel.
     AppendShaderSourceChannel(result, "color.r");
     AppendShaderSourceChannel(result, "color.g");
     AppendShaderSourceChannel(result, "color.b");
   }
 
  private:
   SkColorSpaceTransferFn fn_;
+  // True if the transfer function is extended to be defined for all real
+  // values.
+  const bool extended_ = false;
 };
 
 class ColorTransformFromLinear : public ColorTransformStep {
  public:
   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 {
     for (size_t i = 0; i < num; i++) {
@@ skipping 212 matching lines @@
       base::MakeUnique<ColorTransformMatrix>(Invert(GetTransferMatrix(from))));
 
   // If the target color space is not defined, just apply the adjust and
   // tranfer matrices. This path is used by YUV to RGB color conversion
   // when full color conversion is not enabled.
   if (!to.IsValid())
     return;
 
   SkColorSpaceTransferFn to_linear_fn;
   if (from.GetTransferFunction(&to_linear_fn)) {
-    steps_.push_back(
-        base::MakeUnique<ColorTransformSkTransferFn>(to_linear_fn));
+    steps_.push_back(base::MakeUnique<ColorTransformSkTransferFn>(
+        to_linear_fn, from.HasExtendedSkTransferFn()));
   } 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;
   if (to.GetInverseTransferFunction(&from_linear_fn)) {
-    steps_.push_back(
-        base::MakeUnique<ColorTransformSkTransferFn>(from_linear_fn));
+    steps_.push_back(base::MakeUnique<ColorTransformSkTransferFn>(
+        from_linear_fn, to.HasExtendedSkTransferFn()));
   } 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))));
 }
@@ skipping 165 matching lines @@
     const ColorSpace& to,
     Intent intent) {
   return std::unique_ptr<ColorTransform>(
       new ColorTransformInternal(from, to, intent));
 }
 
 ColorTransform::ColorTransform() {}
 ColorTransform::~ColorTransform() {}
 
 }  // namespace gfx