color: Add support for shader generation

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 "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"
 };
@@ skipping 219 matching lines @@
   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.
   virtual bool IsNull() { return false; }
-
-  virtual void Transform(ColorTransform::TriStim* color, size_t num) = 0;
+  virtual void Transform(ColorTransform::TriStim* color, size_t num) const = 0;
+  virtual bool CanAppendShaderSource() { return false; }
+  virtual void AppendShaderSource(std::string* result) { NOTREACHED(); }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ColorTransformStep);
 };
 
 class ColorTransformInternal : public ColorTransform {
  public:
   ColorTransformInternal(const ColorSpace& from,
                          const ColorSpace& to,
                          Intent intent);
   ~ColorTransformInternal() override;
 
-  // Perform transformation of colors, |colors| is both input and output.
-  void Transform(TriStim* colors, size_t num) override {
+  gfx::ColorSpace GetSrcColorSpace() const override { return src_; };
+  gfx::ColorSpace GetDstColorSpace() const override { return dst_; };
+
+  void Transform(TriStim* colors, size_t num) const override {
     for (const auto& step : steps_)
       step->Transform(colors, num);
   }
+  bool CanGetShaderSource() const override;
+  std::string GetShaderSource() const override;
+  bool IsIdentity() const override { return steps_.empty(); }
   size_t NumberOfStepsForTesting() const override { return steps_.size(); }
 
  private:
   void AppendColorSpaceToColorSpaceTransform(ColorSpace from,
                                              const ColorSpace& to,
                                              ColorTransform::Intent intent);
   void Simplify();
 
   // Retrieve the ICC profile from which |color_space| was created, only if that
   // is a more precise representation of the color space than the primaries and
   // transfer function in |color_space|.
   ScopedQcmsProfile GetQCMSProfileIfNecessary(const ColorSpace& color_space);
 
   std::list<std::unique_ptr<ColorTransformStep>> steps_;
+  gfx::ColorSpace src_;
+  gfx::ColorSpace dst_;
 };
 
+#define SRC(...)                                                     \
+  do {                                                               \
+    *result += std::string("  ") + base::StringPrintf(__VA_ARGS__) + \
+               std::string("\n");                                    \
+  } while (0)
+
 class ColorTransformNull : public ColorTransformStep {
  public:
   ColorTransformNull* GetNull() override { return this; }
   bool IsNull() override { return true; }
-  void Transform(ColorTransform::TriStim* color, size_t num) override {}
+  void Transform(ColorTransform::TriStim* color, size_t num) const override {}
+  bool CanAppendShaderSource() override { return true; }
+  void AppendShaderSource(std::string* result) override {}
 };
 
 class ColorTransformMatrix : public ColorTransformStep {
  public:
   explicit ColorTransformMatrix(const class Transform& matrix)
       : matrix_(matrix) {}
   ColorTransformMatrix* GetMatrix() override { return this; }
   bool Join(ColorTransformStep* next_untyped) override {
     ColorTransformMatrix* next = next_untyped->GetMatrix();
     if (!next)
       return false;
     class Transform tmp = next->matrix_;
     tmp *= matrix_;
     matrix_ = tmp;
     return true;
   }
 
   bool IsNull() override {
     return SkMatrixIsApproximatelyIdentity(matrix_.matrix());
   }
 
-  void Transform(ColorTransform::TriStim* colors, size_t num) override {
+  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));
+  }
+
  private:
   class Transform matrix_;
 };
 
 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;
   }
   ColorTransformFromLinear* GetFromLinear() override { return this; }
   bool IsNull() override { return transfer_ == ColorSpace::TransferID::LINEAR; }
-  void Transform(ColorTransform::TriStim* colors, size_t num) override {
+  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()));
@@ skipping 47 matching lines @@
     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;
   }
 
