Changeset 271992 in webkit


Ignore:
Timestamp:
Jan 27, 2021 5:22:09 PM (18 months ago)
Author:
weinig@apple.com
Message:

Add support for color(a98-rgb ...) as part of CSS Color 4
​https://bugs.webkit.org/show_bug.cgi?id=221018

Reviewed by Darin Adler.

LayoutTests/imported/w3c:

Add some new WPT tests for color(a98-rgb ) that will be upstreamed shortly.

  • web-platform-tests/css/css-color/a98rgb-001-expected.html: Added.
  • web-platform-tests/css/css-color/a98rgb-001.html: Added.
  • web-platform-tests/css/css-color/a98rgb-002-expected.html: Added.
  • web-platform-tests/css/css-color/a98rgb-002.html: Added.
  • web-platform-tests/css/css-color/a98rgb-003-expected.html: Added.
  • web-platform-tests/css/css-color/a98rgb-003.html: Added.
  • web-platform-tests/css/css-color/a98rgb-004-expected.html: Added.
  • web-platform-tests/css/css-color/a98rgb-004.html: Added.

Source/WebCore:

  • css/CSSValueKeywords.in:

Add keyword for a98-rgb and a comment indicating that lab, which already exists as a value,
is also a valid identifier for the color function.

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionParameters):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionForSRGBOrDisplayP3Parameters): Deleted.
Generalize parseColorFunctionForSRGBOrDisplayP3Parameters to work for all RGB types, which now include
A98RGB.

  • platform/graphics/ColorConversion.cpp:

(WebCore::SRGBTransferFunction::fromLinearClamping):
(WebCore::SRGBTransferFunction::toLinearClamping):
(WebCore::SRGBTransferFunction::fromLinearNonClamping):
(WebCore::SRGBTransferFunction::toLinearNonClamping):
(WebCore::A98RGBTransferFunction::fromLinearClamping):
(WebCore::A98RGBTransferFunction::toLinearClamping):
(WebCore::A98RGBTransferFunction::fromLinearNonClamping):
(WebCore::A98RGBTransferFunction::toLinearNonClamping):
(WebCore::toLinearClamping):
(WebCore::fromLinearClamping):
(WebCore::toLinearNonClamping):
(WebCore::fromLinearNonClamping):
(WebCore::toLinearSRGBA):
(WebCore::toLinearExtendedSRGBA):
(WebCore::toSRGBA):
(WebCore::toExtendedSRGBA):
(WebCore::toLinearDisplayP3):
(WebCore::toDisplayP3):
(WebCore::toLinearA98RGB):
(WebCore::toA98RGB):
(WebCore::toXYZA):
(WebCore::linearToRGBColorComponentClamping): Deleted.
(WebCore::rgbToLinearColorComponentClamping): Deleted.
(WebCore::linearToRGBColorComponentNonClamping): Deleted.
(WebCore::rgbToLinearColorComponentNonClamping): Deleted.

  • platform/graphics/ColorConversion.h:

(WebCore::toA98RGB):
(WebCore::toLinearA98RGB):
(WebCore::callWithColorType):
Add conversion support for A98RGB and LinearA98RGB. Move gamma conversion functions
into structs named for the type of transfer function. While not used currently, this
will allow future templatizing of conversion to avoid so much boiler plate in the
future.

  • platform/graphics/ColorSerialization.cpp:

(WebCore::serialization):
(WebCore::serializationForCSS):
(WebCore::serializationForHTML):
(WebCore::serializationForRenderTreeAsText):

  • platform/graphics/ColorSerialization.h:

Add serialization support for color(a98-rgb ...).

  • platform/graphics/ColorSpace.cpp:
  • platform/graphics/ColorSpace.h:

Add A98RGB as a ColorSpace, which really just means it is something
ExtendedColor can hold.

  • platform/graphics/cg/ColorSpaceCG.cpp:
  • platform/graphics/cg/ColorSpaceCG.h:

Add support for creating a CGColorSpace for A98RGB.

  • platform/graphics/ColorTypes.h:

(WebCore::operator==):
(WebCore::operator!=):
(WebCore::RGBAType::RGBAType):
(WebCore::asColorComponents):
(WebCore::SRGBA::SRGBA): Deleted.
(WebCore::ExtendedSRGBA::ExtendedSRGBA): Deleted.
(WebCore::LinearSRGBA::LinearSRGBA): Deleted.
(WebCore::LinearExtendedSRGBA::LinearExtendedSRGBA): Deleted.
(WebCore::DisplayP3::DisplayP3): Deleted.
(WebCore::LinearDisplayP3::LinearDisplayP3): Deleted.
(WebCore::callWithColorType): Deleted.
Simplify adding new RGB color types by adding a shared base class, RGBAType
and and a shared asColorComponents funciton. Also simplify all color types
by removing the need to define your own operator==/!= for each type by having
a single one that operates on any type that can have asColorComponents() called
on it.

To create a new RGB color (one with red, green and blue named components) one
now only needs to do:

template<typename T> struct Foo : RGBAType<Foo, T, RGBModel<T>> {

using RGBAType<Foo, T, RGBModel<T>>::RGBAType;

};
template<typename T> Foo(T, T, T, T) -> Foo<T>;

Additionally, if the type has gamma encoded and linear versions, it should have
either a using GammaEncoded = ... or using Linear = ... decalaring its
counterpart and should add a colorSpace member if the type is used by ExtendedColor.

Note, the deduction guide is necessary to keep things like the following working:

auto color = SRGB { float1, float2, ... };

Unfortunately, deduction does not come along when you explitily inherit constructors
like is being done for these. See the "Deducing from inherited constructors" section
in ​http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1021r4.html.

  • platform/graphics/cairo/ImageBufferCairoBackend.cpp:

(WebCore::ImageBufferCairoBackend::transformColorSpace):
Update to use new name for gamma conversion functions.

LayoutTests:

Un-fail some now passing tests.

  • fast/css/parsing-a98rgb-colors-expected.txt: Added.
  • fast/css/parsing-a98rgb-colors.html: Added.

Add new tests for parsing color(a98-rgb ) colors.

