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 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 {
     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_;
 };
 
+#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 {}
+  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 {
     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(%f, %f, %f, %f, %f, %f, %f, %f, %f) * 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(%f, %f, %f);", 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) {
@@ skipping 255 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 112 matching lines @@
 
   if (to_profile) {
     steps_.push_back(base::MakeUnique<QCMSColorTransform>(
         GetXYZD50Profile(), std::move(to_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