-  ColorTransform::TriStim ClipToWhite(ColorTransform::TriStim& c) {
+  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) override {
+  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) {
       for (size_t i = 0; i < num; i++) {
         ColorTransform::TriStim ret(ToLinear(transfer_, colors[i].x()),
                                     ToLinear(transfer_, colors[i].y()),
@@ skipping 43 matching lines @@
     if (!next)
       return false;
     if (null_)
       return false;
     null_ = true;
     return true;
   }
 
   bool IsNull() override { return null_; }
 
-  void Transform(ColorTransform::TriStim* RYB, size_t num) override {
+  void Transform(ColorTransform::TriStim* RYB, size_t num) const override {
     for (size_t i = 0; i < num; i++) {
       float U, V;
       float B_Y = RYB[i].z() - RYB[i].y();
       if (B_Y <= 0) {
         U = B_Y / (-2.0 * -0.9702);
       } else {
         U = B_Y / (2.0 * 0.7910);
       }
       float R_Y = RYB[i].x() - RYB[i].y();
       if (R_Y <= 0) {
@@ skipping 17 matching lines @@
     if (!next)
       return false;
     if (null_)
       return false;
     null_ = true;
     return true;
   }
 
   bool IsNull() override { return null_; }
 
-  void Transform(ColorTransform::TriStim* YUV, size_t num) override {
+  void Transform(ColorTransform::TriStim* YUV, size_t num) const override {
     if (null_)
       return;
     for (size_t i = 0; i < num; i++) {
       float Y = YUV[i].x();
       float U = YUV[i].y();
       float V = YUV[i].z();
       float B_Y, R_Y;
       if (U <= 0) {
         B_Y = Y * (-2.0 * -0.9702);
       } else {
@@ skipping 52 matching lines @@
 
     // TODO(hubbe): shrink gamuts here (never stretch gamuts)
   }
 
   steps_.push_back(
       base::MakeUnique<ColorTransformMatrix>(GetRangeAdjustMatrix(from)));
 
   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.matrix_ == ColorSpace::MatrixID::BT2020_CL) {
     // BT2020 CL is a special case.
     steps_.push_back(base::MakeUnique<ColorTransformFromBT2020CL>());
   }
   steps_.push_back(
@@ skipping 33 matching lines @@
       to_ = std::move(next->to_);
       return true;
     }
     return false;
   }
   bool IsNull() override {
     if (qcms_profile_match(from_.get(), to_.get()))
       return true;
     return false;
   }
-  void Transform(ColorTransform::TriStim* colors, size_t num) override {
+  void Transform(ColorTransform::TriStim* colors, size_t num) const override {
     CHECK(sizeof(ColorTransform::TriStim) == sizeof(float[3]));
     // QCMS doesn't like numbers outside 0..1
     for (size_t i = 0; i < num; i++) {
       colors[i].set_x(min(1.0f, max(0.0f, colors[i].x())));
       colors[i].set_y(min(1.0f, max(0.0f, colors[i].y())));
       colors[i].set_z(min(1.0f, max(0.0f, colors[i].z())));
     }
     qcms_chain_transform(from_.get(), to_.get(),
                          reinterpret_cast<float*>(colors),
                          reinterpret_cast<float*>(colors), num * 3);
@@ skipping 27 matching lines @@
   xyz.green.Y = 1.0f;
   xyz.blue.x = 0.0f;
   xyz.blue.y = 0.0f;
   xyz.blue.Y = 1.0f;
   w.x = 0.34567f;
   w.y = 0.35850f;
   w.Y = 1.0f;
   return ScopedQcmsProfile(qcms_profile_create_rgb_with_gamma(w, xyz, 1.0f));
 }
 
-ColorTransformInternal::ColorTransformInternal(const ColorSpace& from,
-                                               const ColorSpace& to,
-                                               Intent intent) {
+ColorTransformInternal::ColorTransformInternal(const ColorSpace& src,
+                                               const ColorSpace& dst,
+                                               Intent intent)
+    : src_(src), dst_(dst) {
   // If no source color space is specified, do no transformation.
-  // TODO(ccameron): We may want to assume sRGB at some point in the future.
-  if (!from.IsValid())
+  // TODO(ccameron): We may want dst assume sRGB at some point in the future.
+  if (!src_.IsValid())
     return;
 
-  ScopedQcmsProfile from_profile = GetQCMSProfileIfNecessary(from);
-  ScopedQcmsProfile to_profile = GetQCMSProfileIfNecessary(to);
-  bool has_from_profile = !!from_profile;
-  bool has_to_profile = !!to_profile;
+  ScopedQcmsProfile src_profile = GetQCMSProfileIfNecessary(src_);
+  ScopedQcmsProfile dst_profile = GetQCMSProfileIfNecessary(dst_);
+  bool has_src_profile = !!src_profile;
+  bool has_dst_profile = !!dst_profile;
 
-  if (from_profile) {
+  if (src_profile) {
     steps_.push_back(base::MakeUnique<QCMSColorTransform>(
-        std::move(from_profile), GetXYZD50Profile()));
+        std::move(src_profile), GetXYZD50Profile()));
   }
 
   AppendColorSpaceToColorSpaceTransform(
-      has_from_profile ? ColorSpace::CreateXYZD50() : from,
-      has_to_profile ? ColorSpace::CreateXYZD50() : to, intent);
+      has_src_profile ? ColorSpace::CreateXYZD50() : src_,
+      has_dst_profile ? ColorSpace::CreateXYZD50() : dst_, intent);
 
-  if (to_profile) {
+  if (dst_profile) {
     steps_.push_back(base::MakeUnique<QCMSColorTransform>(
-        GetXYZD50Profile(), std::move(to_profile)));
+        GetXYZD50Profile(), std::move(dst_profile)));
   }
 
   if (intent != Intent::TEST_NO_OPT)
     Simplify();
 }
 
+std::string ColorTransformInternal::GetShaderSource() const {
+  std::string result;
+  result += "vec3 DoColorConversion(vec3 color) {\n";
+  for (const auto& step : steps_)
+    step->AppendShaderSource(&result);
+  result += "  return color;\n";
+  result += "}\n";
+  return result;
+}
+
+bool ColorTransformInternal::CanGetShaderSource() const {
+  for (const auto& step : steps_) {
+    if (!step->CanAppendShaderSource())
+      return false;
+  }
+  return true;
+}
+
 ColorTransformInternal::~ColorTransformInternal() {}
 
 void ColorTransformInternal::Simplify() {
   for (auto iter = steps_.begin(); iter != steps_.end();) {
     std::unique_ptr<ColorTransformStep>& this_step = *iter;
 
     // Try to Join |next_step| into |this_step|. If successful, re-visit the
     // step before |this_step|.
     auto iter_next = iter;
     iter_next++;
@@ skipping 26 matching lines @@
     const ColorSpace& to,
     Intent intent) {
   return std::unique_ptr<ColorTransform>(
       new ColorTransformInternal(from, to, intent));
 }
 
 ColorTransform::ColorTransform() {}
 ColorTransform::~ColorTransform() {}
 
 }  // namespace gfx