Location:
trunk
Files:
10 added
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r271988 r271992  
     12021-01-27  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(a98-rgb ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221018
     5
     6        Reviewed by Darin Adler.
     7
     8        * TestExpectations:
     9        Un-fail some now passing tests.
     10
     11        * fast/css/parsing-a98rgb-colors-expected.txt: Added.
     12        * fast/css/parsing-a98rgb-colors.html: Added.
     13        Add new tests for parsing color(a98-rgb ) colors.
     14
    1152021-01-27  Ada Chan  <ada.chan@apple.com>
    216

  • trunk/LayoutTests/TestExpectations

    r271988 r271992  
    45994599webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-003.html [ ImageOnlyFailure ] # Invalid test, no colorspace specified
    46004600webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-004.html [ ImageOnlyFailure ] # Invalid test, no colorspace specified
    4601 webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-007.html [ ImageOnlyFailure ] # Requires a98-rgb support
    4602 webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-008.html [ ImageOnlyFailure ] # Requires a98-rgb support
    46034601webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-009.html [ ImageOnlyFailure ] # Requires prophoto-rgb support
    46044602webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-010.html [ ImageOnlyFailure ] # Requires prophoto-rgb support

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r271944 r271992  
     12021-01-27  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(a98-rgb ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221018
     5
     6        Reviewed by Darin Adler.
     7
     8        Add some new WPT tests for color(a98-rgb ) that will be upstreamed shortly.
     9
     10        * web-platform-tests/css/css-color/a98rgb-001-expected.html: Added.
     11        * web-platform-tests/css/css-color/a98rgb-001.html: Added.
     12        * web-platform-tests/css/css-color/a98rgb-002-expected.html: Added.
     13        * web-platform-tests/css/css-color/a98rgb-002.html: Added.
     14        * web-platform-tests/css/css-color/a98rgb-003-expected.html: Added.
     15        * web-platform-tests/css/css-color/a98rgb-003.html: Added.
     16        * web-platform-tests/css/css-color/a98rgb-004-expected.html: Added.
     17        * web-platform-tests/css/css-color/a98rgb-004.html: Added.
     18
    1192021-01-27  Manuel Rego Casasnovas  <rego@igalia.com>
    220

  • trunk/Source/WebCore/ChangeLog

    r271988 r271992  
     12021-01-27  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(a98-rgb ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221018
     5
     6        Reviewed by Darin Adler.
     7
     8        * css/CSSValueKeywords.in:
     9        Add keyword for a98-rgb and a comment indicating that lab, which already exists as a value,
     10        is also a valid identifier for the color function.
     11 
     12        * css/parser/CSSPropertyParserHelpers.cpp:
     13        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
     14        (WebCore::CSSPropertyParserHelpers::parseColorFunctionParameters):
     15        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForSRGBOrDisplayP3Parameters): Deleted.
     16        Generalize parseColorFunctionForSRGBOrDisplayP3Parameters to work for all RGB types, which now include
     17        A98RGB.
     18
     19        * platform/graphics/ColorConversion.cpp:
     20        (WebCore::SRGBTransferFunction::fromLinearClamping):
     21        (WebCore::SRGBTransferFunction::toLinearClamping):
     22        (WebCore::SRGBTransferFunction::fromLinearNonClamping):
     23        (WebCore::SRGBTransferFunction::toLinearNonClamping):
     24        (WebCore::A98RGBTransferFunction::fromLinearClamping):
     25        (WebCore::A98RGBTransferFunction::toLinearClamping):
     26        (WebCore::A98RGBTransferFunction::fromLinearNonClamping):
     27        (WebCore::A98RGBTransferFunction::toLinearNonClamping):
     28        (WebCore::toLinearClamping):
     29        (WebCore::fromLinearClamping):
     30        (WebCore::toLinearNonClamping):
     31        (WebCore::fromLinearNonClamping):
     32        (WebCore::toLinearSRGBA):
     33        (WebCore::toLinearExtendedSRGBA):
     34        (WebCore::toSRGBA):
     35        (WebCore::toExtendedSRGBA):
     36        (WebCore::toLinearDisplayP3):
     37        (WebCore::toDisplayP3):
     38        (WebCore::toLinearA98RGB):
     39        (WebCore::toA98RGB):
     40        (WebCore::toXYZA):
     41        (WebCore::linearToRGBColorComponentClamping): Deleted.
     42        (WebCore::rgbToLinearColorComponentClamping): Deleted.
     43        (WebCore::linearToRGBColorComponentNonClamping): Deleted.
     44        (WebCore::rgbToLinearColorComponentNonClamping): Deleted.
     45        * platform/graphics/ColorConversion.h:
     46        (WebCore::toA98RGB):
     47        (WebCore::toLinearA98RGB):
     48        (WebCore::callWithColorType):
     49        Add conversion support for A98RGB and LinearA98RGB. Move gamma conversion functions
     50        into structs named for the type of transfer function. While not used currently, this
     51        will allow future templatizing of conversion to avoid so much boiler plate in the
     52        future.
     53
     54        * platform/graphics/ColorSerialization.cpp:
     55        (WebCore::serialization):
     56        (WebCore::serializationForCSS):
     57        (WebCore::serializationForHTML):
     58        (WebCore::serializationForRenderTreeAsText):
     59        * platform/graphics/ColorSerialization.h:
     60        Add serialization support for color(a98-rgb ...).
     61
     62        * platform/graphics/ColorSpace.cpp:
     63        * platform/graphics/ColorSpace.h:
     64        Add A98RGB as a ColorSpace, which really just means it is something
     65        ExtendedColor can hold.
     66
     67        * platform/graphics/cg/ColorSpaceCG.cpp:
     68        * platform/graphics/cg/ColorSpaceCG.h:
     69        Add support for creating a CGColorSpace for A98RGB.
     70
     71        * platform/graphics/ColorTypes.h:
     72        (WebCore::operator==):
     73        (WebCore::operator!=):
     74        (WebCore::RGBAType::RGBAType):
     75        (WebCore::asColorComponents):
     76        (WebCore::SRGBA::SRGBA): Deleted.
     77        (WebCore::ExtendedSRGBA::ExtendedSRGBA): Deleted.
     78        (WebCore::LinearSRGBA::LinearSRGBA): Deleted.
     79        (WebCore::LinearExtendedSRGBA::LinearExtendedSRGBA): Deleted.
     80        (WebCore::DisplayP3::DisplayP3): Deleted.
     81        (WebCore::LinearDisplayP3::LinearDisplayP3): Deleted.
     82        (WebCore::callWithColorType): Deleted.
     83        Simplify adding new RGB color types by adding a shared base class, RGBAType
     84        and and a shared asColorComponents funciton. Also simplify all color types
     85        by removing the need to define your own operator==/!= for each type by having
     86        a single one that operates on any type that can have asColorComponents() called
     87        on it.
     88       
     89        To create a new RGB color (one with red, green and blue named components) one
     90        now only needs to do:
     91       
     92            template<typename T> struct Foo : RGBAType<Foo, T, RGBModel<T>> {
     93                using RGBAType<Foo, T, RGBModel<T>>::RGBAType;
     94            };
     95            template<typename T> Foo(T, T, T, T) -> Foo<T>;
     96
     97        Additionally, if the type has gamma encoded and linear versions, it should have
     98        either a `using GammaEncoded = ...` or `using Linear = ...` decalaring its
     99        counterpart and should add a colorSpace member if the type is used by ExtendedColor.
     100
     101        Note, the deduction guide is necessary to keep things like the following working:
     102           
     103            auto color = SRGB { float1, float2, ... };
     104           
     105        Unfortunately, deduction does not come along when you explitily inherit constructors
     106        like is being done for these. See the "Deducing from inherited constructors" section
     107        in http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1021r4.html.
     108
     109        * platform/graphics/cairo/ImageBufferCairoBackend.cpp:
     110        (WebCore::ImageBufferCairoBackend::transformColorSpace):
     111        Update to use new name for gamma conversion functions.
     112
    11132021-01-27  Ada Chan  <ada.chan@apple.com>
    2114

  • trunk/Source/WebCore/css/CSSValueKeywords.in

    r271362 r271992  
    14081408sRGB
    14091409display-p3
     1410a98-rgb
     1411// lab
    14101412
    14111413// prefers-default-appearance

  • trunk/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp

    r271866 r271992  
    876876
    877877template<typename ColorType>
    878 static Color parseColorFunctionForSRGBOrDisplayP3Parameters(CSSParserTokenRange& args)
    879 {
    880     ASSERT(args.peek().id() == CSSValueSRGB || args.peek().id() == CSSValueDisplayP3);
     878static Color parseColorFunctionForRGBTypes(CSSParserTokenRange& args)
     879{
     880    ASSERT(args.peek().id() == CSSValueSRGB || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueA98Rgb);
    881881    consumeIdentRaw(args);
    882882
    … …  
    937937    switch (args.peek().id()) {
    938938    case CSSValueSRGB:
    939         color = parseColorFunctionForSRGBOrDisplayP3Parameters<SRGBA<float>>(args);
     939        color = parseColorFunctionForRGBTypes<SRGBA<float>>(args);
    940940        break;
    941941    case CSSValueDisplayP3:
    942         color = parseColorFunctionForSRGBOrDisplayP3Parameters<DisplayP3<float>>(args);
     942        color = parseColorFunctionForRGBTypes<DisplayP3<float>>(args);
     943        break;
     944    case CSSValueA98Rgb:
     945        color = parseColorFunctionForRGBTypes<A98RGB<float>>(args);
    943946        break;
    944947    case CSSValueLab:

  • trunk/Source/WebCore/platform/graphics/ColorConversion.cpp

    r271723 r271992  
    6363};
    6464
     65// https://drafts.csswg.org/css-color/#color-conversion-code
     66static constexpr ColorMatrix<3, 3> xyzToLinearA98RGBMatrix {
     67     2.493496911941425f,  -0.9313836179191239f, -0.4027107844507168f,
     68    -0.8294889695615747f,  1.7626640603183463f,  0.0236246858419436f,
     69     0.0358458302437845f, -0.0761723892680418f,  0.9568845240076872f
     70};
     71
     72// https://drafts.csswg.org/css-color/#color-conversion-code
     73static constexpr ColorMatrix<3, 3> linearA98RGBToXYZMatrix {
     74    0.5766690429101305f,   0.1855582379065463f,   0.1882286462349947f,
     75    0.29734497525053605f,  0.6273635662554661f,   0.07529145849399788f,
     76    0.02703136138641234f,  0.07068885253582723f,  0.9913375368376388f
     77};
     78
    6579// http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html
    6680static constexpr ColorMatrix<3, 3> D50ToD65Matrix {
    … …  
    7993// Gamma conversions.
    8094
    81 float linearToRGBColorComponentClamping(float c)
     95float SRGBTransferFunction::fromLinearClamping(float c)
    8296{
    8397    if (c < 0.0031308f)
    … …  
    87101}
    88102
    89 float rgbToLinearColorComponentClamping(float c)
     103float SRGBTransferFunction::toLinearClamping(float c)
    90104{
    91105    if (c <= 0.04045f)
    … …  
    95109}
    96110
    97 float linearToRGBColorComponentNonClamping(float c)
    98 {
    99     float sign = c > 0 ? 1.0f : -1.0f;
     111float SRGBTransferFunction::fromLinearNonClamping(float c)
     112{
     113    float sign = std::signbit(c) ? -1.0f : 1.0f;
    100114    c = std::abs(c);
    101115
    … …  
    106120}
    107121
    108 float rgbToLinearColorComponentNonClamping(float c)
    109 {
    110     float sign = c > 0 ? 1.0f : -1.0f;
     122float SRGBTransferFunction::toLinearNonClamping(float c)
     123{
     124    float sign = std::signbit(c) ? -1.0f : 1.0f;
    111125    c = std::abs(c);
    112126
    … …  
    117131}
    118132
     133float A98RGBTransferFunction::fromLinearClamping(float c)
     134{
     135    return clampTo<float>(fromLinearNonClamping(c), 0, 1);
     136}
     137
     138float A98RGBTransferFunction::toLinearClamping(float c)
     139{
     140    return clampTo<float>(toLinearNonClamping(c), 0, 1);
     141}
     142
     143float A98RGBTransferFunction::fromLinearNonClamping(float c)
     144{
     145    float sign = std::signbit(c) ? -1.0f : 1.0f;
     146    return std::pow(std::abs(c), 256.0f / 563.0f) * sign;
     147}
     148
     149float A98RGBTransferFunction::toLinearNonClamping(float c)
     150{
     151    float sign = std::signbit(c) ? -1.0f : 1.0f;
     152    return std::pow(std::abs(c), 563.0f / 256.0f) * sign;
     153}
     154
     155template<typename TransferFunction, typename T> static auto toLinearClamping(const T& color) -> typename T::LinearCounterpart
     156{
     157    auto [c1, c2, c3, alpha] = color;
     158    return { TransferFunction::toLinearClamping(c1), TransferFunction::toLinearClamping(c2), TransferFunction::toLinearClamping(c3), alpha };
     159}
     160
     161template<typename TransferFunction, typename T> static auto fromLinearClamping(const T& color) -> typename T::GammaEncodedCounterpart
     162{
     163    auto [c1, c2, c3, alpha] = color;
     164    return { TransferFunction::fromLinearClamping(c1), TransferFunction::fromLinearClamping(c2), TransferFunction::fromLinearClamping(c3), alpha };
     165}
     166
     167template<typename TransferFunction, typename T> static auto toLinearNonClamping(const T& color) -> typename T::LinearCounterpart
     168{
     169    auto [c1, c2, c3, alpha] = color;
     170    return { TransferFunction::toLinearNonClamping(c1), TransferFunction::toLinearNonClamping(c2), TransferFunction::toLinearNonClamping(c3), alpha };
     171}
     172
     173template<typename TransferFunction, typename T> static auto fromLinearNonClamping(const T& color) -> typename T::GammaEncodedCounterpart
     174{
     175    auto [c1, c2, c3, alpha] = color;
     176    return { TransferFunction::fromLinearNonClamping(c1), TransferFunction::fromLinearNonClamping(c2), TransferFunction::fromLinearNonClamping(c3), alpha };
     177}
     178
    119179LinearSRGBA<float> toLinearSRGBA(const SRGBA<float>& color)
    120180{
    121     return {
    122         rgbToLinearColorComponentClamping(color.red),
    123         rgbToLinearColorComponentClamping(color.green),
    124         rgbToLinearColorComponentClamping(color.blue),
    125         color.alpha
    126     };
     181    return toLinearClamping<SRGBTransferFunction>(color);
    127182}
    128183
    129184LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const ExtendedSRGBA<float>& color)
    130185{
    131     return {
    132         rgbToLinearColorComponentNonClamping(color.red),
    133         rgbToLinearColorComponentNonClamping(color.green),
    134         rgbToLinearColorComponentNonClamping(color.blue),
    135         color.alpha
    136     };
     186    return toLinearNonClamping<SRGBTransferFunction>(color);
    137187}
    138188
    139189SRGBA<float> toSRGBA(const LinearSRGBA<float>& color)
    140190{
    141     return {
    142         linearToRGBColorComponentClamping(color.red),
    143         linearToRGBColorComponentClamping(color.green),
    144         linearToRGBColorComponentClamping(color.blue),
    145         color.alpha
    146     };
     191    return fromLinearClamping<SRGBTransferFunction>(color);
    147192}
    148193
    149194ExtendedSRGBA<float> toExtendedSRGBA(const LinearExtendedSRGBA<float>& color)
    150195{
    151     return {
    152         linearToRGBColorComponentNonClamping(color.red),
    153         linearToRGBColorComponentNonClamping(color.green),
    154         linearToRGBColorComponentNonClamping(color.blue),
    155         color.alpha
    156     };
     196    return fromLinearNonClamping<SRGBTransferFunction>(color);
    157197}
    158198
    159199LinearDisplayP3<float> toLinearDisplayP3(const DisplayP3<float>& color)
    160200{
    161     return {
    162         rgbToLinearColorComponentClamping(color.red),
    163         rgbToLinearColorComponentClamping(color.green),
    164         rgbToLinearColorComponentClamping(color.blue),
    165         color.alpha
    166     };
     201    return toLinearClamping<SRGBTransferFunction>(color);
    167202}
    168203
    169204DisplayP3<float> toDisplayP3(const LinearDisplayP3<float>& color)
    170205{
    171     return {
    172         linearToRGBColorComponentClamping(color.red),
    173         linearToRGBColorComponentClamping(color.green),
    174         linearToRGBColorComponentClamping(color.blue),
    175         color.alpha
    176     };
    177 }
    178 
    179 // Matrix conversions.
     206    return fromLinearClamping<SRGBTransferFunction>(color);
     207}
     208
     209LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>& color)
     210{
     211    return toLinearClamping<A98RGBTransferFunction>(color);
     212}
     213
     214A98RGB<float> toA98RGB(const LinearA98RGB<float>& color)
     215{
     216    return fromLinearClamping<A98RGBTransferFunction>(color);
     217}
     218
     219// Matrix conversions (to and from XYZ for all linear color types).
     220
     221// - LinearSRGBA matrix conversions.
    180222
    181223LinearSRGBA<float> toLinearSRGBA(const XYZA<float>& color)
    … …  
    189231}
    190232
     233// - LinearExtendedSRGBA matrix conversions.
     234
    191235LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const XYZA<float>& color)
    192236{
    … …  
    199243}
    200244
     245// - LinearDisplayP3 matrix conversions.
     246
    201247LinearDisplayP3<float> toLinearDisplayP3(const XYZA<float>& color)
    202248{
    … …  
    207253{
    208254    return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearDisplayP3ToXYZMatrix.transformedColorComponents(asColorComponents(color)));
     255}
     256
     257// - LinearA98RGB matrix conversions.
     258
     259LinearA98RGB<float> toLinearA98RGB(const XYZA<float>& color)
     260{
     261    return makeFromComponentsClampingExceptAlpha<LinearA98RGB<float>>(xyzToLinearA98RGBMatrix.transformedColorComponents(asColorComponents(color)));
     262}
     263
     264XYZA<float> toXYZA(const LinearA98RGB<float>& color)
     265{
     266    return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearA98RGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
    209267}
    210268
    … …  
    407465// Combination conversions (constructed from more basic conversions above).
    408466
     467// - SRGB combination functions.
     468
    409469XYZA<float> toXYZA(const SRGBA<float>& color)
    410470{
    … …  
    417477}
    418478
     479// - ExtendedSRGB combination functions.
     480
    419481XYZA<float> toXYZA(const ExtendedSRGBA<float>& color)
    420482{
    … …  
    427489}
    428490
     491// - DisplayP3 combination functions.
     492
    429493XYZA<float> toXYZA(const DisplayP3<float>& color)
    430494{
    … …  
    437501}
    438502
     503// - A98RGB combination functions.
     504
     505XYZA<float> toXYZA(const A98RGB<float>& color)
     506{
     507    return toXYZA(toLinearA98RGB(color));
     508}
     509
     510A98RGB<float> toA98RGB(const XYZA<float>& color)
     511{
     512    return toA98RGB(toLinearA98RGB(color));
     513}
     514
     515// - LCHA combination functions.
     516
    439517XYZA<float> toXYZA(const LCHA<float>& color)
    440518{
    … …  
    447525}
    448526
     527// - HSLA combination functions.
     528
    449529XYZA<float> toXYZA(const HSLA<float>& color)
    450530{

  • trunk/Source/WebCore/platform/graphics/ColorConversion.h

    r271723 r271992  
    3030namespace WebCore {
    3131
    32 // These are the standard sRGB <-> LinearRGB / DisplayP3 <-> LinearDisplayP3 conversion functions (https://en.wikipedia.org/wiki/SRGB).
    33 float linearToRGBColorComponentClamping(float);
    34 float rgbToLinearColorComponentClamping(float);
    35 float linearToRGBColorComponentNonClamping(float);
    36 float rgbToLinearColorComponentNonClamping(float);
     32// Transfer functions for colors that can be gamma encoded.
     33
     34struct SRGBTransferFunction {
     35    static float fromLinearClamping(float);
     36    static float toLinearClamping(float);
     37    static float fromLinearNonClamping(float);
     38    static float toLinearNonClamping(float);
     39};
     40
     41struct A98RGBTransferFunction {
     42    static float fromLinearClamping(float);
     43    static float toLinearClamping(float);
     44    static float fromLinearNonClamping(float);
     45    static float toLinearNonClamping(float);
     46};
    3747
    3848// All color types must at least implement the following conversions to and from the XYZA color space:
    … …  
    98108// Additions
    99109WEBCORE_EXPORT SRGBA<float> toSRGBA(const HSLA<float>&);
     110
     111// A98RGB
     112WEBCORE_EXPORT XYZA<float> toXYZA(const A98RGB<float>&);
     113WEBCORE_EXPORT A98RGB<float> toA98RGB(const XYZA<float>&);
     114// Additions
     115WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const A98RGB<float>&);
     116
     117// LinearA98RGB
     118WEBCORE_EXPORT XYZA<float> toXYZA(const LinearA98RGB<float>&);
     119WEBCORE_EXPORT LinearA98RGB<float> toLinearA98RGB(const XYZA<float>&);
     120// Additions
     121WEBCORE_EXPORT A98RGB<float> toA98RGB(const LinearA98RGB<float>& color);
    100122
    101123
    … …  
    112134constexpr HSLA<float> toHSLA(const HSLA<float>& color) { return color; }
    113135constexpr XYZA<float> toXYZA(const XYZA<float>& color) { return color; }
     136constexpr A98RGB<float> toA98RGB(const A98RGB<float>& color) { return color; }
    114137
    115138
    … …  
    164187}
    165188
     189template<typename T> A98RGB<float> toA98RGB(const T& color)
     190{
     191    return toA98RGB(toXYZA(color));
     192}
     193
     194template<typename T> LinearA98RGB<float> toLinearA98RGB(const T& color)
     195{
     196    return toLinearA98RGB(toXYZA(color));
     197}
     198
     199
     200template<typename T, typename Functor> constexpr decltype(auto) callWithColorType(const ColorComponents<T>& components, ColorSpace colorSpace, Functor&& functor)
     201{
     202    switch (colorSpace) {
     203    case ColorSpace::SRGB:
     204        return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
     205    case ColorSpace::LinearRGB:
     206        return std::invoke(std::forward<Functor>(functor), makeFromComponents<LinearSRGBA<T>>(components));
     207    case ColorSpace::DisplayP3:
     208        return std::invoke(std::forward<Functor>(functor), makeFromComponents<DisplayP3<T>>(components));
     209    case ColorSpace::A98RGB:
     210        return std::invoke(std::forward<Functor>(functor), makeFromComponents<A98RGB<T>>(components));
     211    case ColorSpace::Lab:
     212        return std::invoke(std::forward<Functor>(functor), makeFromComponents<Lab<T>>(components));
     213    }
     214
     215    ASSERT_NOT_REACHED();
     216    return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
     217}
     218
    166219} // namespace WebCore

  • trunk/Source/WebCore/platform/graphics/ColorSerialization.cpp

    r271362 r271992  
    9797    case ColorSpace::DisplayP3:
    9898        return "display-p3"_s;
     99    case ColorSpace::A98RGB:
     100        return "a98-rgb"_s;
    99101    case ColorSpace::Lab:
    100102        return "lab"_s;
    … …  
    164166}
    165167
     168// A98RGB<float> overloads
     169
     170String serializationForCSS(const A98RGB<float>& color)
     171{
     172    return serialization(color);
     173}
     174
     175String serializationForHTML(const A98RGB<float>& color)
     176{
     177    return serialization(color);
     178}
     179
     180String serializationForRenderTreeAsText(const A98RGB<float>& color)
     181{
     182    return serialization(color);
     183}
     184
    166185// Lab<float> overloads
    167186

  • trunk/Source/WebCore/platform/graphics/ColorSerialization.h

    r271362 r271992  
    3232class Color;
    3333
     34template<typename> struct A98RGB;
    3435template<typename> struct DisplayP3;
    3536template<typename> struct Lab;
    … …  
    5758WEBCORE_EXPORT String serializationForRenderTreeAsText(const DisplayP3<float>&);
    5859
     60WEBCORE_EXPORT String serializationForCSS(const A98RGB<float>&);
     61WEBCORE_EXPORT String serializationForHTML(const A98RGB<float>&);
     62WEBCORE_EXPORT String serializationForRenderTreeAsText(const A98RGB<float>&);
     63
    5964WEBCORE_EXPORT String serializationForCSS(const Lab<float>&);
    6065WEBCORE_EXPORT String serializationForHTML(const Lab<float>&);

  • trunk/Source/WebCore/platform/graphics/ColorSpace.cpp

    r271362 r271992  
    11/*
    2  * Copyright (C) 2020 Apple Inc. All rights reserved.
     2 * Copyright (C) 2020-2021 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4343        ts << "DisplayP3";
    4444        break;
     45    case ColorSpace::A98RGB:
     46        ts << "a98-rgb";
     47        break;
    4548    case ColorSpace::Lab:
    4649        ts << "L*a*b";

  • trunk/Source/WebCore/platform/graphics/ColorSpace.h

    r271362 r271992  
    11/*
    2  * Copyright (C) 2009 Apple Inc. All rights reserved.
     2 * Copyright (C) 2009-2021 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3636    LinearRGB,
    3737    DisplayP3,
     38    A98RGB,
    3839    Lab
    3940};

  • trunk/Source/WebCore/platform/graphics/ColorTypes.h

    r271723 r271992  
    3232namespace WebCore {
    3333
     34template<typename> struct SRGBA;
     35template<typename> struct ExtendedSRGBA;
     36template<typename> struct LinearSRGBA;
     37template<typename> struct LinearExtendedSRGBA;
     38template<typename> struct DisplayP3;
     39template<typename> struct LinearDisplayP3;
     40template<typename> struct A98RGB;
     41template<typename> struct LinearA98RGB;
     42template<typename> struct Lab;
     43template<typename> struct LCHA;
     44template<typename> struct HSLA;
     45template<typename> struct XYZ;
     46
    3447template<typename> struct AlphaTraits;
    3548
    … …  
    118131    static constexpr bool isInvertible = false;
    119132};
     133
    120134
    121135template<typename ColorType, typename T> constexpr ColorType makeFromComponents(const ColorComponents<T>& c)
    … …  
    270284};
    271285
    272 template<typename T> struct SRGBA : ColorWithAlphaHelper<SRGBA<T>> {
     286
     287template<typename ColorType, typename std::enable_if_t<IsConvertibleToColorComponents<ColorType>>* = nullptr>
     288constexpr bool operator==(const ColorType& a, const ColorType& b)
     289{
     290    return asColorComponents(a) == asColorComponents(b);
     291}
     292
     293template<typename ColorType, typename std::enable_if_t<IsConvertibleToColorComponents<ColorType>>* = nullptr>
     294constexpr bool operator!=(const ColorType& a, const ColorType& b)
     295{
     296    return !(a == b);
     297}
     298
     299
     300// MARK: - RGB Color Types.
     301
     302template<template<typename> class C, typename T, typename M> struct RGBAType : ColorWithAlphaHelper<C<T>> {
    273303    using ComponentType = T;
    274     using Model = RGBModel<T>;
    275     static constexpr auto colorSpace { ColorSpace::SRGB };
     304    using Model = M;
    276305   
    277     constexpr SRGBA(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
     306    constexpr RGBAType(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    278307        : red { red }
    279308        , green { green }
    … …  
    284313    }
    285314
    286     constexpr SRGBA()
    287         : SRGBA { 0, 0, 0, 0 }
     315    constexpr RGBAType()
     316        : RGBAType { 0, 0, 0, 0 }
    288317    {
    289318    }
    … …  
    295324};
    296325
    297 template<typename T> constexpr ColorComponents<T> asColorComponents(const SRGBA<T>& c)
     326template<template<typename> class ColorType, typename T, typename M> constexpr ColorComponents<T> asColorComponents(const RGBAType<ColorType, T, M>& c)
    298327{
    299328    return { c.red, c.green, c.blue, c.alpha };
    300329}
    301330
    302 template<typename T> constexpr bool operator==(const SRGBA<T>& a, const SRGBA<T>& b)
    303 {
    304     return asColorComponents(a) == asColorComponents(b);
    305 }
    306 
    307 template<typename T> constexpr bool operator!=(const SRGBA<T>& a, const SRGBA<T>& b)
    308 {
    309     return !(a == b);
    310 }
    311 
    312 
    313 template<typename T> struct ExtendedSRGBA : ColorWithAlphaHelper<ExtendedSRGBA<T>> {
    314     using ComponentType = T;
    315     using Model = ExtendedRGBModel<T>;
    316 
    317     constexpr ExtendedSRGBA(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    318         : red { red }
    319         , green { green }
    320         , blue { blue }
    321         , alpha { alpha }
    322     {
    323     }
    324 
    325     constexpr ExtendedSRGBA()
    326         : ExtendedSRGBA { 0, 0, 0, 0 }
    327     {
    328     }
    329 
    330     T red;
    331     T green;
    332     T blue;
    333     T alpha;
    334 };
    335 
    336 template<typename T> constexpr ColorComponents<T> asColorComponents(const ExtendedSRGBA<T>& c)
    337 {
    338     return { c.red, c.green, c.blue, c.alpha };
    339 }
    340 
    341 template<typename T> constexpr bool operator==(const ExtendedSRGBA<T>& a, const ExtendedSRGBA<T>& b)
    342 {
    343     return asColorComponents(a) == asColorComponents(b);
    344 }
    345 
    346 template<typename T> constexpr bool operator!=(const ExtendedSRGBA<T>& a, const ExtendedSRGBA<T>& b)
    347 {
    348     return !(a == b);
    349 }
    350 
    351 
    352 template<typename T> struct LinearSRGBA : ColorWithAlphaHelper<LinearSRGBA<T>> {
    353     using ComponentType = T;
    354     using Model = RGBModel<T>;
     331template<typename T> struct SRGBA : RGBAType<SRGBA, T, RGBModel<T>> {
     332    using RGBAType<SRGBA, T, RGBModel<T>>::RGBAType;
     333    using LinearCounterpart = LinearSRGBA<T>;
     334    static constexpr auto colorSpace { ColorSpace::SRGB };
     335};
     336template<typename T> SRGBA(T, T, T, T) -> SRGBA<T>;
     337
     338template<typename T> struct LinearSRGBA : RGBAType<LinearSRGBA, T, RGBModel<T>> {
     339    using RGBAType<LinearSRGBA, T, RGBModel<T>>::RGBAType;
     340    using GammaEncodedCounterpart = SRGBA<T>;
    355341    static constexpr auto colorSpace = ColorSpace::LinearRGB;
    356 
    357     constexpr LinearSRGBA(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    358         : red { red }
    359         , green { green }
    360         , blue { blue }
    361         , alpha { alpha }
    362     {
    363         assertInRange(*this);
    364     }
    365 
    366     constexpr LinearSRGBA()
    367         : LinearSRGBA { 0, 0, 0, 0 }
    368     {
    369     }
    370 
    371     T red;
    372     T green;
    373     T blue;
    374     T alpha;
    375 };
    376 
    377 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearSRGBA<T>& c)
    378 {
    379     return { c.red, c.green, c.blue, c.alpha };
    380 }
    381 
    382 template<typename T> constexpr bool operator==(const LinearSRGBA<T>& a, const LinearSRGBA<T>& b)
    383 {
    384     return asColorComponents(a) == asColorComponents(b);
    385 }
    386 
    387 template<typename T> constexpr bool operator!=(const LinearSRGBA<T>& a, const LinearSRGBA<T>& b)
    388 {
    389     return !(a == b);
    390 }
    391 
    392 
    393 template<typename T> struct LinearExtendedSRGBA : ColorWithAlphaHelper<LinearExtendedSRGBA<T>> {
    394     using ComponentType = T;
    395     using Model = ExtendedRGBModel<T>;
    396 
    397     constexpr LinearExtendedSRGBA(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    398         : red { red }
    399         , green { green }
    400         , blue { blue }
    401         , alpha { alpha }
    402     {
    403     }
    404 
    405     constexpr LinearExtendedSRGBA()
    406         : LinearExtendedSRGBA { 0, 0, 0, 0 }
    407     {
    408     }
    409 
    410     T red;
    411     T green;
    412     T blue;
    413     T alpha;
    414 };
    415 
    416 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearExtendedSRGBA<T>& c)
    417 {
    418     return { c.red, c.green, c.blue, c.alpha };
    419 }
    420 
    421 template<typename T> constexpr bool operator==(const LinearExtendedSRGBA<T>& a, const LinearExtendedSRGBA<T>& b)
    422 {
    423     return asColorComponents(a) == asColorComponents(b);
    424 }
    425 
    426 template<typename T> constexpr bool operator!=(const LinearExtendedSRGBA<T>& a, const LinearExtendedSRGBA<T>& b)
    427 {
    428     return !(a == b);
    429 }
    430 
    431 
    432 template<typename T> struct DisplayP3 : ColorWithAlphaHelper<DisplayP3<T>> {
    433     using ComponentType = T;
    434     using Model = RGBModel<T>;
     342};
     343template<typename T> LinearSRGBA(T, T, T, T) -> LinearSRGBA<T>;
     344
     345
     346template<typename T> struct ExtendedSRGBA : RGBAType<ExtendedSRGBA, T, ExtendedRGBModel<T>> {
     347    using RGBAType<ExtendedSRGBA, T, ExtendedRGBModel<T>>::RGBAType;
     348    using LinearCounterpart = LinearExtendedSRGBA<T>;
     349};
     350template<typename T> ExtendedSRGBA(T, T, T, T) -> ExtendedSRGBA<T>;
     351
     352template<typename T> struct LinearExtendedSRGBA : RGBAType<LinearExtendedSRGBA, T, ExtendedRGBModel<T>> {
     353    using RGBAType<LinearExtendedSRGBA, T, ExtendedRGBModel<T>>::RGBAType;
     354    using GammaEncodedCounterpart = ExtendedSRGBA<T>;
     355};
     356template<typename T> LinearExtendedSRGBA(T, T, T, T) -> LinearExtendedSRGBA<T>;
     357
     358
     359template<typename T> struct DisplayP3 : RGBAType<DisplayP3, T, RGBModel<T>> {
     360    using RGBAType<DisplayP3, T, RGBModel<T>>::RGBAType;
     361    using LinearCounterpart = LinearDisplayP3<T>;
    435362    static constexpr auto colorSpace = ColorSpace::DisplayP3;
    436 
    437     constexpr DisplayP3(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    438         : red { red }
    439         , green { green }
    440         , blue { blue }
    441         , alpha { alpha }
    442     {
    443         assertInRange(*this);
    444     }
    445 
    446     constexpr DisplayP3()
    447         : DisplayP3 { 0, 0, 0, 0 }
    448     {
    449     }
    450 
    451     T red;
    452     T green;
    453     T blue;
    454     T alpha;
    455 };
    456 
    457 template<typename T> constexpr ColorComponents<T> asColorComponents(const DisplayP3<T>& c)
    458 {
    459     return { c.red, c.green, c.blue, c.alpha };
    460 }
    461 
    462 template<typename T> constexpr bool operator==(const DisplayP3<T>& a, const DisplayP3<T>& b)
    463 {
    464     return asColorComponents(a) == asColorComponents(b);
    465 }
    466 
    467 template<typename T> constexpr bool operator!=(const DisplayP3<T>& a, const DisplayP3<T>& b)
    468 {
    469     return !(a == b);
    470 }
    471 
    472 
    473 template<typename T> struct LinearDisplayP3 : ColorWithAlphaHelper<LinearDisplayP3<T>> {
    474     using ComponentType = T;
    475     using Model = RGBModel<T>;
    476 
    477     constexpr LinearDisplayP3(T red, T green, T blue, T alpha = AlphaTraits<T>::opaque)
    478         : red { red }
    479         , green { green }
    480         , blue { blue }
    481         , alpha { alpha }
    482     {
    483         assertInRange(*this);
    484     }
    485 
    486     constexpr LinearDisplayP3()
    487         : LinearDisplayP3 { 0, 0, 0, 0 }
    488     {
    489     }
    490 
    491     T red;
    492     T green;
    493     T blue;
    494     T alpha;
    495 };
    496 
    497 template<typename T> constexpr ColorComponents<T> asColorComponents(const LinearDisplayP3<T>& c)
    498 {
    499     return { c.red, c.green, c.blue, c.alpha };
    500 }
    501 
    502 template<typename T> constexpr bool operator==(const LinearDisplayP3<T>& a, const LinearDisplayP3<T>& b)
    503 {
    504     return asColorComponents(a) == asColorComponents(b);
    505 }
    506 
    507 template<typename T> constexpr bool operator!=(const LinearDisplayP3<T>& a, const LinearDisplayP3<T>& b)
    508 {
    509     return !(a == b);
    510 }
    511 
     363};
     364template<typename T> DisplayP3(T, T, T, T) -> DisplayP3<T>;
     365
     366template<typename T> struct LinearDisplayP3 : RGBAType<LinearDisplayP3, T, RGBModel<T>> {
     367    using RGBAType<LinearDisplayP3, T, RGBModel<T>>::RGBAType;
     368    using GammaEncodedCounterpart = DisplayP3<T>;
     369};
     370template<typename T> LinearDisplayP3(T, T, T, T) -> LinearDisplayP3<T>;
     371
     372
     373template<typename T> struct A98RGB : RGBAType<A98RGB, T, RGBModel<T>> {
     374    using RGBAType<A98RGB, T, RGBModel<T>>::RGBAType;
     375    using LinearCounterpart = LinearA98RGB<T>;
     376    static constexpr auto colorSpace = ColorSpace::A98RGB;
     377};
     378template<typename T> A98RGB(T, T, T, T) -> A98RGB<T>;
     379
     380template<typename T> struct LinearA98RGB : RGBAType<LinearA98RGB, T, RGBModel<T>> {
     381    using RGBAType<LinearA98RGB, T, RGBModel<T>>::RGBAType;
     382    using GammaEncodedCounterpart = A98RGB<T>;
     383};
     384template<typename T> LinearA98RGB(T, T, T, T) -> LinearA98RGB<T>;
     385
     386
     387// MARK: - Lab Color Type.
    512388
    513389template<typename T> struct Lab : ColorWithAlphaHelper<Lab<T>> {
    … …  
    541417}
    542418
    543 template<typename T> constexpr bool operator==(const Lab<T>& a, const Lab<T>& b)
    544 {
    545     return asColorComponents(a) == asColorComponents(b);
    546 }
    547 
    548 template<typename T> constexpr bool operator!=(const Lab<T>& a, const Lab<T>& b)
    549 {
    550     return !(a == b);
    551 }
    552 
     419// MARK: - LCHA Color Type.
    553420
    554421template<typename T> struct LCHA : ColorWithAlphaHelper<LCHA<T>> {
    … …  
    581448}
    582449
    583 template<typename T> constexpr bool operator==(const LCHA<T>& a, const LCHA<T>& b)
    584 {
    585     return asColorComponents(a) == asColorComponents(b);
    586 }
    587 
    588 template<typename T> constexpr bool operator!=(const LCHA<T>& a, const LCHA<T>& b)
    589 {
    590     return !(a == b);
    591 }
    592 
     450
     451// MARK: - HSLA Color Type.
    593452
    594453template<typename T> struct HSLA : ColorWithAlphaHelper<HSLA<T>> {
    … …  
    616475};
    617476
    618 template<typename T> HSLA(T, T, T, T) -> HSLA<T>;
    619 
    620477template<typename T> constexpr ColorComponents<T> asColorComponents(const HSLA<T>& c)
    621478{
    … …  
    623480}
    624481
    625 template<typename T> constexpr bool operator==(const HSLA<T>& a, const HSLA<T>& b)
    626 {
    627     return asColorComponents(a) == asColorComponents(b);
    628 }
    629 
    630 template<typename T> constexpr bool operator!=(const HSLA<T>& a, const HSLA<T>& b)
    631 {
    632     return !(a == b);
    633 }
    634 
     482// MARK: - XYZ Color Type.
    635483
    636484template<typename T> struct XYZA : ColorWithAlphaHelper<XYZA<T>> {
    … …  
    663511}
    664512
    665 template<typename T> constexpr bool operator==(const XYZA<T>& a, const XYZA<T>& b)
    666 {
    667     return asColorComponents(a) == asColorComponents(b);
    668 }
    669 
    670 template<typename T> constexpr bool operator!=(const XYZA<T>& a, const XYZA<T>& b)
    671 {
    672     return !(a == b);
    673 }
    674 
    675 
    676 template<typename T, typename Functor> constexpr decltype(auto) callWithColorType(const ColorComponents<T>& components, ColorSpace colorSpace, Functor&& functor)
    677 {
    678     switch (colorSpace) {
    679     case ColorSpace::SRGB:
    680         return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
    681     case ColorSpace::LinearRGB:
    682         return std::invoke(std::forward<Functor>(functor), makeFromComponents<LinearSRGBA<T>>(components));
    683     case ColorSpace::DisplayP3:
    684         return std::invoke(std::forward<Functor>(functor), makeFromComponents<DisplayP3<T>>(components));
    685     case ColorSpace::Lab:
    686         return std::invoke(std::forward<Functor>(functor), makeFromComponents<Lab<T>>(components));
    687     }
    688 
    689     ASSERT_NOT_REACHED();
    690     return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));
    691 }
    692513
    693514// Packed Color Formats

  • trunk/Source/WebCore/platform/graphics/cairo/ImageBufferCairoBackend.cpp

    r271695 r271992  
    105105            for (unsigned i = 0; i < 256; i++) {
    106106                float color = i / 255.0f;
    107                 color = rgbToLinearColorComponentClamping(color);
     107                color = SRGBTransferFunction::toLinearClamping(color);
    108108                array[i] = static_cast<uint8_t>(round(color * 255));
    109109            }
    … …  
    116116            for (unsigned i = 0; i < 256; i++) {
    117117                float color = i / 255.0f;
    118                 color = linearToRGBColorComponentClamping(color);
     118                color = SRGBTransferFunction::fromLinearClamping(color);
    119119                array[i] = static_cast<uint8_t>(round(color * 255));
    120120            }

  • trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.cpp

    r271362 r271992  
    8383}
    8484
     85CGColorSpaceRef a98RGBColorSpaceRef()
     86{
     87    static CGColorSpaceRef a98RGBColorSpace;
     88    static std::once_flag onceFlag;
     89    std::call_once(onceFlag, [] {
     90#if PLATFORM(COCOA)
     91        a98RGBColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceAdobeRGB1998);
     92#else
     93        a98RGBColorSpace = sRGBColorSpaceRef();
     94#endif
     95    });
     96    return a98RGBColorSpace;
     97}
     98
    8599CGColorSpaceRef labColorSpaceRef()
    86100{

  • trunk/Source/WebCore/platform/graphics/cg/ColorSpaceCG.h

    r271362 r271992  
    3636WEBCORE_EXPORT CGColorSpaceRef displayP3ColorSpaceRef();
    3737WEBCORE_EXPORT CGColorSpaceRef labColorSpaceRef();
     38WEBCORE_EXPORT CGColorSpaceRef a98RGBColorSpaceRef();
    3839WEBCORE_EXPORT CGColorSpaceRef extendedSRGBColorSpaceRef();
    3940
    … …  
    4748    case ColorSpace::DisplayP3:
    4849        return displayP3ColorSpaceRef();
     50    case ColorSpace::A98RGB:
     51        return a98RGBColorSpaceRef();
    4952    case ColorSpace::Lab:
    5053        return labColorSpaceRef();
Note: See TracChangeset for help on using the changeset viewer.