ui/gfx/color_conversions.cc - chromium/src.git - Git at Google

 // Copyright 2012 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "ui/gfx/color_conversions.h"

 #include <cmath>
 #include <numeric>
 #include <tuple>

 #include "base/compiler_specific.h"
 #include "base/numerics/angle_conversions.h"
 #include "skia/ext/skcms_ext.h"
 #include "skia/ext/skcolorspace_primaries.h"
 #include "skia/ext/skcolorspace_trfn.h"
 #include "third_party/skia/include/core/SkColorSpace.h"
 #include "third_party/skia/modules/skcms/skcms.h"
 #include "ui/gfx/color_space.h"

 namespace gfx {

 // Namespace containing some of the helper methods for color conversions.
 namespace {
 // https://en.wikipedia.org/wiki/CIELAB_color_space#Converting_between_CIELAB_and_CIEXYZ_coordinates
 constexpr float kD50_x = 0.9642f;
 constexpr float kD50_y = 1.0f;
 constexpr float kD50_z = 0.8251f;

 // Power function extended to all real numbers by point symmetry.
 float powExt(float x, float p) {
   if (x < 0) {
     return -powf(-x, p);
   } else {
     return powf(x, p);
   }
 }

 skcms_Matrix3x3 getXYDZ65toXYZD50matrix() {
   constexpr float kD65_x = 0.3127f;
   constexpr float kD65_y = 0.3290f;
   skcms_Matrix3x3 adapt_d65_to_d50;
   skcms_AdaptToXYZD50(kD65_x, kD65_y, &adapt_d65_to_d50);
   return adapt_d65_to_d50;
 }

 const skcms_Matrix3x3 kXYZD65_to_LMS = {
     {{0.8190224432164319f, 0.3619062562801221f, -0.12887378261216414f},
      {0.0329836671980271f, 0.9292868468965546f, 0.03614466816999844f},
      {0.048177199566046255f, 0.26423952494422764f, 0.6335478258136937f}}};

 const skcms_Matrix3x3 kOklab_to_LMS = {
     {{0.99999999845051981432f, 0.39633779217376785678f,
       0.21580375806075880339f},
      {1.0000000088817607767f, -0.1055613423236563494f,
       -0.063854174771705903402f},
      {1.0000000546724109177f, -0.089484182094965759684f,
       -1.2914855378640917399f}}};

 typedef struct {
   std::array<float, 2> vals;
 } skcms_Vector2;

 float dot(const skcms_Vector2& a, const skcms_Vector2& b) {
   return a.vals[0] * b.vals[0] + a.vals[1] * b.vals[1];
 }

 std::tuple<float, float, float> ToTuple(const skcms::Vector3& v) {
   return std::make_tuple(v.vals[0], v.vals[1], v.vals[2]);
 }

 }  // namespace

 std::tuple<float, float, float> LabToXYZD50(float l, float a, float b) {
   float y = (l + 16.0f) / 116.0f;
   float x = y + a / 500.0f;
   float z = y - b / 200.0f;

   auto LabInverseTransferFunction = [](float t) {
     constexpr float delta = (24.0f / 116.0f);

     if (t <= delta) {
       return (108.0f / 841.0f) * (t - (16.0f / 116.0f));
     }

     return t * t * t;
   };

   x = LabInverseTransferFunction(x) * kD50_x;
   y = LabInverseTransferFunction(y) * kD50_y;
   z = LabInverseTransferFunction(z) * kD50_z;

   return std::make_tuple(x, y, z);
 }

 std::tuple<float, float, float> XYZD50ToLab(float x, float y, float z) {
   auto LabTransferFunction = [](float t) {
     constexpr float delta_limit =
         (24.0f / 116.0f) * (24.0f / 116.0f) * (24.0f / 116.0f);

     if (t <= delta_limit)
       return (841.0f / 108.0f) * t + (16.0f / 116.0f);
     else
       return std::pow(t, 1.0f / 3.0f);
   };

   x = LabTransferFunction(x / kD50_x);
   y = LabTransferFunction(y / kD50_y);
   z = LabTransferFunction(z / kD50_z);

   float l = 116.0f * y - 16.0f;
   float a = 500.0f * (x - y);
   float b = 200.0f * (y - z);

   return std::make_tuple(l, a, b);
 }

 // Projects the color (l,a,b) to be within a polyhedral approximation of the
 // Rec2020 gamut. This is done by finding the maximum value of alpha such that
 // (l, alpha*a, alpha*b) is within that polyhedral approximation.
 std::tuple<float, float, float> OklabGamutMap(float l, float a, float b) {
   // Constants for the normal vector of the plane formed by white, black, and
   // the specified vertex of the gamut.
   const skcms_Vector2 normal_R{{0.409702, -0.912219}};
   const skcms_Vector2 normal_M{{-0.397919, -0.917421}};
   const skcms_Vector2 normal_B{{-0.906800, 0.421562}};
   const skcms_Vector2 normal_C{{-0.171122, 0.985250}};
   const skcms_Vector2 normal_G{{0.460276, 0.887776}};
   const skcms_Vector2 normal_Y{{0.947925, 0.318495}};

   // For the triangles formed by white (W) or black (K) with the vertices
   // of Yellow and Red (YR), Red and Magenta (RM), etc, the constants to be
   // used to compute the intersection of a line of constant hue and luminance
   // with that plane.
   const float c0_YR = 0.091132;
   const skcms_Vector2 cW_YR{{0.070370, 0.034139}};
   const skcms_Vector2 cK_YR{{0.018170, 0.378550}};
   const float c0_RM = 0.113902;
   const skcms_Vector2 cW_RM{{0.090836, 0.036251}};
   const skcms_Vector2 cK_RM{{0.226781, 0.018764}};
   const float c0_MB = 0.161739;
   const skcms_Vector2 cW_MB{{-0.008202, -0.264819}};
   const skcms_Vector2 cK_MB{{0.187156, -0.284304}};
   const float c0_BC = 0.102047;
   const skcms_Vector2 cW_BC{{-0.014804, -0.162608}};
   const skcms_Vector2 cK_BC{{-0.276786, 0.004193}};
   const float c0_CG = 0.092029;
   const skcms_Vector2 cW_CG{{-0.038533, -0.001650}};
   const skcms_Vector2 cK_CG{{-0.232572, -0.094331}};
   const float c0_GY = 0.081709;
   const skcms_Vector2 cW_GY{{-0.034601, -0.002215}};
   const skcms_Vector2 cK_GY{{0.012185, 0.338031}};

   const float L = l;
   const float one_minus_L = 1.0 - L;
   const skcms_Vector2 ab{{a, b}};

   // Find the planes to intersect with and set the constants based on those
   // planes.
   float c0 = 0.f;
   skcms_Vector2 cW{{0.f, 0.f}};
   skcms_Vector2 cK{{0.f, 0.f}};
   if (dot(ab, normal_R) < 0.0) {
     if (dot(ab, normal_G) < 0.0) {
       if (dot(ab, normal_C) < 0.0) {
         c0 = c0_BC;
         cW = cW_BC;
         cK = cK_BC;
       } else {
         c0 = c0_CG;
         cW = cW_CG;
         cK = cK_CG;
       }
     } else {
       if (dot(ab, normal_Y) < 0.0) {
         c0 = c0_GY;
         cW = cW_GY;
         cK = cK_GY;
       } else {
         c0 = c0_YR;
         cW = cW_YR;
         cK = cK_YR;
       }
     }
   } else {
     if (dot(ab, normal_B) < 0.0) {
       if (dot(ab, normal_M) < 0.0) {
         c0 = c0_RM;
         cW = cW_RM;
         cK = cK_RM;
       } else {
         c0 = c0_MB;
         cW = cW_MB;
         cK = cK_MB;
       }
     } else {
       c0 = c0_BC;
       cW = cW_BC;
       cK = cK_BC;
     }
   }

   // Perform the intersection.
   float alpha = 1.f;

   // Intersect with the plane with white.
   const float w_denom = dot(cW, ab);
   if (w_denom > 0.f) {
     const float w_num = c0 * one_minus_L;
     if (w_num < w_denom) {
       alpha = std::min(alpha, w_num / w_denom);
     }
   }

   // Intersect with the plane with black.
   const float k_denom = dot(cK, ab);
   if (k_denom > 0.f) {
     const float k_num = c0 * L;
     if (k_num < k_denom) {
       alpha = std::min(alpha, k_num / k_denom);
     }
   }

   // Attenuate the ab coordinate by alpha.
   return std::make_tuple(L, alpha * a, alpha * b);
 }

 std::tuple<float, float, float> OklabToXYZD50(float l,
                                               float a,
                                               float b,
                                               bool gamut_map) {
   if (gamut_map) {
     std::tie(l, a, b) = OklabGamutMap(l, a, b);
   }
   // See definition of Oklab space at.
   // https://bottosson.github.io/posts/oklab/
   const skcms::Vector3 lab_input{{l, a, b}};
   const auto lms = skcms::Matrix3x3_apply(kOklab_to_LMS, lab_input);
   const skcms::Vector3 lms_cubed{{
       lms.vals[0] * lms.vals[0] * lms.vals[0],
       lms.vals[1] * lms.vals[1] * lms.vals[1],
       lms.vals[2] * lms.vals[2] * lms.vals[2],
   }};
   const auto xyz_d65 =
       skcms::Matrix3x3_apply_inverse(kXYZD65_to_LMS, lms_cubed);
   // Oklab's LMS matrix is defined with respect to D65 primaries, and needs
   // chromatic adaptation to D50.
   const auto xyz = skcms::Matrix3x3_apply(getXYDZ65toXYZD50matrix(), xyz_d65);
   return std::make_tuple(xyz.vals[0], xyz.vals[1], xyz.vals[2]);
 }

 std::tuple<float, float, float> XYZD50ToOklab(float x, float y, float z) {
   const skcms::Vector3 xyz{{x, y, z}};
   const auto xyz_d65 =
       skcms::Matrix3x3_apply_inverse(getXYDZ65toXYZD50matrix(), xyz);
   const auto lms_cubed = skcms::Matrix3x3_apply(kXYZD65_to_LMS, xyz_d65);
   const skcms::Vector3 lms{{
       powExt(lms_cubed.vals[0], 1.0f / 3.0f),
       powExt(lms_cubed.vals[1], 1.0f / 3.0f),
       powExt(lms_cubed.vals[2], 1.0f / 3.0f),
   }};
   const auto oklab = skcms::Matrix3x3_apply_inverse(kOklab_to_LMS, lms);
   return std::make_tuple(oklab.vals[0], oklab.vals[1], oklab.vals[2]);
 }

 std::tuple<float, float, float> LchToLab(float l, float c, float h) {
   return std::make_tuple(l, c * std::cos(base::DegToRad(h)),
                          c * std::sin(base::DegToRad(h)));
 }
 std::tuple<float, float, float> LabToLch(float l, float a, float b) {
   return std::make_tuple(l, std::sqrt(a * a + b * b),
                          base::RadToDeg(atan2f(b, a)));
 }

 std::tuple<float, float, float> SRGBToSRGBLegacy(float r, float g, float b) {
   return std::make_tuple(r * 255.0, g * 255.0, b * 255.0);
 }

 std::tuple<float, float, float> SRGBLegacyToSRGB(float r, float g, float b) {
   return std::make_tuple(r / 255.0, g / 255.0, b / 255.0);
 }

 std::tuple<float, float, float> XYZD50ToSRGB(float x, float y, float z) {
   skcms::Vector3 c{{x, y, z}};
   c = skcms::Matrix3x3_apply_inverse(SkNamedGamut::kSRGB, c);
   c = skcms::TransferFunction_apply_inverse(SkNamedTransferFn::kSRGB, c);
   return ToTuple(c);
 }

 std::tuple<float, float, float> SRGBToXYZD50(float r, float g, float b) {
   skcms::Vector3 c{{r, g, b}};
   c = skcms::TransferFunction_apply(SkNamedTransferFn::kSRGB, c);
   c = skcms::Matrix3x3_apply(SkNamedGamut::kSRGB, c);
   return ToTuple(c);
 }

 std::tuple<float, float, float> HSLToSRGB(float h, float s, float l) {
   // See https://www.w3.org/TR/css-color-4/#hsl-to-rgb
   if (!s) {
     return std::make_tuple(l, l, l);
   }

   auto f = [&h, &l, &s](float n) {
     float k = fmod(n + h / 30.0f, 12.0);
     float a = s * std::min(l, 1.0f - l);
     return l - a * std::max(-1.0f, std::min({k - 3.0f, 9.0f - k, 1.0f}));
   };

   return std::make_tuple(f(0), f(8), f(4));
 }

 std::tuple<float, float, float> SRGBToHSL(float r, float g, float b) {
   // See https://drafts.csswg.org/css-color-4/#rgb-to-hsl
   // TODO(crbug.com/329301908): check if there's any change after this draft
   // becomes settled.
   auto [min, max] = std::minmax({r, g, b});
   float hue = 0.0f, saturation = 0.0f, lightness = std::midpoint(min, max);
   float d = max - min;

   if (d != 0.0f) {
     saturation = (lightness == 0.0f || lightness == 1.0f)
                      ? 0.0f
                      : (max - lightness) / std::min(lightness, 1 - lightness);
     if (max == r) {
       hue = (g - b) / d + (g < b ? 6.0f : 0.0f);
     } else if (max == g) {
       hue = (b - r) / d + 2.0f;
     } else {  // if(max == b)
       hue = (r - g) / d + 4.0f;
     }
     hue *= 60.0f;
   }

   // Very out of gamut colors can produce negative saturation.
   // If so, just rotate the hue by 180 and use a positive saturation.
   // See https://github.com/w3c/csswg-drafts/issues/9222
   if (saturation < 0) {
     hue += 180;
     saturation = std::abs(saturation);
   }

   if (hue >= 360) {
     hue -= 360;
   }

   return std::make_tuple(hue, saturation, lightness);
 }

 std::tuple<float, float, float> HWBToSRGB(float h, float w, float b) {
   if (w + b >= 1.0f) {
     float gray = (w / (w + b));
     return std::make_tuple(gray, gray, gray);
   }

   // Leverage HSL to RGB conversion to find HWB to RGB, see
   // https://drafts.csswg.org/css-color-4/#hwb-to-rgb
   auto [red, green, blue] = HSLToSRGB(h, 1.0f, 0.5f);

   red += w - (w + b) * red;
   green += w - (w + b) * green;
   blue += w - (w + b) * blue;

   return std::make_tuple(red, green, blue);
 }

 static inline float SRGBToHue(float r, float g, float b) {
   // See https://drafts.csswg.org/css-color-4/#rgb-to-hwb
   // Similar to rgbToHsl, except that saturation and lightness are not
   // calculated, and potential negative saturation is ignored.
   // TODO(crbug.com/329301908): check if there's any change after this draft
   // becomes settled.
   auto [min, max] = std::minmax({r, g, b});
   float hue = 0.0f;
   float d = max - min;

   if (d != 0) {
     if (max == r) {
       hue = (g - b) / d + (g < b ? 6 : 0);
     } else if (max == g) {
       hue = (b - r) / d + 2;
     } else {
       hue = (r - g) / d + 4;
     }

     hue *= 60;
   }

   if (hue >= 360) {
     hue -= 360;
   }

   return hue;
 }

 std::tuple<float, float, float> SRGBToHWB(float r, float g, float b) {
   // See https://drafts.csswg.org/css-color-4/#rgb-to-hwb
   // TODO(crbug.com/329301908): check if there's any change after this draft
   // becomes settled.
   float hue = SRGBToHue(r, g, b);
   float white = std::min({r, g, b});
   float black = 1.0f - std::max({r, g, b});

   return std::make_tuple(hue, white, black);
 }

 SkColor4f SRGBLinearToSkColor4f(float r, float g, float b, float alpha) {
   // Several SVG rendering tests expect the inaccurate results from this
   // formulation and need to be rebaselined.
   // https://crbug.com/450045076
   skcms_TransferFunction tf_inv;
   skcms_TransferFunction_invert(&SkNamedTransferFn::kSRGB, &tf_inv);
   return SkColor4f{skcms_TransferFunction_eval(&tf_inv, r),
                    skcms_TransferFunction_eval(&tf_inv, g),
                    skcms_TransferFunction_eval(&tf_inv, b), alpha};
 }

 }  // namespace gfx
	// Copyright 2012 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "ui/gfx/color_conversions.h"

	#include <cmath>
	#include <numeric>
	#include <tuple>

	#include "base/compiler_specific.h"
	#include "base/numerics/angle_conversions.h"
	#include "skia/ext/skcms_ext.h"
	#include "skia/ext/skcolorspace_primaries.h"
	#include "skia/ext/skcolorspace_trfn.h"
	#include "third_party/skia/include/core/SkColorSpace.h"
	#include "third_party/skia/modules/skcms/skcms.h"
	#include "ui/gfx/color_space.h"

	namespace gfx {

	// Namespace containing some of the helper methods for color conversions.
	namespace {
	// https://en.wikipedia.org/wiki/CIELAB_color_space#Converting_between_CIELAB_and_CIEXYZ_coordinates
	constexpr float kD50_x = 0.9642f;
	constexpr float kD50_y = 1.0f;
	constexpr float kD50_z = 0.8251f;

	// Power function extended to all real numbers by point symmetry.
	float powExt(float x, float p) {
	if (x < 0) {
	return -powf(-x, p);
	} else {
	return powf(x, p);
	}
	}

	skcms_Matrix3x3 getXYDZ65toXYZD50matrix() {
	constexpr float kD65_x = 0.3127f;
	constexpr float kD65_y = 0.3290f;
	skcms_Matrix3x3 adapt_d65_to_d50;
	skcms_AdaptToXYZD50(kD65_x, kD65_y, &adapt_d65_to_d50);
	return adapt_d65_to_d50;
	}

	const skcms_Matrix3x3 kXYZD65_to_LMS = {
	{{0.8190224432164319f, 0.3619062562801221f, -0.12887378261216414f},
	{0.0329836671980271f, 0.9292868468965546f, 0.03614466816999844f},
	{0.048177199566046255f, 0.26423952494422764f, 0.6335478258136937f}}};

	const skcms_Matrix3x3 kOklab_to_LMS = {
	{{0.99999999845051981432f, 0.39633779217376785678f,
	0.21580375806075880339f},
	{1.0000000088817607767f, -0.1055613423236563494f,
	-0.063854174771705903402f},
	{1.0000000546724109177f, -0.089484182094965759684f,
	-1.2914855378640917399f}}};

	typedef struct {
	std::array<float, 2> vals;
	} skcms_Vector2;

	float dot(const skcms_Vector2& a, const skcms_Vector2& b) {
	return a.vals[0] * b.vals[0] + a.vals[1] * b.vals[1];
	}

	std::tuple<float, float, float> ToTuple(const skcms::Vector3& v) {
	return std::make_tuple(v.vals[0], v.vals[1], v.vals[2]);
	}

	} // namespace

	std::tuple<float, float, float> LabToXYZD50(float l, float a, float b) {
	float y = (l + 16.0f) / 116.0f;
	float x = y + a / 500.0f;
	float z = y - b / 200.0f;

	auto LabInverseTransferFunction = [](float t) {
	constexpr float delta = (24.0f / 116.0f);

	if (t <= delta) {
	return (108.0f / 841.0f) * (t - (16.0f / 116.0f));
	}

	return t * t * t;
	};

	x = LabInverseTransferFunction(x) * kD50_x;
	y = LabInverseTransferFunction(y) * kD50_y;
	z = LabInverseTransferFunction(z) * kD50_z;

	return std::make_tuple(x, y, z);
	}

	std::tuple<float, float, float> XYZD50ToLab(float x, float y, float z) {
	auto LabTransferFunction = [](float t) {
	constexpr float delta_limit =
	(24.0f / 116.0f) * (24.0f / 116.0f) * (24.0f / 116.0f);

	if (t <= delta_limit)
	return (841.0f / 108.0f) * t + (16.0f / 116.0f);
	else
	return std::pow(t, 1.0f / 3.0f);
	};

	x = LabTransferFunction(x / kD50_x);
	y = LabTransferFunction(y / kD50_y);
	z = LabTransferFunction(z / kD50_z);

	float l = 116.0f * y - 16.0f;
	float a = 500.0f * (x - y);
	float b = 200.0f * (y - z);

	return std::make_tuple(l, a, b);
	}

	// Projects the color (l,a,b) to be within a polyhedral approximation of the
	// Rec2020 gamut. This is done by finding the maximum value of alpha such that
	// (l, alphaa, alphab) is within that polyhedral approximation.
	std::tuple<float, float, float> OklabGamutMap(float l, float a, float b) {
	// Constants for the normal vector of the plane formed by white, black, and
	// the specified vertex of the gamut.
	const skcms_Vector2 normal_R{{0.409702, -0.912219}};
	const skcms_Vector2 normal_M{{-0.397919, -0.917421}};
	const skcms_Vector2 normal_B{{-0.906800, 0.421562}};
	const skcms_Vector2 normal_C{{-0.171122, 0.985250}};
	const skcms_Vector2 normal_G{{0.460276, 0.887776}};
	const skcms_Vector2 normal_Y{{0.947925, 0.318495}};

	// For the triangles formed by white (W) or black (K) with the vertices
	// of Yellow and Red (YR), Red and Magenta (RM), etc, the constants to be
	// used to compute the intersection of a line of constant hue and luminance
	// with that plane.
	const float c0_YR = 0.091132;
	const skcms_Vector2 cW_YR{{0.070370, 0.034139}};
	const skcms_Vector2 cK_YR{{0.018170, 0.378550}};
	const float c0_RM = 0.113902;
	const skcms_Vector2 cW_RM{{0.090836, 0.036251}};
	const skcms_Vector2 cK_RM{{0.226781, 0.018764}};
	const float c0_MB = 0.161739;
	const skcms_Vector2 cW_MB{{-0.008202, -0.264819}};
	const skcms_Vector2 cK_MB{{0.187156, -0.284304}};
	const float c0_BC = 0.102047;
	const skcms_Vector2 cW_BC{{-0.014804, -0.162608}};
	const skcms_Vector2 cK_BC{{-0.276786, 0.004193}};
	const float c0_CG = 0.092029;
	const skcms_Vector2 cW_CG{{-0.038533, -0.001650}};
	const skcms_Vector2 cK_CG{{-0.232572, -0.094331}};
	const float c0_GY = 0.081709;
	const skcms_Vector2 cW_GY{{-0.034601, -0.002215}};
	const skcms_Vector2 cK_GY{{0.012185, 0.338031}};

	const float L = l;
	const float one_minus_L = 1.0 - L;
	const skcms_Vector2 ab{{a, b}};

	// Find the planes to intersect with and set the constants based on those
	// planes.
	float c0 = 0.f;
	skcms_Vector2 cW{{0.f, 0.f}};
	skcms_Vector2 cK{{0.f, 0.f}};
	if (dot(ab, normal_R) < 0.0) {
	if (dot(ab, normal_G) < 0.0) {
	if (dot(ab, normal_C) < 0.0) {
	c0 = c0_BC;
	cW = cW_BC;
	cK = cK_BC;
	} else {
	c0 = c0_CG;
	cW = cW_CG;
	cK = cK_CG;
	}
	} else {
	if (dot(ab, normal_Y) < 0.0) {
	c0 = c0_GY;
	cW = cW_GY;
	cK = cK_GY;
	} else {
	c0 = c0_YR;
	cW = cW_YR;
	cK = cK_YR;
	}
	}
	} else {
	if (dot(ab, normal_B) < 0.0) {
	if (dot(ab, normal_M) < 0.0) {
	c0 = c0_RM;
	cW = cW_RM;
	cK = cK_RM;
	} else {
	c0 = c0_MB;
	cW = cW_MB;
	cK = cK_MB;
	}
	} else {
	c0 = c0_BC;
	cW = cW_BC;
	cK = cK_BC;
	}
	}

	// Perform the intersection.
	float alpha = 1.f;

	// Intersect with the plane with white.
	const float w_denom = dot(cW, ab);
	if (w_denom > 0.f) {
	const float w_num = c0 * one_minus_L;
	if (w_num < w_denom) {
	alpha = std::min(alpha, w_num / w_denom);
	}
	}

	// Intersect with the plane with black.
	const float k_denom = dot(cK, ab);
	if (k_denom > 0.f) {
	const float k_num = c0 * L;
	if (k_num < k_denom) {
	alpha = std::min(alpha, k_num / k_denom);
	}
	}

	// Attenuate the ab coordinate by alpha.
	return std::make_tuple(L, alpha * a, alpha * b);
	}

	std::tuple<float, float, float> OklabToXYZD50(float l,
	float a,
	float b,
	bool gamut_map) {
	if (gamut_map) {
	std::tie(l, a, b) = OklabGamutMap(l, a, b);
	}
	// See definition of Oklab space at.
	// https://bottosson.github.io/posts/oklab/
	const skcms::Vector3 lab_input{{l, a, b}};
	const auto lms = skcms::Matrix3x3_apply(kOklab_to_LMS, lab_input);
	const skcms::Vector3 lms_cubed{{
	lms.vals[0] * lms.vals[0] * lms.vals[0],
	lms.vals[1] * lms.vals[1] * lms.vals[1],
	lms.vals[2] * lms.vals[2] * lms.vals[2],
	}};
	const auto xyz_d65 =
	skcms::Matrix3x3_apply_inverse(kXYZD65_to_LMS, lms_cubed);
	// Oklab's LMS matrix is defined with respect to D65 primaries, and needs
	// chromatic adaptation to D50.
	const auto xyz = skcms::Matrix3x3_apply(getXYDZ65toXYZD50matrix(), xyz_d65);
	return std::make_tuple(xyz.vals[0], xyz.vals[1], xyz.vals[2]);
	}

	std::tuple<float, float, float> XYZD50ToOklab(float x, float y, float z) {
	const skcms::Vector3 xyz{{x, y, z}};
	const auto xyz_d65 =
	skcms::Matrix3x3_apply_inverse(getXYDZ65toXYZD50matrix(), xyz);
	const auto lms_cubed = skcms::Matrix3x3_apply(kXYZD65_to_LMS, xyz_d65);
	const skcms::Vector3 lms{{
	powExt(lms_cubed.vals[0], 1.0f / 3.0f),
	powExt(lms_cubed.vals[1], 1.0f / 3.0f),
	powExt(lms_cubed.vals[2], 1.0f / 3.0f),
	}};
	const auto oklab = skcms::Matrix3x3_apply_inverse(kOklab_to_LMS, lms);
	return std::make_tuple(oklab.vals[0], oklab.vals[1], oklab.vals[2]);
	}

	std::tuple<float, float, float> LchToLab(float l, float c, float h) {
	return std::make_tuple(l, c * std::cos(base::DegToRad(h)),
	c * std::sin(base::DegToRad(h)));
	}
	std::tuple<float, float, float> LabToLch(float l, float a, float b) {
	return std::make_tuple(l, std::sqrt(a * a + b * b),
	base::RadToDeg(atan2f(b, a)));
	}

	std::tuple<float, float, float> SRGBToSRGBLegacy(float r, float g, float b) {
	return std::make_tuple(r * 255.0, g * 255.0, b * 255.0);
	}

	std::tuple<float, float, float> SRGBLegacyToSRGB(float r, float g, float b) {
	return std::make_tuple(r / 255.0, g / 255.0, b / 255.0);
	}

	std::tuple<float, float, float> XYZD50ToSRGB(float x, float y, float z) {
	skcms::Vector3 c{{x, y, z}};
	c = skcms::Matrix3x3_apply_inverse(SkNamedGamut::kSRGB, c);
	c = skcms::TransferFunction_apply_inverse(SkNamedTransferFn::kSRGB, c);
	return ToTuple(c);
	}

	std::tuple<float, float, float> SRGBToXYZD50(float r, float g, float b) {
	skcms::Vector3 c{{r, g, b}};
	c = skcms::TransferFunction_apply(SkNamedTransferFn::kSRGB, c);
	c = skcms::Matrix3x3_apply(SkNamedGamut::kSRGB, c);
	return ToTuple(c);
	}

	std::tuple<float, float, float> HSLToSRGB(float h, float s, float l) {
	// See https://www.w3.org/TR/css-color-4/#hsl-to-rgb
	if (!s) {
	return std::make_tuple(l, l, l);
	}

	auto f = [&h, &l, &s](float n) {
	float k = fmod(n + h / 30.0f, 12.0);
	float a = s * std::min(l, 1.0f - l);
	return l - a * std::max(-1.0f, std::min({k - 3.0f, 9.0f - k, 1.0f}));
	};

	return std::make_tuple(f(0), f(8), f(4));
	}

	std::tuple<float, float, float> SRGBToHSL(float r, float g, float b) {
	// See https://drafts.csswg.org/css-color-4/#rgb-to-hsl
	// TODO(crbug.com/329301908): check if there's any change after this draft
	// becomes settled.
	auto [min, max] = std::minmax({r, g, b});
	float hue = 0.0f, saturation = 0.0f, lightness = std::midpoint(min, max);
	float d = max - min;

	if (d != 0.0f) {
	saturation = (lightness == 0.0f \|\| lightness == 1.0f)
	? 0.0f
	: (max - lightness) / std::min(lightness, 1 - lightness);
	if (max == r) {
	hue = (g - b) / d + (g < b ? 6.0f : 0.0f);
	} else if (max == g) {
	hue = (b - r) / d + 2.0f;
	} else { // if(max == b)
	hue = (r - g) / d + 4.0f;
	}
	hue *= 60.0f;
	}

	// Very out of gamut colors can produce negative saturation.
	// If so, just rotate the hue by 180 and use a positive saturation.
	// See https://github.com/w3c/csswg-drafts/issues/9222
	if (saturation < 0) {
	hue += 180;
	saturation = std::abs(saturation);
	}

	if (hue >= 360) {
	hue -= 360;
	}

	return std::make_tuple(hue, saturation, lightness);
	}

	std::tuple<float, float, float> HWBToSRGB(float h, float w, float b) {
	if (w + b >= 1.0f) {
	float gray = (w / (w + b));
	return std::make_tuple(gray, gray, gray);
	}

	// Leverage HSL to RGB conversion to find HWB to RGB, see
	// https://drafts.csswg.org/css-color-4/#hwb-to-rgb
	auto [red, green, blue] = HSLToSRGB(h, 1.0f, 0.5f);

	red += w - (w + b) * red;
	green += w - (w + b) * green;
	blue += w - (w + b) * blue;

	return std::make_tuple(red, green, blue);
	}

	static inline float SRGBToHue(float r, float g, float b) {
	// See https://drafts.csswg.org/css-color-4/#rgb-to-hwb
	// Similar to rgbToHsl, except that saturation and lightness are not
	// calculated, and potential negative saturation is ignored.
	// TODO(crbug.com/329301908): check if there's any change after this draft
	// becomes settled.
	auto [min, max] = std::minmax({r, g, b});
	float hue = 0.0f;
	float d = max - min;

	if (d != 0) {
	if (max == r) {
	hue = (g - b) / d + (g < b ? 6 : 0);
	} else if (max == g) {
	hue = (b - r) / d + 2;
	} else {
	hue = (r - g) / d + 4;
	}

	hue *= 60;
	}

	if (hue >= 360) {
	hue -= 360;
	}

	return hue;
	}

	std::tuple<float, float, float> SRGBToHWB(float r, float g, float b) {
	// See https://drafts.csswg.org/css-color-4/#rgb-to-hwb
	// TODO(crbug.com/329301908): check if there's any change after this draft
	// becomes settled.
	float hue = SRGBToHue(r, g, b);
	float white = std::min({r, g, b});
	float black = 1.0f - std::max({r, g, b});

	return std::make_tuple(hue, white, black);
	}

	SkColor4f SRGBLinearToSkColor4f(float r, float g, float b, float alpha) {
	// Several SVG rendering tests expect the inaccurate results from this
	// formulation and need to be rebaselined.
	// https://crbug.com/450045076
	skcms_TransferFunction tf_inv;
	skcms_TransferFunction_invert(&SkNamedTransferFn::kSRGB, &tf_inv);
	return SkColor4f{skcms_TransferFunction_eval(&tf_inv, r),
	skcms_TransferFunction_eval(&tf_inv, g),
	skcms_TransferFunction_eval(&tf_inv, b), alpha};
	}

	} // namespace gfx