Diff
Modified: trunk/Source/WebCore/ChangeLog (272032 => 272033)
--- trunk/Source/WebCore/ChangeLog 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/ChangeLog 2021-01-28 20:50:10 UTC (rev 272033)
@@ -1,3 +1,23 @@
+2021-01-28 Sam Weinig <wei...@apple.com>
+
+ Sort colors in ColorTypes.h alphabetically
+ https://bugs.webkit.org/show_bug.cgi?id=221073
+
+ Reviewed by Darin Adler.
+
+ * css/CSSValueKeywords.in:
+ * css/parser/CSSPropertyParserHelpers.cpp:
+ * platform/graphics/ColorConversion.cpp:
+ * platform/graphics/ColorConversion.h:
+ * platform/graphics/ColorSerialization.cpp:
+ * platform/graphics/ColorSerialization.h:
+ * platform/graphics/ColorSpace.cpp:
+ * platform/graphics/ColorSpace.h:
+ * platform/graphics/ColorTypes.h:
+ * platform/graphics/cg/ColorSpaceCG.cpp:
+ * platform/graphics/cg/ColorSpaceCG.h:
+ Sort things a bit more alphabetically.
+
2021-01-28 Fujii Hironori <hironori.fu...@sony.com>
Remove the dead code of USE(WINGDI)
Modified: trunk/Source/WebCore/css/CSSValueKeywords.in (272032 => 272033)
--- trunk/Source/WebCore/css/CSSValueKeywords.in 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/css/CSSValueKeywords.in 2021-01-28 20:50:10 UTC (rev 272033)
@@ -1403,12 +1403,13 @@
// color-gamut
p3
rec2020
+sRGB
// color() function
-sRGB
+a98-rgb
display-p3
-a98-rgb
// lab
+// sRGB
// prefers-default-appearance
prefers
Modified: trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp (272032 => 272033)
--- trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp 2021-01-28 20:50:10 UTC (rev 272033)
@@ -877,7 +877,7 @@
template<typename ColorType>
static Color parseColorFunctionForRGBTypes(CSSParserTokenRange& args)
{
- ASSERT(args.peek().id() == CSSValueSRGB || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueA98Rgb);
+ ASSERT(args.peek().id() == CSSValueA98Rgb || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueSRGB);
consumeIdentRaw(args);
double channels[3] = { 0, 0, 0 };
@@ -935,18 +935,18 @@
Color color;
switch (args.peek().id()) {
- case CSSValueSRGB:
- color = parseColorFunctionForRGBTypes<SRGBA<float>>(args);
+ case CSSValueA98Rgb:
+ color = parseColorFunctionForRGBTypes<A98RGB<float>>(args);
break;
case CSSValueDisplayP3:
color = parseColorFunctionForRGBTypes<DisplayP3<float>>(args);
break;
- case CSSValueA98Rgb:
- color = parseColorFunctionForRGBTypes<A98RGB<float>>(args);
- break;
case CSSValueLab:
color = parseColorFunctionForLabParameters(args);
break;
+ case CSSValueSRGB:
+ color = parseColorFunctionForRGBTypes<SRGBA<float>>(args);
+ break;
default:
return { };
}
Modified: trunk/Source/WebCore/platform/graphics/ColorConversion.cpp (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorConversion.cpp 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorConversion.cpp 2021-01-28 20:50:10 UTC (rev 272033)
@@ -32,22 +32,24 @@
namespace WebCore {
-// https://en.wikipedia.org/wiki/SRGB
-// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
-static constexpr ColorMatrix<3, 3> xyzToLinearSRGBMatrix {
- 3.2404542f, -1.5371385f, -0.4985314f,
- -0.9692660f, 1.8760108f, 0.0415560f,
- 0.0556434f, -0.2040259f, 1.0572252f
+// A98RGB Matrices.
+
+// https://drafts.csswg.org/css-color/#color-conversion-code
+static constexpr ColorMatrix<3, 3> xyzToLinearA98RGBMatrix {
+ 2.493496911941425f, -0.9313836179191239f, -0.4027107844507168f,
+ -0.8294889695615747f, 1.7626640603183463f, 0.0236246858419436f,
+ 0.0358458302437845f, -0.0761723892680418f, 0.9568845240076872f
};
-// https://en.wikipedia.org/wiki/SRGB
-// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
-static constexpr ColorMatrix<3, 3> linearSRGBToXYZMatrix {
- 0.4124564f, 0.3575761f, 0.1804375f,
- 0.2126729f, 0.7151522f, 0.0721750f,
- 0.0193339f, 0.1191920f, 0.9503041f
+// https://drafts.csswg.org/css-color/#color-conversion-code
+static constexpr ColorMatrix<3, 3> linearA98RGBToXYZMatrix {
+ 0.5766690429101305f, 0.1855582379065463f, 0.1882286462349947f,
+ 0.29734497525053605f, 0.6273635662554661f, 0.07529145849399788f,
+ 0.02703136138641234f, 0.07068885253582723f, 0.9913375368376388f
};
+// DisplayP3 Matrices.
+
// https://drafts.csswg.org/css-color/#color-conversion-code
static constexpr ColorMatrix<3, 3> xyzToLinearDisplayP3Matrix {
2.493496911941425f, -0.9313836179191239f, -0.4027107844507168f,
@@ -62,20 +64,26 @@
0.0f, 0.0451133818589026f, 1.043944368900976f
};
-// https://drafts.csswg.org/css-color/#color-conversion-code
-static constexpr ColorMatrix<3, 3> xyzToLinearA98RGBMatrix {
- 2.493496911941425f, -0.9313836179191239f, -0.4027107844507168f,
- -0.8294889695615747f, 1.7626640603183463f, 0.0236246858419436f,
- 0.0358458302437845f, -0.0761723892680418f, 0.9568845240076872f
+// sRGB Matrices.
+
+// https://en.wikipedia.org/wiki/SRGB
+// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+static constexpr ColorMatrix<3, 3> xyzToLinearSRGBMatrix {
+ 3.2404542f, -1.5371385f, -0.4985314f,
+ -0.9692660f, 1.8760108f, 0.0415560f,
+ 0.0556434f, -0.2040259f, 1.0572252f
};
-// https://drafts.csswg.org/css-color/#color-conversion-code
-static constexpr ColorMatrix<3, 3> linearA98RGBToXYZMatrix {
- 0.5766690429101305f, 0.1855582379065463f, 0.1882286462349947f,
- 0.29734497525053605f, 0.6273635662554661f, 0.07529145849399788f,
- 0.02703136138641234f, 0.07068885253582723f, 0.9913375368376388f
+// https://en.wikipedia.org/wiki/SRGB
+// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
+static constexpr ColorMatrix<3, 3> linearSRGBToXYZMatrix {
+ 0.4124564f, 0.3575761f, 0.1804375f,
+ 0.2126729f, 0.7151522f, 0.0721750f,
+ 0.0193339f, 0.1191920f, 0.9503041f
};
+// Chromatic Adaptation Matrices.
+
// http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html
static constexpr ColorMatrix<3, 3> D50ToD65Matrix {
0.9555766f, -0.0230393f, 0.0631636f,
@@ -90,8 +98,30 @@
-0.0092345f, 0.0150436f, 0.7521316f
};
-// Gamma conversions.
+// MARK: Gamma conversions.
+float A98RGBTransferFunction::fromLinearClamping(float c)
+{
+ return clampTo<float>(fromLinearNonClamping(c), 0, 1);
+}
+
+float A98RGBTransferFunction::toLinearClamping(float c)
+{
+ return clampTo<float>(toLinearNonClamping(c), 0, 1);
+}
+
+float A98RGBTransferFunction::fromLinearNonClamping(float c)
+{
+ float sign = std::signbit(c) ? -1.0f : 1.0f;
+ return std::pow(std::abs(c), 256.0f / 563.0f) * sign;
+}
+
+float A98RGBTransferFunction::toLinearNonClamping(float c)
+{
+ float sign = std::signbit(c) ? -1.0f : 1.0f;
+ return std::pow(std::abs(c), 563.0f / 256.0f) * sign;
+}
+
float SRGBTransferFunction::fromLinearClamping(float c)
{
if (c < 0.0031308f)
@@ -130,28 +160,6 @@
return std::pow((c + 0.055f) / 1.055f, 2.4f) * sign;
}
-float A98RGBTransferFunction::fromLinearClamping(float c)
-{
- return clampTo<float>(fromLinearNonClamping(c), 0, 1);
-}
-
-float A98RGBTransferFunction::toLinearClamping(float c)
-{
- return clampTo<float>(toLinearNonClamping(c), 0, 1);
-}
-
-float A98RGBTransferFunction::fromLinearNonClamping(float c)
-{
- float sign = std::signbit(c) ? -1.0f : 1.0f;
- return std::pow(std::abs(c), 256.0f / 563.0f) * sign;
-}
-
-float A98RGBTransferFunction::toLinearNonClamping(float c)
-{
- float sign = std::signbit(c) ? -1.0f : 1.0f;
- return std::pow(std::abs(c), 563.0f / 256.0f) * sign;
-}
-
template<typename TransferFunction, typename T> static auto toLinearClamping(const T& color) -> typename T::LinearCounterpart
{
auto [c1, c2, c3, alpha] = color;
@@ -176,58 +184,78 @@
return { TransferFunction::fromLinearNonClamping(c1), TransferFunction::fromLinearNonClamping(c2), TransferFunction::fromLinearNonClamping(c3), alpha };
}
-LinearSRGBA<float> toLinearSRGBA(const SRGBA<float>& color)
+// A98RGB <-> LinearA98RGB conversions.
+
+LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>& color)
{
- return toLinearClamping<SRGBTransferFunction>(color);
+ return toLinearClamping<A98RGBTransferFunction>(color);
}
-LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const ExtendedSRGBA<float>& color)
+A98RGB<float> toA98RGB(const LinearA98RGB<float>& color)
{
- return toLinearNonClamping<SRGBTransferFunction>(color);
+ return fromLinearClamping<A98RGBTransferFunction>(color);
}
-SRGBA<float> toSRGBA(const LinearSRGBA<float>& color)
+// DisplayP3 <-> LinearDisplayP3 conversions.
+
+LinearDisplayP3<float> toLinearDisplayP3(const DisplayP3<float>& color)
{
+ return toLinearClamping<SRGBTransferFunction>(color);
+}
+
+DisplayP3<float> toDisplayP3(const LinearDisplayP3<float>& color)
+{
return fromLinearClamping<SRGBTransferFunction>(color);
}
+// ExtendedSRGBA <-> LinearExtendedSRGBA conversions.
+
+LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const ExtendedSRGBA<float>& color)
+{
+ return toLinearNonClamping<SRGBTransferFunction>(color);
+}
+
ExtendedSRGBA<float> toExtendedSRGBA(const LinearExtendedSRGBA<float>& color)
{
return fromLinearNonClamping<SRGBTransferFunction>(color);
}
-LinearDisplayP3<float> toLinearDisplayP3(const DisplayP3<float>& color)
+// SRGBA <-> LinearSRGBA conversions.
+
+LinearSRGBA<float> toLinearSRGBA(const SRGBA<float>& color)
{
return toLinearClamping<SRGBTransferFunction>(color);
}
-DisplayP3<float> toDisplayP3(const LinearDisplayP3<float>& color)
+SRGBA<float> toSRGBA(const LinearSRGBA<float>& color)
{
return fromLinearClamping<SRGBTransferFunction>(color);
}
-LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>& color)
+// MARK: Matrix conversions (to and from XYZ for all linear color types).
+
+// - LinearA98RGB matrix conversions.
+
+LinearA98RGB<float> toLinearA98RGB(const XYZA<float>& color)
{
- return toLinearClamping<A98RGBTransferFunction>(color);
+ return makeFromComponentsClampingExceptAlpha<LinearA98RGB<float>>(xyzToLinearA98RGBMatrix.transformedColorComponents(asColorComponents(color)));
}
-A98RGB<float> toA98RGB(const LinearA98RGB<float>& color)
+XYZA<float> toXYZA(const LinearA98RGB<float>& color)
{
- return fromLinearClamping<A98RGBTransferFunction>(color);
+ return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearA98RGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
}
-// Matrix conversions (to and from XYZ for all linear color types).
+// - LinearDisplayP3 matrix conversions.
-// - LinearSRGBA matrix conversions.
-
-LinearSRGBA<float> toLinearSRGBA(const XYZA<float>& color)
+LinearDisplayP3<float> toLinearDisplayP3(const XYZA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<LinearSRGBA<float>>(xyzToLinearSRGBMatrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<LinearDisplayP3<float>>(xyzToLinearDisplayP3Matrix.transformedColorComponents(asColorComponents(color)));
}
-XYZA<float> toXYZA(const LinearSRGBA<float>& color)
+XYZA<float> toXYZA(const LinearDisplayP3<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearSRGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearDisplayP3ToXYZMatrix.transformedColorComponents(asColorComponents(color)));
}
// - LinearExtendedSRGBA matrix conversions.
@@ -242,44 +270,119 @@
return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearSRGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
}
-// - LinearDisplayP3 matrix conversions.
+// - LinearSRGBA matrix conversions.
-LinearDisplayP3<float> toLinearDisplayP3(const XYZA<float>& color)
+LinearSRGBA<float> toLinearSRGBA(const XYZA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<LinearDisplayP3<float>>(xyzToLinearDisplayP3Matrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<LinearSRGBA<float>>(xyzToLinearSRGBMatrix.transformedColorComponents(asColorComponents(color)));
}
-XYZA<float> toXYZA(const LinearDisplayP3<float>& color)
+XYZA<float> toXYZA(const LinearSRGBA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearDisplayP3ToXYZMatrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearSRGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
}
-// - LinearA98RGB matrix conversions.
+// MARK: Chromatic Adaptation conversions.
-LinearA98RGB<float> toLinearA98RGB(const XYZA<float>& color)
+static XYZA<float> convertFromD50WhitePointToD65WhitePoint(const XYZA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<LinearA98RGB<float>>(xyzToLinearA98RGBMatrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<XYZA<float>>(D50ToD65Matrix.transformedColorComponents(asColorComponents(color)));
}
-XYZA<float> toXYZA(const LinearA98RGB<float>& color)
+static XYZA<float> convertFromD65WhitePointToD50WhitePoint(const XYZA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearA98RGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
+ return makeFromComponentsClampingExceptAlpha<XYZA<float>>(D65ToD50Matrix.transformedColorComponents(asColorComponents(color)));
}
-// Chromatic Adaptation conversions.
+// MARK: HSL conversions.
-static XYZA<float> convertFromD50WhitePointToD65WhitePoint(const XYZA<float>& color)
+HSLA<float> toHSLA(const SRGBA<float>& color)
{
- return makeFromComponentsClampingExceptAlpha<XYZA<float>>(D50ToD65Matrix.transformedColorComponents(asColorComponents(color)));
+ // http://en.wikipedia.org/wiki/HSL_color_space.
+ auto [r, g, b, alpha] = color;
+
+ auto [min, max] = std::minmax({ r, g, b });
+ float chroma = max - min;
+
+ float hue;
+ if (!chroma)
+ hue = 0;
+ else if (max == r)
+ hue = (60.0f * ((g - b) / chroma)) + 360.0f;
+ else if (max == g)
+ hue = (60.0f * ((b - r) / chroma)) + 120.0f;
+ else
+ hue = (60.0f * ((r - g) / chroma)) + 240.0f;
+
+ if (hue >= 360.0f)
+ hue -= 360.0f;
+
+ hue /= 360.0f;
+
+ float lightness = 0.5f * (max + min);
+ float saturation;
+ if (!chroma)
+ saturation = 0;
+ else if (lightness <= 0.5f)
+ saturation = (chroma / (max + min));
+ else
+ saturation = (chroma / (2.0f - (max + min)));
+
+ return {
+ hue,
+ saturation,
+ lightness,
+ alpha
+ };
}
-static XYZA<float> convertFromD65WhitePointToD50WhitePoint(const XYZA<float>& color)
+// Hue is in the range 0-6, other args in 0-1.
+static float calcHue(float temp1, float temp2, float hueVal)
{
- return makeFromComponentsClampingExceptAlpha<XYZA<float>>(D65ToD50Matrix.transformedColorComponents(asColorComponents(color)));
+ if (hueVal < 0.0f)
+ hueVal += 6.0f;
+ else if (hueVal >= 6.0f)
+ hueVal -= 6.0f;
+ if (hueVal < 1.0f)
+ return temp1 + (temp2 - temp1) * hueVal;
+ if (hueVal < 3.0f)
+ return temp2;
+ if (hueVal < 4.0f)
+ return temp1 + (temp2 - temp1) * (4.0f - hueVal);
+ return temp1;
}
-// Lab conversions.
+// Explanation of this algorithm can be found in the CSS Color 4 Module
+// specification at https://drafts.csswg.org/css-color-4/#hsl-to-rgb with
+// further explanation available at http://en.wikipedia.org/wiki/HSL_color_space
+SRGBA<float> toSRGBA(const HSLA<float>& color)
+{
+ auto [hue, saturation, lightness, alpha] = color;
+ // Convert back to RGB.
+ if (!saturation) {
+ return {
+ lightness,
+ lightness,
+ lightness,
+ alpha
+ };
+ }
+
+ float temp2 = lightness <= 0.5f ? lightness * (1.0f + saturation) : lightness + saturation - lightness * saturation;
+ float temp1 = 2.0f * lightness - temp2;
+
+ hue *= 6.0f; // calcHue() wants hue in the 0-6 range.
+ return {
+ calcHue(temp1, temp2, hue + 2.0f),
+ calcHue(temp1, temp2, hue),
+ calcHue(temp1, temp2, hue - 2.0f),
+ alpha
+ };
+}
+
+// MARK: Lab conversions.
+
static constexpr float LABe = 216.0f / 24389.0f;
static constexpr float LABk = 24389.0f / 27.0f;
static constexpr float D50WhiteValues[] = { 0.96422f, 1.0f, 0.82521f };
@@ -346,7 +449,7 @@
}
-// LCH conversions.
+// MARK: LCH conversions.
LCHA<float> toLCHA(const Lab<float>& color)
{
@@ -374,106 +477,30 @@
};
}
-// HSL conversions.
+// MARK: Combination conversions (constructed from more basic conversions above).
-HSLA<float> toHSLA(const SRGBA<float>& color)
-{
- // http://en.wikipedia.org/wiki/HSL_color_space.
- auto [r, g, b, alpha] = color;
+// - A98RGB combination functions.
- auto [min, max] = std::minmax({ r, g, b });
- float chroma = max - min;
-
- float hue;
- if (!chroma)
- hue = 0;
- else if (max == r)
- hue = (60.0f * ((g - b) / chroma)) + 360.0f;
- else if (max == g)
- hue = (60.0f * ((b - r) / chroma)) + 120.0f;
- else
- hue = (60.0f * ((r - g) / chroma)) + 240.0f;
-
- if (hue >= 360.0f)
- hue -= 360.0f;
-
- hue /= 360.0f;
-
- float lightness = 0.5f * (max + min);
- float saturation;
- if (!chroma)
- saturation = 0;
- else if (lightness <= 0.5f)
- saturation = (chroma / (max + min));
- else
- saturation = (chroma / (2.0f - (max + min)));
-
- return {
- hue,
- saturation,
- lightness,
- alpha
- };
-}
-
-// Hue is in the range 0-6, other args in 0-1.
-static float calcHue(float temp1, float temp2, float hueVal)
+XYZA<float> toXYZA(const A98RGB<float>& color)
{
- if (hueVal < 0.0f)
- hueVal += 6.0f;
- else if (hueVal >= 6.0f)
- hueVal -= 6.0f;
- if (hueVal < 1.0f)
- return temp1 + (temp2 - temp1) * hueVal;
- if (hueVal < 3.0f)
- return temp2;
- if (hueVal < 4.0f)
- return temp1 + (temp2 - temp1) * (4.0f - hueVal);
- return temp1;
+ return toXYZA(toLinearA98RGB(color));
}
-// Explanation of this algorithm can be found in the CSS Color 4 Module
-// specification at https://drafts.csswg.org/css-color-4/#hsl-to-rgb with
-// further explanation available at http://en.wikipedia.org/wiki/HSL_color_space
-SRGBA<float> toSRGBA(const HSLA<float>& color)
+A98RGB<float> toA98RGB(const XYZA<float>& color)
{
- auto [hue, saturation, lightness, alpha] = color;
-
- // Convert back to RGB.
- if (!saturation) {
- return {
- lightness,
- lightness,
- lightness,
- alpha
- };
- }
-
- float temp2 = lightness <= 0.5f ? lightness * (1.0f + saturation) : lightness + saturation - lightness * saturation;
- float temp1 = 2.0f * lightness - temp2;
-
- hue *= 6.0f; // calcHue() wants hue in the 0-6 range.
- return {
- calcHue(temp1, temp2, hue + 2.0f),
- calcHue(temp1, temp2, hue),
- calcHue(temp1, temp2, hue - 2.0f),
- alpha
- };
+ return toA98RGB(toLinearA98RGB(color));
}
+// - DisplayP3 combination functions.
-// Combination conversions (constructed from more basic conversions above).
-
-// - SRGB combination functions.
-
-XYZA<float> toXYZA(const SRGBA<float>& color)
+XYZA<float> toXYZA(const DisplayP3<float>& color)
{
- return toXYZA(toLinearSRGBA(color));
+ return toXYZA(toLinearDisplayP3(color));
}
-SRGBA<float> toSRGBA(const XYZA<float>& color)
+DisplayP3<float> toDisplayP3(const XYZA<float>& color)
{
- return toSRGBA(toLinearSRGBA(color));
+ return toDisplayP3(toLinearDisplayP3(color));
}
// - ExtendedSRGB combination functions.
@@ -488,30 +515,18 @@
return toExtendedSRGBA(toLinearExtendedSRGBA(color));
}
-// - DisplayP3 combination functions.
+// - HSLA combination functions.
-XYZA<float> toXYZA(const DisplayP3<float>& color)
+XYZA<float> toXYZA(const HSLA<float>& color)
{
- return toXYZA(toLinearDisplayP3(color));
+ return toXYZA(toSRGBA(color));
}
-DisplayP3<float> toDisplayP3(const XYZA<float>& color)
+HSLA<float> toHSLA(const XYZA<float>& color)
{
- return toDisplayP3(toLinearDisplayP3(color));
+ return toHSLA(toSRGBA(color));
}
-// - A98RGB combination functions.
-
-XYZA<float> toXYZA(const A98RGB<float>& color)
-{
- return toXYZA(toLinearA98RGB(color));
-}
-
-A98RGB<float> toA98RGB(const XYZA<float>& color)
-{
- return toA98RGB(toLinearA98RGB(color));
-}
-
// - LCHA combination functions.
XYZA<float> toXYZA(const LCHA<float>& color)
@@ -524,16 +539,16 @@
return toLCHA(toLab(color));
}
-// - HSLA combination functions.
+// - SRGB combination functions.
-XYZA<float> toXYZA(const HSLA<float>& color)
+XYZA<float> toXYZA(const SRGBA<float>& color)
{
- return toXYZA(toSRGBA(color));
+ return toXYZA(toLinearSRGBA(color));
}
-HSLA<float> toHSLA(const XYZA<float>& color)
+SRGBA<float> toSRGBA(const XYZA<float>& color)
{
- return toHSLA(toSRGBA(color));
+ return toSRGBA(toLinearSRGBA(color));
}
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/graphics/ColorConversion.h (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorConversion.h 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorConversion.h 2021-01-28 20:50:10 UTC (rev 272033)
@@ -31,7 +31,7 @@
// Transfer functions for colors that can be gamma encoded.
-struct SRGBTransferFunction {
+struct A98RGBTransferFunction {
static float fromLinearClamping(float);
static float toLinearClamping(float);
static float fromLinearNonClamping(float);
@@ -38,7 +38,7 @@
static float toLinearNonClamping(float);
};
-struct A98RGBTransferFunction {
+struct SRGBTransferFunction {
static float fromLinearClamping(float);
static float toLinearClamping(float);
static float fromLinearNonClamping(float);
@@ -53,13 +53,18 @@
// some may be integral to the base conversion.
-// SRGBA
-WEBCORE_EXPORT XYZA<float> toXYZA(const SRGBA<float>&);
-WEBCORE_EXPORT SRGBA<float> toSRGBA(const XYZA<float>&);
+// A98RGB
+WEBCORE_EXPORT XYZA<float> toXYZA(const A98RGB<float>&);
+WEBCORE_EXPORT A98RGB<float> toA98RGB(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT LinearSRGBA<float> toLinearSRGBA(const SRGBA<float>&);
-WEBCORE_EXPORT HSLA<float> toHSLA(const SRGBA<float>&);
+WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>&);
+// DisplayP3
+WEBCORE_EXPORT XYZA<float> toXYZA(const DisplayP3<float>&);
+WEBCORE_EXPORT DisplayP3<float> toDisplayP3(const XYZA<float>&);
+// Additions
+WEBCORE_EXPORT LinearDisplayP3<float> toLinearDisplayP3(const DisplayP3<float>&);
+
// ExtendedSRGBA
WEBCORE_EXPORT XYZA<float> toXYZA(const ExtendedSRGBA<float>&);
WEBCORE_EXPORT ExtendedSRGBA<float> toExtendedSRGBA(const XYZA<float>&);
@@ -66,24 +71,30 @@
// Additions
WEBCORE_EXPORT LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const ExtendedSRGBA<float>&);
-// LinearSRGBA
-WEBCORE_EXPORT XYZA<float> toXYZA(const LinearSRGBA<float>&);
-WEBCORE_EXPORT LinearSRGBA<float> toLinearSRGBA(const XYZA<float>&);
+// HSLA
+WEBCORE_EXPORT XYZA<float> toXYZA(const HSLA<float>&);
+WEBCORE_EXPORT HSLA<float> toHSLA(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT SRGBA<float> toSRGBA(const LinearSRGBA<float>&);
+WEBCORE_EXPORT SRGBA<float> toSRGBA(const HSLA<float>&);
-// LinearExtendedSRGBA
-WEBCORE_EXPORT XYZA<float> toXYZA(const LinearExtendedSRGBA<float>&);
-WEBCORE_EXPORT LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const XYZA<float>&);
+// LCHA
+WEBCORE_EXPORT XYZA<float> toXYZA(const LCHA<float>&);
+WEBCORE_EXPORT LCHA<float> toLCHA(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT ExtendedSRGBA<float> toExtendedSRGBA(const LinearExtendedSRGBA<float>&);
+WEBCORE_EXPORT Lab<float> toLab(const LCHA<float>&);
-// DisplayP3
-WEBCORE_EXPORT XYZA<float> toXYZA(const DisplayP3<float>&);
-WEBCORE_EXPORT DisplayP3<float> toDisplayP3(const XYZA<float>&);
+// Lab
+WEBCORE_EXPORT XYZA<float> toXYZA(const Lab<float>&);
+WEBCORE_EXPORT Lab<float> toLab(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT LinearDisplayP3<float> toLinearDisplayP3(const DisplayP3<float>&);
+WEBCORE_EXPORT LCHA<float> toLCHA(const Lab<float>&);
+// LinearA98RGB
+WEBCORE_EXPORT XYZA<float> toXYZA(const LinearA98RGB<float>&);
+WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const XYZA<float>&);
+// Additions
+WEBCORE_EXPORT A98RGB<float> toA98RGB(const LinearA98RGB<float>& color);
+
// LinearDisplayP3
WEBCORE_EXPORT XYZA<float> toXYZA(const LinearDisplayP3<float>&);
WEBCORE_EXPORT LinearDisplayP3<float> toLinearDisplayP3(const XYZA<float>&);
@@ -90,50 +101,40 @@
// Additions
WEBCORE_EXPORT DisplayP3<float> toDisplayP3(const LinearDisplayP3<float>&);
-// Lab
-WEBCORE_EXPORT XYZA<float> toXYZA(const Lab<float>&);
-WEBCORE_EXPORT Lab<float> toLab(const XYZA<float>&);
+// LinearExtendedSRGBA
+WEBCORE_EXPORT XYZA<float> toXYZA(const LinearExtendedSRGBA<float>&);
+WEBCORE_EXPORT LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT LCHA<float> toLCHA(const Lab<float>&);
+WEBCORE_EXPORT ExtendedSRGBA<float> toExtendedSRGBA(const LinearExtendedSRGBA<float>&);
-// LCHA
-WEBCORE_EXPORT XYZA<float> toXYZA(const LCHA<float>&);
-WEBCORE_EXPORT LCHA<float> toLCHA(const XYZA<float>&);
+// LinearSRGBA
+WEBCORE_EXPORT XYZA<float> toXYZA(const LinearSRGBA<float>&);
+WEBCORE_EXPORT LinearSRGBA<float> toLinearSRGBA(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT Lab<float> toLab(const LCHA<float>&);
+WEBCORE_EXPORT SRGBA<float> toSRGBA(const LinearSRGBA<float>&);
-// HSLA
-WEBCORE_EXPORT XYZA<float> toXYZA(const HSLA<float>&);
-WEBCORE_EXPORT HSLA<float> toHSLA(const XYZA<float>&);
+// SRGBA
+WEBCORE_EXPORT XYZA<float> toXYZA(const SRGBA<float>&);
+WEBCORE_EXPORT SRGBA<float> toSRGBA(const XYZA<float>&);
// Additions
-WEBCORE_EXPORT SRGBA<float> toSRGBA(const HSLA<float>&);
+WEBCORE_EXPORT LinearSRGBA<float> toLinearSRGBA(const SRGBA<float>&);
+WEBCORE_EXPORT HSLA<float> toHSLA(const SRGBA<float>&);
-// A98RGB
-WEBCORE_EXPORT XYZA<float> toXYZA(const A98RGB<float>&);
-WEBCORE_EXPORT A98RGB<float> toA98RGB(const XYZA<float>&);
-// Additions
-WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>&);
-// LinearA98RGB
-WEBCORE_EXPORT XYZA<float> toXYZA(const LinearA98RGB<float>&);
-WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const XYZA<float>&);
-// Additions
-WEBCORE_EXPORT A98RGB<float> toA98RGB(const LinearA98RGB<float>& color);
-
-
// Identity conversions (useful for generic contexts).
-constexpr SRGBA<float> toSRGBA(const SRGBA<float>& color) { return color; }
+constexpr A98RGB<float> toA98RGB(const A98RGB<float>& color) { return color; }
+constexpr DisplayP3<float> toDisplayP3(const DisplayP3<float>& color) { return color; }
constexpr ExtendedSRGBA<float> toExtendedSRGBA(const ExtendedSRGBA<float>& color) { return color; }
+constexpr HSLA<float> toHSLA(const HSLA<float>& color) { return color; }
+constexpr LCHA<float> toLCHA(const LCHA<float>& color) { return color; }
+constexpr Lab<float> toLab(const Lab<float>& color) { return color; }
+constexpr LinearA98RGB<float> toLinearA98RGB(const LinearA98RGB<float>& color) { return color; }
+constexpr LinearDisplayP3<float> toLinearDisplayP3(const LinearDisplayP3<float>& color) { return color; }
+constexpr LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const LinearExtendedSRGBA<float>& color) { return color; }
constexpr LinearSRGBA<float> toLinearSRGBA(const LinearSRGBA<float>& color) { return color; }
-constexpr LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const LinearExtendedSRGBA<float>& color) { return color; }
-constexpr DisplayP3<float> toDisplayP3(const DisplayP3<float>& color) { return color; }
-constexpr LinearDisplayP3<float> toLinearDisplayP3(const LinearDisplayP3<float>& color) { return color; }
-constexpr Lab<float> toLab(const Lab<float>& color) { return color; }
-constexpr LCHA<float> toLCHA(const LCHA<float>& color) { return color; }
-constexpr HSLA<float> toHSLA(const HSLA<float>& color) { return color; }
+constexpr SRGBA<float> toSRGBA(const SRGBA<float>& color) { return color; }
constexpr XYZA<float> toXYZA(const XYZA<float>& color) { return color; }
-constexpr A98RGB<float> toA98RGB(const A98RGB<float>& color) { return color; }
// Fallback conversions.
@@ -141,59 +142,59 @@
// All types are required to have a conversion to XYZA, so these are guaranteed to work if
// another overload is not already provided.
-template<typename T> SRGBA<float> toSRGBA(const T& color)
+template<typename T> A98RGB<float> toA98RGB(const T& color)
{
- return toSRGBA(toXYZA(color));
+ return toA98RGB(toXYZA(color));
}
-template<typename T> ExtendedSRGBA<float> toExtendedSRGBA(const T& color)
+template<typename T> DisplayP3<float> toDisplayP3(const T& color)
{
- return toExtendedSRGBA(toXYZA(color));
+ return toDisplayP3(toXYZA(color));
}
-template<typename T> LinearSRGBA<float> toLinearSRGBA(const T& color)
+template<typename T> ExtendedSRGBA<float> toExtendedSRGBA(const T& color)
{
- return toLinearSRGBA(toXYZA(color));
+ return toExtendedSRGBA(toXYZA(color));
}
-template<typename T> LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const T& color)
+template<typename T> HSLA<float> toHSLA(const T& color)
{
- return toLinearExtendedSRGBA(toXYZA(color));
+ return toHSLA(toXYZA(color));
}
-template<typename T> DisplayP3<float> toDisplayP3(const T& color)
+template<typename T> LCHA<float> toLCHA(const T& color)
{
- return toDisplayP3(toXYZA(color));
+ return toLCHA(toXYZA(color));
}
-template<typename T> LinearDisplayP3<float> toLinearDisplayP3(const T& color)
+template<typename T> Lab<float> toLab(const T& color)
{
- return toLinearDisplayP3(toXYZA(color));
+ return toLab(toXYZA(color));
}
-template<typename T> Lab<float> toLab(const T& color)
+template<typename T> LinearA98RGB<float> toLinearA98RGB(const T& color)
{
- return toLab(toXYZA(color));
+ return toLinearA98RGB(toXYZA(color));
}
-template<typename T> LCHA<float> toLCHA(const T& color)
+template<typename T> LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const T& color)
{
- return toLCHA(toXYZA(color));
+ return toLinearExtendedSRGBA(toXYZA(color));
}
-template<typename T> HSLA<float> toHSLA(const T& color)
+template<typename T> LinearDisplayP3<float> toLinearDisplayP3(const T& color)
{
- return toHSLA(toXYZA(color));
+ return toLinearDisplayP3(toXYZA(color));
}
-template<typename T> A98RGB<float> toA98RGB(const T& color)
+template<typename T> LinearSRGBA<float> toLinearSRGBA(const T& color)
{
- return toA98RGB(toXYZA(color));
+ return toLinearSRGBA(toXYZA(color));
}
-template<typename T> LinearA98RGB<float> toLinearA98RGB(const T& color)
+template<typename T> SRGBA<float> toSRGBA(const T& color)
{
- return toLinearA98RGB(toXYZA(color));
+ return toSRGBA(toXYZA(color));
}
@@ -200,16 +201,16 @@
template<typename T, typename Functor> constexpr decltype(auto) callWithColorType(const ColorComponents<T>& components, ColorSpace colorSpace, Functor&& functor)
{
switch (colorSpace) {
- case ColorSpace::SRGB:
- return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
- case ColorSpace::LinearRGB:
- return std::invoke(std::forward<Functor>(functor), makeFromComponents<LinearSRGBA<T>>(components));
+ case ColorSpace::A98RGB:
+ return std::invoke(std::forward<Functor>(functor), makeFromComponents<A98RGB<T>>(components));
case ColorSpace::DisplayP3:
return std::invoke(std::forward<Functor>(functor), makeFromComponents<DisplayP3<T>>(components));
- case ColorSpace::A98RGB:
- return std::invoke(std::forward<Functor>(functor), makeFromComponents<A98RGB<T>>(components));
case ColorSpace::Lab:
return std::invoke(std::forward<Functor>(functor), makeFromComponents<Lab<T>>(components));
+ case ColorSpace::LinearRGB:
+ return std::invoke(std::forward<Functor>(functor), makeFromComponents<LinearSRGBA<T>>(components));
+ case ColorSpace::SRGB:
+ return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
}
ASSERT_NOT_REACHED();
Modified: trunk/Source/WebCore/platform/graphics/ColorSerialization.cpp (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorSerialization.cpp 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorSerialization.cpp 2021-01-28 20:50:10 UTC (rev 272033)
@@ -36,70 +36,40 @@
namespace WebCore {
-// SRGBA<uint8_t> overloads
-
-static char decimalDigit(unsigned number)
+String serializationForCSS(const Color& color)
{
- ASSERT(number < 10);
- return '0' + number;
+ return color.callOnUnderlyingType([] (auto underlyingColor) {
+ return serializationForCSS(underlyingColor);
+ });
}
-static std::array<char, 4> fractionDigitsForFractionalAlphaValue(uint8_t alpha)
+String serializationForHTML(const Color& color)
{
- ASSERT(alpha > 0);
- ASSERT(alpha < 0xFF);
- if (((alpha * 100 + 0x7F) / 0xFF * 0xFF + 50) / 100 != alpha)
- return { { decimalDigit(alpha * 10 / 0xFF % 10), decimalDigit(alpha * 100 / 0xFF % 10), decimalDigit((alpha * 1000 + 0x7F) / 0xFF % 10), '\0' } };
- if (int thirdDigit = (alpha * 100 + 0x7F) / 0xFF % 10)
- return { { decimalDigit(alpha * 10 / 0xFF), decimalDigit(thirdDigit), '\0', '\0' } };
- return { { decimalDigit((alpha * 10 + 0x7F) / 0xFF), '\0', '\0', '\0' } };
+ return color.callOnUnderlyingType([] (auto underlyingColor) {
+ return serializationForHTML(underlyingColor);
+ });
}
-String serializationForCSS(SRGBA<uint8_t> color)
+String serializationForRenderTreeAsText(const Color& color)
{
- auto [red, green, blue, alpha] = color;
- switch (alpha) {
- case 0:
- return makeString("rgba(", red, ", ", green, ", ", blue, ", 0)");
- case 0xFF:
- return makeString("rgb(", red, ", ", green, ", ", blue, ')');
- default:
- return makeString("rgba(", red, ", ", green, ", ", blue, ", 0.", fractionDigitsForFractionalAlphaValue(alpha).data(), ')');
- }
+ return color.callOnUnderlyingType([] (auto underlyingColor) {
+ return serializationForRenderTreeAsText(underlyingColor);
+ });
}
-String serializationForHTML(SRGBA<uint8_t> color)
-{
- auto [red, green, blue, alpha] = color;
- if (alpha == 0xFF)
- return makeString('#', hex(red, 2, Lowercase), hex(green, 2, Lowercase), hex(blue, 2, Lowercase));
- return serializationForCSS(color);
-}
-
-String serializationForRenderTreeAsText(SRGBA<uint8_t> color)
-{
- auto [red, green, blue, alpha] = color;
- if (alpha < 0xFF)
- return makeString('#', hex(red, 2), hex(green, 2), hex(blue, 2), hex(alpha, 2));
- return makeString('#', hex(red, 2), hex(green, 2), hex(blue, 2));
-}
-
-
-// ExtendedColor overloads
-
static ASCIILiteral serialization(ColorSpace colorSpace)
{
switch (colorSpace) {
- case ColorSpace::SRGB:
- return "srgb"_s;
- case ColorSpace::LinearRGB:
- return "linear-srgb"_s;
+ case ColorSpace::A98RGB:
+ return "a98-rgb"_s;
case ColorSpace::DisplayP3:
return "display-p3"_s;
- case ColorSpace::A98RGB:
- return "a98-rgb"_s;
case ColorSpace::Lab:
return "lab"_s;
+ case ColorSpace::LinearRGB:
+ return "linear-srgb"_s;
+ case ColorSpace::SRGB:
+ return "srgb"_s;
}
ASSERT_NOT_REACHED();
@@ -114,117 +84,142 @@
return makeString("color(", serialization(color.colorSpace), ' ', c1, ' ', c2, ' ', c3, " / ", alpha, ')');
}
-// SRGBA<float> overloads
+// MARK: A98RGB<float> overloads
-String serializationForCSS(const SRGBA<float>& color)
+String serializationForCSS(const A98RGB<float>& color)
{
return serialization(color);
}
-String serializationForHTML(const SRGBA<float>& color)
+String serializationForHTML(const A98RGB<float>& color)
{
return serialization(color);
}
-String serializationForRenderTreeAsText(const SRGBA<float>& color)
+String serializationForRenderTreeAsText(const A98RGB<float>& color)
{
return serialization(color);
}
-// LinearSRGBA<float> overloads
+// MARK: DisplayP3<float> overloads
-String serializationForCSS(const LinearSRGBA<float>& color)
+String serializationForCSS(const DisplayP3<float>& color)
{
return serialization(color);
}
-String serializationForHTML(const LinearSRGBA<float>& color)
+String serializationForHTML(const DisplayP3<float>& color)
{
return serialization(color);
}
-String serializationForRenderTreeAsText(const LinearSRGBA<float>& color)
+String serializationForRenderTreeAsText(const DisplayP3<float>& color)
{
return serialization(color);
}
-// DisplayP3<float> overloads
+// MARK: Lab<float> overloads
-String serializationForCSS(const DisplayP3<float>& color)
+String serializationForCSS(const Lab<float>& color)
{
- return serialization(color);
+ // https://www.w3.org/TR/css-color-4/#serializing-lab-lch
+
+ auto [c1, c2, c3, alpha] = color;
+ if (WTF::areEssentiallyEqual(alpha, 1.0f))
+ return makeString("lab(", c1, "% ", c2, ' ', c3, ')');
+ return makeString("lab(", c1, "% ", c2, ' ', c3, " / ", alpha, ')');
}
-String serializationForHTML(const DisplayP3<float>& color)
+String serializationForHTML(const Lab<float>& color)
{
- return serialization(color);
+ return serializationForCSS(color);
}
-String serializationForRenderTreeAsText(const DisplayP3<float>& color)
+String serializationForRenderTreeAsText(const Lab<float>& color)
{
- return serialization(color);
+ return serializationForCSS(color);
}
-// A98RGB<float> overloads
+// MARK: LinearSRGBA<float> overloads
-String serializationForCSS(const A98RGB<float>& color)
+String serializationForCSS(const LinearSRGBA<float>& color)
{
return serialization(color);
}
-String serializationForHTML(const A98RGB<float>& color)
+String serializationForHTML(const LinearSRGBA<float>& color)
{
return serialization(color);
}
-String serializationForRenderTreeAsText(const A98RGB<float>& color)
+String serializationForRenderTreeAsText(const LinearSRGBA<float>& color)
{
return serialization(color);
}
-// Lab<float> overloads
+// MARK: SRGBA<float> overloads
-String serializationForCSS(const Lab<float>& color)
+String serializationForCSS(const SRGBA<float>& color)
{
- // https://www.w3.org/TR/css-color-4/#serializing-lab-lch
+ return serialization(color);
+}
- auto [c1, c2, c3, alpha] = color;
- if (WTF::areEssentiallyEqual(alpha, 1.0f))
- return makeString("lab(", c1, "% ", c2, ' ', c3, ')');
- return makeString("lab(", c1, "% ", c2, ' ', c3, " / ", alpha, ')');
+String serializationForHTML(const SRGBA<float>& color)
+{
+ return serialization(color);
}
-String serializationForHTML(const Lab<float>& color)
+String serializationForRenderTreeAsText(const SRGBA<float>& color)
{
- return serializationForCSS(color);
+ return serialization(color);
}
-String serializationForRenderTreeAsText(const Lab<float>& color)
+// MARK: SRGBA<uint8_t> overloads
+
+static char decimalDigit(unsigned number)
{
- return serializationForCSS(color);
+ ASSERT(number < 10);
+ return '0' + number;
}
-// Color overloads
+static std::array<char, 4> fractionDigitsForFractionalAlphaValue(uint8_t alpha)
+{
+ ASSERT(alpha > 0);
+ ASSERT(alpha < 0xFF);
+ if (((alpha * 100 + 0x7F) / 0xFF * 0xFF + 50) / 100 != alpha)
+ return { { decimalDigit(alpha * 10 / 0xFF % 10), decimalDigit(alpha * 100 / 0xFF % 10), decimalDigit((alpha * 1000 + 0x7F) / 0xFF % 10), '\0' } };
+ if (int thirdDigit = (alpha * 100 + 0x7F) / 0xFF % 10)
+ return { { decimalDigit(alpha * 10 / 0xFF), decimalDigit(thirdDigit), '\0', '\0' } };
+ return { { decimalDigit((alpha * 10 + 0x7F) / 0xFF), '\0', '\0', '\0' } };
+}
-String serializationForCSS(const Color& color)
+String serializationForCSS(SRGBA<uint8_t> color)
{
- return color.callOnUnderlyingType([] (auto underlyingColor) {
- return serializationForCSS(underlyingColor);
- });
+ auto [red, green, blue, alpha] = color;
+ switch (alpha) {
+ case 0:
+ return makeString("rgba(", red, ", ", green, ", ", blue, ", 0)");
+ case 0xFF:
+ return makeString("rgb(", red, ", ", green, ", ", blue, ')');
+ default:
+ return makeString("rgba(", red, ", ", green, ", ", blue, ", 0.", fractionDigitsForFractionalAlphaValue(alpha).data(), ')');
+ }
}
-String serializationForHTML(const Color& color)
+String serializationForHTML(SRGBA<uint8_t> color)
{
- return color.callOnUnderlyingType([] (auto underlyingColor) {
- return serializationForHTML(underlyingColor);
- });
+ auto [red, green, blue, alpha] = color;
+ if (alpha == 0xFF)
+ return makeString('#', hex(red, 2, Lowercase), hex(green, 2, Lowercase), hex(blue, 2, Lowercase));
+ return serializationForCSS(color);
}
-String serializationForRenderTreeAsText(const Color& color)
+String serializationForRenderTreeAsText(SRGBA<uint8_t> color)
{
- return color.callOnUnderlyingType([] (auto underlyingColor) {
- return serializationForRenderTreeAsText(underlyingColor);
- });
+ auto [red, green, blue, alpha] = color;
+ if (alpha < 0xFF)
+ return makeString('#', hex(red, 2), hex(green, 2), hex(blue, 2), hex(alpha, 2));
+ return makeString('#', hex(red, 2), hex(green, 2), hex(blue, 2));
}
}
Modified: trunk/Source/WebCore/platform/graphics/ColorSerialization.h (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorSerialization.h 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorSerialization.h 2021-01-28 20:50:10 UTC (rev 272033)
@@ -41,32 +41,34 @@
// serializationForCSS returns the color serialized according to CSS
// serializationForRenderTreeAsText returns the color serialized for DumpRenderTree, #RRGGBB, #RRGGBBAA or the CSS serialization
-WEBCORE_EXPORT String serializationForCSS(SRGBA<uint8_t>);
-WEBCORE_EXPORT String serializationForHTML(SRGBA<uint8_t>);
-WEBCORE_EXPORT String serializationForRenderTreeAsText(SRGBA<uint8_t>);
+WEBCORE_EXPORT String serializationForCSS(const Color&);
+WEBCORE_EXPORT String serializationForHTML(const Color&);
+WEBCORE_EXPORT String serializationForRenderTreeAsText(const Color&);
-WEBCORE_EXPORT String serializationForCSS(const SRGBA<float>&);
-WEBCORE_EXPORT String serializationForHTML(const SRGBA<float>&);
-WEBCORE_EXPORT String serializationForRenderTreeAsText(const SRGBA<float>&);
+// Per-ColorType specializations.
-WEBCORE_EXPORT String serializationForCSS(const LinearSRGBA<float>&);
-WEBCORE_EXPORT String serializationForHTML(const LinearSRGBA<float>&);
-WEBCORE_EXPORT String serializationForRenderTreeAsText(const LinearSRGBA<float>&);
+WEBCORE_EXPORT String serializationForCSS(const A98RGB<float>&);
+WEBCORE_EXPORT String serializationForHTML(const A98RGB<float>&);
+WEBCORE_EXPORT String serializationForRenderTreeAsText(const A98RGB<float>&);
WEBCORE_EXPORT String serializationForCSS(const DisplayP3<float>&);
WEBCORE_EXPORT String serializationForHTML(const DisplayP3<float>&);
WEBCORE_EXPORT String serializationForRenderTreeAsText(const DisplayP3<float>&);
-WEBCORE_EXPORT String serializationForCSS(const A98RGB<float>&);
-WEBCORE_EXPORT String serializationForHTML(const A98RGB<float>&);
-WEBCORE_EXPORT String serializationForRenderTreeAsText(const A98RGB<float>&);
-
WEBCORE_EXPORT String serializationForCSS(const Lab<float>&);
WEBCORE_EXPORT String serializationForHTML(const Lab<float>&);
WEBCORE_EXPORT String serializationForRenderTreeAsText(const Lab<float>&);
-WEBCORE_EXPORT String serializationForCSS(const Color&);
-WEBCORE_EXPORT String serializationForHTML(const Color&);
-WEBCORE_EXPORT String serializationForRenderTreeAsText(const Color&);
+WEBCORE_EXPORT String serializationForCSS(const LinearSRGBA<float>&);
+WEBCORE_EXPORT String serializationForHTML(const LinearSRGBA<float>&);
+WEBCORE_EXPORT String serializationForRenderTreeAsText(const LinearSRGBA<float>&);
+WEBCORE_EXPORT String serializationForCSS(const SRGBA<float>&);
+WEBCORE_EXPORT String serializationForHTML(const SRGBA<float>&);
+WEBCORE_EXPORT String serializationForRenderTreeAsText(const SRGBA<float>&);
+
+WEBCORE_EXPORT String serializationForCSS(SRGBA<uint8_t>);
+WEBCORE_EXPORT String serializationForHTML(SRGBA<uint8_t>);
+WEBCORE_EXPORT String serializationForRenderTreeAsText(SRGBA<uint8_t>);
+
}
Modified: trunk/Source/WebCore/platform/graphics/ColorSpace.cpp (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorSpace.cpp 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorSpace.cpp 2021-01-28 20:50:10 UTC (rev 272033)
@@ -33,21 +33,21 @@
TextStream& operator<<(TextStream& ts, ColorSpace colorSpace)
{
switch (colorSpace) {
- case ColorSpace::SRGB:
- ts << "sRGB";
+ case ColorSpace::A98RGB:
+ ts << "a98-rgb";
break;
- case ColorSpace::LinearRGB:
- ts << "LinearRGB";
- break;
case ColorSpace::DisplayP3:
ts << "DisplayP3";
break;
- case ColorSpace::A98RGB:
- ts << "a98-rgb";
- break;
case ColorSpace::Lab:
ts << "L*a*b";
break;
+ case ColorSpace::LinearRGB:
+ ts << "LinearRGB";
+ break;
+ case ColorSpace::SRGB:
+ ts << "sRGB";
+ break;
}
return ts;
}
Modified: trunk/Source/WebCore/platform/graphics/ColorSpace.h (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorSpace.h 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorSpace.h 2021-01-28 20:50:10 UTC (rev 272033)
@@ -32,11 +32,11 @@
namespace WebCore {
enum class ColorSpace : uint8_t {
+ A98RGB,
+ DisplayP3,
+ Lab,
+ LinearRGB,
SRGB,
- LinearRGB,
- DisplayP3,
- A98RGB,
- Lab
};
WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, ColorSpace);
Modified: trunk/Source/WebCore/platform/graphics/ColorTypes.h (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/ColorTypes.h 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/ColorTypes.h 2021-01-28 20:50:10 UTC (rev 272033)
@@ -31,107 +31,30 @@
namespace WebCore {
-template<typename> struct SRGBA;
-template<typename> struct ExtendedSRGBA;
-template<typename> struct LinearSRGBA;
-template<typename> struct LinearExtendedSRGBA;
-template<typename> struct DisplayP3;
-template<typename> struct LinearDisplayP3;
template<typename> struct A98RGB;
-template<typename> struct LinearA98RGB;
-template<typename> struct Lab;
-template<typename> struct LCHA;
-template<typename> struct HSLA;
-template<typename> struct XYZ;
-
template<typename> struct AlphaTraits;
-
-template<> struct AlphaTraits<uint8_t> {
- static constexpr uint8_t transparent = 0;
- static constexpr uint8_t opaque = 255;
-};
-
-template<> struct AlphaTraits<float> {
- static constexpr float transparent = 0.0f;
- static constexpr float opaque = 1.0f;
-};
-
-template<typename T> struct ColorComponentRange {
- T min;
- T max;
-};
-
-template<typename> struct RGBModel;
+template<typename> struct ColorComponentRange;
+template<typename> struct DisplayP3;
template<typename> struct ExtendedRGBModel;
+template<typename> struct ExtendedSRGBA;
+template<typename> struct HSLA;
+template<typename> struct HSLModel;
+template<typename> struct LCHA;
+template<typename> struct LCHModel;
+template<typename> struct Lab;
template<typename> struct LabModel;
-template<typename> struct LCHModel;
-template<typename> struct HSLModel;
+template<typename> struct LinearA98RGB;
+template<typename> struct LinearDisplayP3;
+template<typename> struct LinearExtendedSRGBA;
+template<typename> struct LinearSRGBA;
+template<typename> struct RGBModel;
+template<typename> struct SRGBA;
+template<typename> struct XYZ;
template<typename> struct XYZModel;
-template<> struct RGBModel<uint8_t> {
- static constexpr std::array<ColorComponentRange<uint8_t>, 3> ranges { {
- { 0, 255 },
- { 0, 255 },
- { 0, 255 }
- } };
- static constexpr bool isInvertible = true;
-};
-template<> struct RGBModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { 0, 1 },
- { 0, 1 },
- { 0, 1 }
- } };
- static constexpr bool isInvertible = true;
-};
+// MARK: Make functions.
-template<> struct ExtendedRGBModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
- } };
- static constexpr bool isInvertible = false;
-};
-
-template<> struct LabModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { 0, std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
- } };
- static constexpr bool isInvertible = false;
-};
-
-template<> struct LCHModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { 0, std::numeric_limits<float>::infinity() },
- { 0, std::numeric_limits<float>::infinity() },
- { 0, 360 }
- } };
- static constexpr bool isInvertible = false;
-};
-
-template<> struct HSLModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { 0, 360 },
- { 0, 100 },
- { 0, 100 }
- } };
- static constexpr bool isInvertible = true;
-};
-
-template<> struct XYZModel<float> {
- static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
- { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
- } };
- static constexpr bool isInvertible = false;
-};
-
-
template<typename ColorType, typename T> constexpr ColorType makeFromComponents(const ColorComponents<T>& c)
{
return ColorType { c[0], c[1], c[2], c[3] };
@@ -173,22 +96,12 @@
template<typename ColorType, typename T> constexpr ColorComponents<T> clampedComponents(const ColorComponents<T>& components)
{
- return {
- clampedComponent<ColorType, 0>(components),
- clampedComponent<ColorType, 1>(components),
- clampedComponent<ColorType, 2>(components),
- clampedAlpha(components[3])
- };
+ return { clampedComponent<ColorType, 0>(components), clampedComponent<ColorType, 1>(components), clampedComponent<ColorType, 2>(components), clampedAlpha(components[3]) };
}
template<typename ColorType, typename T> constexpr ColorComponents<T> clampedComponentsExceptAlpha(const ColorComponents<T>& components)
{
- return {
- clampedComponent<ColorType, 0>(components),
- clampedComponent<ColorType, 1>(components),
- clampedComponent<ColorType, 2>(components),
- components[3]
- };
+ return { clampedComponent<ColorType, 0>(components), clampedComponent<ColorType, 1>(components), clampedComponent<ColorType, 2>(components), components[3] };
}
template<typename ColorType, typename T> constexpr ColorType makeFromComponentsClamping(const ColorComponents<T>& components)
@@ -198,22 +111,12 @@
template<typename ColorType, typename T> constexpr ColorType makeFromComponentsClamping(T c1, T c2, T c3)
{
- return makeFromComponents<ColorType>(ColorComponents {
- clampedComponent<ColorType, 0>(c1),
- clampedComponent<ColorType, 1>(c2),
- clampedComponent<ColorType, 2>(c3),
- AlphaTraits<typename ColorType::ComponentType>::opaque
- });
+ return makeFromComponents<ColorType>(ColorComponents { clampedComponent<ColorType, 0>(c1), clampedComponent<ColorType, 1>(c2), clampedComponent<ColorType, 2>(c3), AlphaTraits<typename ColorType::ComponentType>::opaque });
}
template<typename ColorType, typename T> constexpr ColorType makeFromComponentsClamping(T c1, T c2, T c3, T alpha)
{
- return makeFromComponents<ColorType>(ColorComponents {
- clampedComponent<ColorType, 0>(c1),
- clampedComponent<ColorType, 1>(c2),
- clampedComponent<ColorType, 2>(c3),
- clampedAlpha<T, typename ColorType::ComponentType>(alpha)
- });
+ return makeFromComponents<ColorType>(ColorComponents { clampedComponent<ColorType, 0>(c1), clampedComponent<ColorType, 1>(c2), clampedComponent<ColorType, 2>(c3), clampedAlpha<T, typename ColorType::ComponentType>(alpha) });
}
template<typename ColorType, typename T> constexpr ColorType makeFromComponentsClampingExceptAlpha(const ColorComponents<T>& components)
@@ -223,14 +126,89 @@
template<typename ColorType, typename T, typename Alpha> constexpr ColorType makeFromComponentsClampingExceptAlpha(T c1, T c2, T c3, Alpha alpha)
{
- return makeFromComponents<ColorType>(ColorComponents {
- clampedComponent<ColorType, 0>(c1),
- clampedComponent<ColorType, 1>(c2),
- clampedComponent<ColorType, 2>(c3),
- alpha
- });
+ return makeFromComponents<ColorType>(ColorComponents { clampedComponent<ColorType, 0>(c1), clampedComponent<ColorType, 1>(c2), clampedComponent<ColorType, 2>(c3), alpha });
}
+// MARK: - Models
+
+template<> struct AlphaTraits<float> {
+ static constexpr float transparent = 0.0f;
+ static constexpr float opaque = 1.0f;
+};
+
+template<> struct AlphaTraits<uint8_t> {
+ static constexpr uint8_t transparent = 0;
+ static constexpr uint8_t opaque = 255;
+};
+
+template<typename T> struct ColorComponentRange {
+ T min;
+ T max;
+};
+
+template<> struct ExtendedRGBModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
+ } };
+ static constexpr bool isInvertible = false;
+};
+
+template<> struct HSLModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { 0, 360 },
+ { 0, 100 },
+ { 0, 100 }
+ } };
+ static constexpr bool isInvertible = true;
+};
+
+template<> struct LabModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { 0, std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
+ } };
+ static constexpr bool isInvertible = false;
+};
+
+template<> struct LCHModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { 0, std::numeric_limits<float>::infinity() },
+ { 0, std::numeric_limits<float>::infinity() },
+ { 0, 360 }
+ } };
+ static constexpr bool isInvertible = false;
+};
+
+template<> struct RGBModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { 0, 1 },
+ { 0, 1 },
+ { 0, 1 }
+ } };
+ static constexpr bool isInvertible = true;
+};
+
+template<> struct RGBModel<uint8_t> {
+ static constexpr std::array<ColorComponentRange<uint8_t>, 3> ranges { {
+ { 0, 255 },
+ { 0, 255 },
+ { 0, 255 }
+ } };
+ static constexpr bool isInvertible = true;
+};
+
+template<> struct XYZModel<float> {
+ static constexpr std::array<ColorComponentRange<float>, 3> ranges { {
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() },
+ { -std::numeric_limits<float>::infinity(), std::numeric_limits<float>::infinity() }
+ } };
+ static constexpr bool isInvertible = false;
+};
+
#if ASSERT_ENABLED
template<typename T> constexpr void assertInRange(T color)
@@ -328,21 +306,14 @@
return { c.red, c.green, c.blue, c.alpha };
}
-template<typename T> struct SRGBA : RGBAType<SRGBA, T, RGBModel<T>> {
- using RGBAType<SRGBA, T, RGBModel<T>>::RGBAType;
- using LinearCounterpart = LinearSRGBA<T>;
- static constexpr auto colorSpace { ColorSpace::SRGB };
-};
-template<typename T> SRGBA(T, T, T, T) -> SRGBA<T>;
-template<typename T> struct LinearSRGBA : RGBAType<LinearSRGBA, T, RGBModel<T>> {
- using RGBAType<LinearSRGBA, T, RGBModel<T>>::RGBAType;
- using GammaEncodedCounterpart = SRGBA<T>;
- static constexpr auto colorSpace = ColorSpace::LinearRGB;
+template<typename T> struct A98RGB : RGBAType<A98RGB, T, RGBModel<T>> {
+ using RGBAType<A98RGB, T, RGBModel<T>>::RGBAType;
+ using LinearCounterpart = LinearA98RGB<T>;
+ static constexpr auto colorSpace = ColorSpace::A98RGB;
};
-template<typename T> LinearSRGBA(T, T, T, T) -> LinearSRGBA<T>;
+template<typename T> A98RGB(T, T, T, T) -> A98RGB<T>;
-
template<typename T> struct ExtendedSRGBA : RGBAType<ExtendedSRGBA, T, ExtendedRGBModel<T>> {
using RGBAType<ExtendedSRGBA, T, ExtendedRGBModel<T>>::RGBAType;
using LinearCounterpart = LinearExtendedSRGBA<T>;
@@ -349,6 +320,18 @@
};
template<typename T> ExtendedSRGBA(T, T, T, T) -> ExtendedSRGBA<T>;
+template<typename T> struct LinearA98RGB : RGBAType<LinearA98RGB, T, RGBModel<T>> {
+ using RGBAType<LinearA98RGB, T, RGBModel<T>>::RGBAType;
+ using GammaEncodedCounterpart = A98RGB<T>;
+};
+template<typename T> LinearA98RGB(T, T, T, T) -> LinearA98RGB<T>;
+
+template<typename T> struct LinearDisplayP3 : RGBAType<LinearDisplayP3, T, RGBModel<T>> {
+ using RGBAType<LinearDisplayP3, T, RGBModel<T>>::RGBAType;
+ using GammaEncodedCounterpart = DisplayP3<T>;
+};
+template<typename T> LinearDisplayP3(T, T, T, T) -> LinearDisplayP3<T>;
+
template<typename T> struct LinearExtendedSRGBA : RGBAType<LinearExtendedSRGBA, T, ExtendedRGBModel<T>> {
using RGBAType<LinearExtendedSRGBA, T, ExtendedRGBModel<T>>::RGBAType;
using GammaEncodedCounterpart = ExtendedSRGBA<T>;
@@ -355,7 +338,20 @@
};
template<typename T> LinearExtendedSRGBA(T, T, T, T) -> LinearExtendedSRGBA<T>;
+template<typename T> struct LinearSRGBA : RGBAType<LinearSRGBA, T, RGBModel<T>> {
+ using RGBAType<LinearSRGBA, T, RGBModel<T>>::RGBAType;
+ using GammaEncodedCounterpart = SRGBA<T>;
+ static constexpr auto colorSpace = ColorSpace::LinearRGB;
+};
+template<typename T> LinearSRGBA(T, T, T, T) -> LinearSRGBA<T>;
+template<typename T> struct SRGBA : RGBAType<SRGBA, T, RGBModel<T>> {
+ using RGBAType<SRGBA, T, RGBModel<T>>::RGBAType;
+ using LinearCounterpart = LinearSRGBA<T>;
+ static constexpr auto colorSpace { ColorSpace::SRGB };
+};
+template<typename T> SRGBA(T, T, T, T) -> SRGBA<T>;
+
template<typename T> struct DisplayP3 : RGBAType<DisplayP3, T, RGBModel<T>> {
using RGBAType<DisplayP3, T, RGBModel<T>>::RGBAType;
using LinearCounterpart = LinearDisplayP3<T>;
@@ -363,27 +359,6 @@
};
template<typename T> DisplayP3(T, T, T, T) -> DisplayP3<T>;
-template<typename T> struct LinearDisplayP3 : RGBAType<LinearDisplayP3, T, RGBModel<T>> {
- using RGBAType<LinearDisplayP3, T, RGBModel<T>>::RGBAType;
- using GammaEncodedCounterpart = DisplayP3<T>;
-};
-template<typename T> LinearDisplayP3(T, T, T, T) -> LinearDisplayP3<T>;
-
-
-template<typename T> struct A98RGB : RGBAType<A98RGB, T, RGBModel<T>> {
- using RGBAType<A98RGB, T, RGBModel<T>>::RGBAType;
- using LinearCounterpart = LinearA98RGB<T>;
- static constexpr auto colorSpace = ColorSpace::A98RGB;
-};
-template<typename T> A98RGB(T, T, T, T) -> A98RGB<T>;
-
-template<typename T> struct LinearA98RGB : RGBAType<LinearA98RGB, T, RGBModel<T>> {
- using RGBAType<LinearA98RGB, T, RGBModel<T>>::RGBAType;
- using GammaEncodedCounterpart = A98RGB<T>;
-};
-template<typename T> LinearA98RGB(T, T, T, T) -> LinearA98RGB<T>;
-
-
// MARK: - Lab Color Type.
template<typename T> struct Lab : ColorWithAlphaHelper<Lab<T>> {
Modified: trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.cpp (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.cpp 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.cpp 2021-01-28 20:50:10 UTC (rev 272033)
@@ -33,39 +33,18 @@
namespace WebCore {
-CGColorSpaceRef sRGBColorSpaceRef()
+CGColorSpaceRef a98RGBColorSpaceRef()
{
- static CGColorSpaceRef sRGBColorSpace;
+ static CGColorSpaceRef a98RGBColorSpace;
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
-#if PLATFORM(WIN)
- // Out-of-date CG installations will not honor kCGColorSpaceSRGB. This logic avoids
- // causing a crash under those conditions. Since the default color space in Windows
- // is sRGB, this all works out nicely.
- // FIXME: Is this still needed? rdar://problem/15213515 was fixed.
- sRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
- if (!sRGBColorSpace)
- sRGBColorSpace = CGColorSpaceCreateDeviceRGB();
+#if PLATFORM(COCOA)
+ a98RGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceAdobeRGB1998);
#else
- sRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
-#endif // PLATFORM(WIN)
- });
- return sRGBColorSpace;
-}
-
-CGColorSpaceRef linearRGBColorSpaceRef()
-{
- static CGColorSpaceRef linearRGBColorSpace;
- static std::once_flag onceFlag;
- std::call_once(onceFlag, [] {
-#if PLATFORM(WIN)
- // FIXME: Windows should be able to use linear sRGB, this is tracked by http://webkit.org/b/80000.
- linearRGBColorSpace = sRGBColorSpaceRef();
-#else
- linearRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceLinearSRGB);
+ a98RGBColorSpace = sRGBColorSpaceRef();
#endif
});
- return linearRGBColorSpace;
+ return a98RGBColorSpace;
}
CGColorSpaceRef displayP3ColorSpaceRef()
@@ -82,18 +61,22 @@
return displayP3ColorSpace;
}
-CGColorSpaceRef a98RGBColorSpaceRef()
+CGColorSpaceRef extendedSRGBColorSpaceRef()
{
- static CGColorSpaceRef a98RGBColorSpace;
+ static CGColorSpaceRef extendedSRGBColorSpace;
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
+ CGColorSpaceRef colorSpace = nullptr;
#if PLATFORM(COCOA)
- a98RGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceAdobeRGB1998);
-#else
- a98RGBColorSpace = sRGBColorSpaceRef();
+ colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceExtendedSRGB);
#endif
+ // If there is no support for extended sRGB, fall back to sRGB.
+ if (!colorSpace)
+ colorSpace = sRGBColorSpaceRef();
+
+ extendedSRGBColorSpace = colorSpace;
});
- return a98RGBColorSpace;
+ return extendedSRGBColorSpace;
}
CGColorSpaceRef labColorSpaceRef()
@@ -102,22 +85,39 @@
return sRGBColorSpaceRef();
}
-CGColorSpaceRef extendedSRGBColorSpaceRef()
+CGColorSpaceRef linearRGBColorSpaceRef()
{
- static CGColorSpaceRef extendedSRGBColorSpace;
+ static CGColorSpaceRef linearRGBColorSpace;
static std::once_flag onceFlag;
std::call_once(onceFlag, [] {
- CGColorSpaceRef colorSpace = nullptr;
-#if PLATFORM(COCOA)
- colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceExtendedSRGB);
+#if PLATFORM(WIN)
+ // FIXME: Windows should be able to use linear sRGB, this is tracked by http://webkit.org/b/80000.
+ linearRGBColorSpace = sRGBColorSpaceRef();
+#else
+ linearRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceLinearSRGB);
#endif
- // If there is no support for extended sRGB, fall back to sRGB.
- if (!colorSpace)
- colorSpace = sRGBColorSpaceRef();
+ });
+ return linearRGBColorSpace;
+}
- extendedSRGBColorSpace = colorSpace;
+CGColorSpaceRef sRGBColorSpaceRef()
+{
+ static CGColorSpaceRef sRGBColorSpace;
+ static std::once_flag onceFlag;
+ std::call_once(onceFlag, [] {
+#if PLATFORM(WIN)
+ // Out-of-date CG installations will not honor kCGColorSpaceSRGB. This logic avoids
+ // causing a crash under those conditions. Since the default color space in Windows
+ // is sRGB, this all works out nicely.
+ // FIXME: Is this still needed? rdar://problem/15213515 was fixed.
+ sRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+ if (!sRGBColorSpace)
+ sRGBColorSpace = CGColorSpaceCreateDeviceRGB();
+#else
+ sRGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceSRGB);
+#endif // PLATFORM(WIN)
});
- return extendedSRGBColorSpace;
+ return sRGBColorSpace;
}
}
Modified: trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.h (272032 => 272033)
--- trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.h 2021-01-28 20:47:48 UTC (rev 272032)
+++ trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.h 2021-01-28 20:50:10 UTC (rev 272033)
@@ -31,26 +31,27 @@
namespace WebCore {
-WEBCORE_EXPORT CGColorSpaceRef sRGBColorSpaceRef();
-WEBCORE_EXPORT CGColorSpaceRef linearRGBColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef a98RGBColorSpaceRef();
WEBCORE_EXPORT CGColorSpaceRef displayP3ColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef extendedSRGBColorSpaceRef();
WEBCORE_EXPORT CGColorSpaceRef labColorSpaceRef();
-WEBCORE_EXPORT CGColorSpaceRef a98RGBColorSpaceRef();
-WEBCORE_EXPORT CGColorSpaceRef extendedSRGBColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef linearRGBColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef rec2020ColorSpaceRef();
+WEBCORE_EXPORT CGColorSpaceRef sRGBColorSpaceRef();
static inline CGColorSpaceRef cachedCGColorSpace(ColorSpace colorSpace)
{
switch (colorSpace) {
- case ColorSpace::SRGB:
- return sRGBColorSpaceRef();
- case ColorSpace::LinearRGB:
- return linearRGBColorSpaceRef();
+ case ColorSpace::A98RGB:
+ return a98RGBColorSpaceRef();
case ColorSpace::DisplayP3:
return displayP3ColorSpaceRef();
- case ColorSpace::A98RGB:
- return a98RGBColorSpaceRef();
case ColorSpace::Lab:
return labColorSpaceRef();
+ case ColorSpace::LinearRGB:
+ return linearRGBColorSpaceRef();
+ case ColorSpace::SRGB:
+ return sRGBColorSpaceRef();
}
ASSERT_NOT_REACHED();
return sRGBColorSpaceRef();
