Changeset 272123 in webkit


Ignore:
Timestamp:
Jan 30, 2021 11:52:56 PM (18 months ago)
Author:
weinig@apple.com
Message:

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

Reviewed by Antti Koivisto.

LayoutTests/imported/w3c:

Add some new WPT tests for color(rec2020 ) that will be upstreamed shortly.

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

Source/WebCore:

  • css/CSSValueKeywords.in:

Add comment to indicate rec2020 is support color function type.

  • css/parser/CSSPropertyParserHelpers.cpp:

(WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
(WebCore::CSSPropertyParserHelpers::parseColorFunctionParameters):
Parse color(rec2020 ) using the existing generic rgb type color function
parsing function.

  • platform/graphics/Color.h:

Remove overly specific comment that listed all the color types that Color
could hold, replacing it with a more generic statement about the functionaly
of ExtendedColor. This avoids needing to update this not very useful comment
everytime we add a new supported color type.

  • platform/graphics/ColorConversion.cpp:

(WebCore::toLinearRec2020):
(WebCore::toRec2020):
(WebCore::toXYZA):

  • platform/graphics/ColorConversion.h:

(WebCore::toLinearRec2020):
(WebCore::toRec2020):
(WebCore::toLinearDisplayP3):
(WebCore::callWithColorType):
Add conversion support for Rec2020, utilizing the Rec2020TransferFunction
for gamma correction. Fix incorrect sorting of toLinearDisplayP3.

  • platform/graphics/ColorSerialization.cpp:

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

  • platform/graphics/ColorSerialization.h:

Add serialization support, matching other rgb color() function
types.

  • platform/graphics/ColorSpace.cpp:

(WebCore::operator<<):

  • platform/graphics/ColorSpace.h:

Add Rec2020 as a new ColorSpace.

  • platform/graphics/ColorTransferFunctions.h:

(WebCore::Rec2020TransferFunction::toGammaEncoded):
(WebCore::Rec2020TransferFunction::toLinear):
Add transfer function for Rec2020. Both clamped and unclamped
are implemented, though for now, only the clamped variant is
being used.

  • platform/graphics/ColorTypes.h:

Add Rec2020 and LinearRec2020 types.

  • platform/graphics/cg/ColorSpaceCG.cpp:

(WebCore::rec2020ColorSpaceRef):

  • platform/graphics/cg/ColorSpaceCG.h:

(WebCore::cachedCGColorSpace):
Add support for the rec2020 as a CoreGraphics color space, where
it is known as kCGColorSpaceITUR_2020.

LayoutTests:

Remove now passing rec2020 tests.

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

Re-write parsing-a98rgb-colors.html to test all rgb types in the color() function as
they all have the same parsing requirements. Color(lab ) must still be parsed separately
as it has a different grammar.

Location:
trunk
Files:
10 added
2 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r272117 r272123  
     12021-01-30  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(rec2020 ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221114
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * TestExpectations:
     9        Remove now passing rec2020 tests.
     10
     11        * fast/css/parsing-a98rgb-colors-expected.txt: Removed.
     12        * fast/css/parsing-a98rgb-colors.html: Removed.
     13        * fast/css/parsing-color-function-expected.txt: Added.
     14        * fast/css/parsing-color-function.html: Added.
     15        Re-write parsing-a98rgb-colors.html to test all rgb types in the color() function as
     16        they all have the same parsing requirements. Color(lab ) must still be parsed separately
     17        as it has a different grammar.
     18
    1192021-01-30  Wenson Hsieh  <wenson_hsieh@apple.com>
    220

  • trunk/LayoutTests/TestExpectations

    r272049 r272123  
    46074607webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-009.html [ ImageOnlyFailure ] # Requires prophoto-rgb support
    46084608webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-010.html [ ImageOnlyFailure ] # Requires prophoto-rgb support
    4609 webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-011.html [ ImageOnlyFailure ] # Requires rec2020 support
    4610 webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-012.html [ ImageOnlyFailure ] # Requires rec2020 support
    46114609webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-014.html [ ImageOnlyFailure ] # Requires fallback (at parse time) support
    46124610webkit.org/b/220928 imported/w3c/web-platform-tests/css/css-color/predefined-015.html [ ImageOnlyFailure ] # Requires fallback (at parse time) support (unclear if this makes sense)

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r272117 r272123  
     12021-01-30  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(rec2020 ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221114
     5
     6        Reviewed by Antti Koivisto.
     7
     8        Add some new WPT tests for color(rec2020 ) that will be upstreamed shortly.
     9
     10        * web-platform-tests/css/css-color/rec2020-001-expected.html: Added.
     11        * web-platform-tests/css/css-color/rec2020-001.html: Added.
     12        * web-platform-tests/css/css-color/rec2020-002-expected.html: Added.
     13        * web-platform-tests/css/css-color/rec2020-002.html: Added.
     14        * web-platform-tests/css/css-color/rec2020-003-expected.html: Added.
     15        * web-platform-tests/css/css-color/rec2020-003.html: Added.
     16        * web-platform-tests/css/css-color/rec2020-004-expected.html: Added.
     17        * web-platform-tests/css/css-color/rec2020-004.html: Added.
     18
    1192021-01-30  Wenson Hsieh  <wenson_hsieh@apple.com>
    220

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/predefined-011.html

    r271798 r272123  
    99    .test { background-color: red; width: 12em; height: 6em; margin-top:0}
    1010    .ref { background-color: #009900; width: 12em; height: 6em; margin-bottom: 0}
    11     .test {background-color: color(rec2020 0.33033 0.55976 0.14863)}
     11    .test {background-color: color(rec2020 0.299218 0.533327 0.120785)}
    1212</style>
    1313<body>

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-color/predefined-012.html

    r271798 r272123  
    99    .test { background-color: red; width: 12em; height: 6em; margin-top:0}
    1010    .ref { background-color: #009900; width: 12em; height: 6em; margin-bottom: 0}
    11     .test {background-color: color(rec2020 33.033% 55.976% 14.863%)}
     11    .test {background-color: color(rec2020 29.9218% 53.3327% 12.0785%)}
    1212</style>
    1313<body>

  • trunk/Source/WebCore/ChangeLog

    r272122 r272123  
     12021-01-30  Sam Weinig  <weinig@apple.com>
     2
     3        Add support for color(rec2020 ...) as part of CSS Color 4
     4        https://bugs.webkit.org/show_bug.cgi?id=221114
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * css/CSSValueKeywords.in:
     9        Add comment to indicate rec2020 is support color function type.
     10
     11        * css/parser/CSSPropertyParserHelpers.cpp:
     12        (WebCore::CSSPropertyParserHelpers::parseColorFunctionForRGBTypes):
     13        (WebCore::CSSPropertyParserHelpers::parseColorFunctionParameters):
     14        Parse color(rec2020 ) using the existing generic rgb type color function
     15        parsing function.
     16
     17        * platform/graphics/Color.h:
     18        Remove overly specific comment that listed all the color types that Color
     19        could hold, replacing it with a more generic statement about the functionaly
     20        of ExtendedColor. This avoids needing to update this not very useful comment
     21        everytime we add a new supported color type.
     22
     23        * platform/graphics/ColorConversion.cpp:
     24        (WebCore::toLinearRec2020):
     25        (WebCore::toRec2020):
     26        (WebCore::toXYZA):
     27        * platform/graphics/ColorConversion.h:
     28        (WebCore::toLinearRec2020):
     29        (WebCore::toRec2020):
     30        (WebCore::toLinearDisplayP3):
     31        (WebCore::callWithColorType):
     32        Add conversion support for Rec2020, utilizing the Rec2020TransferFunction
     33        for gamma correction. Fix incorrect sorting of toLinearDisplayP3.
     34
     35        * platform/graphics/ColorSerialization.cpp:
     36        (WebCore::serialization):
     37        (WebCore::serializationForCSS):
     38        (WebCore::serializationForHTML):
     39        (WebCore::serializationForRenderTreeAsText):
     40        * platform/graphics/ColorSerialization.h:
     41        Add serialization support, matching other rgb color() function
     42        types.
     43
     44        * platform/graphics/ColorSpace.cpp:
     45        (WebCore::operator<<):
     46        * platform/graphics/ColorSpace.h:
     47        Add Rec2020 as a new ColorSpace.
     48
     49        * platform/graphics/ColorTransferFunctions.h:
     50        (WebCore::Rec2020TransferFunction::toGammaEncoded):
     51        (WebCore::Rec2020TransferFunction::toLinear):
     52        Add transfer function for Rec2020. Both clamped and unclamped
     53        are implemented, though for now, only the clamped variant is
     54        being used.
     55
     56        * platform/graphics/ColorTypes.h:
     57        Add Rec2020 and LinearRec2020 types.
     58
     59        * platform/graphics/cg/ColorSpaceCG.cpp:
     60        (WebCore::rec2020ColorSpaceRef):
     61        * platform/graphics/cg/ColorSpaceCG.h:
     62        (WebCore::cachedCGColorSpace):
     63        Add support for the rec2020 as a CoreGraphics color space, where
     64        it is known as kCGColorSpaceITUR_2020.
     65
    1662021-01-29  Darin Adler  <darin@apple.com>
    267

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

    r272117 r272123  
    14071407display-p3
    14081408// lab
     1409// rec2020
    14091410// sRGB
    14101411

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

    r272121 r272123  
    895895static Color parseColorFunctionForRGBTypes(CSSParserTokenRange& args)
    896896{
    897     ASSERT(args.peek().id() == CSSValueA98Rgb || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueSRGB);
     897    ASSERT(args.peek().id() == CSSValueA98Rgb || args.peek().id() == CSSValueDisplayP3 || args.peek().id() == CSSValueRec2020 || args.peek().id() == CSSValueSRGB);
    898898    consumeIdentRaw(args);
    899899
    … …  
    958958    case CSSValueLab:
    959959        color = parseColorFunctionForLabParameters(args);
     960        break;
     961    case CSSValueRec2020:
     962        color = parseColorFunctionForRGBTypes<Rec2020<float>>(args);
    960963        break;
    961964    case CSSValueSRGB:

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

    r271695 r272123  
    5656//    - Special "invalid color" state, treated as transparent black but distinguishable
    5757//    - 4x 8-bit (0-255) sRGBA, stored inline, no allocation
    58 //    - 4x float (0-1) sRGBA, stored in a reference counted sub-object
    59 //    - 4x float (0-1) Linear sRGBA, stored in a reference counted sub-object
    60 //    - 4x float (0-1) DisplayP3, stored in a reference counted sub-object
    61 //    - 4x float (0-1) Lab, stored in a reference counted sub-object
     58//    - 4x float color components + color space, stored in a reference counted sub-object
    6259//
    6360// Additionally, the inline 8-bit sRGBA can have an optional "semantic" bit set on it,

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

    r272066 r272123  
    6666};
    6767
     68// Rec2020 Matrices.
     69
     70// https://drafts.csswg.org/css-color/#color-conversion-code
     71static constexpr ColorMatrix<3, 3> xyzToLinearRec2020Matrix {
     72     1.7166511879712674f,   -0.35567078377639233f, -0.25336628137365974f,
     73    -0.6666843518324892f,    1.6164812366349395f,   0.01576854581391113f,
     74     0.017639857445310783f, -0.042770613257808524f, 0.9421031212354738f
     75};
     76
     77// https://drafts.csswg.org/css-color/#color-conversion-code
     78static constexpr ColorMatrix<3, 3> linearRec2020ToXYZMatrix {
     79    0.6369580483012914f, 0.14461690358620832f,  0.1688809751641721f,
     80    0.2627002120112671f, 0.6779980715188708f,   0.05930171646986196f,
     81    0.000000000000000f,  0.028072693049087428f, 1.060985057710791f
     82};
     83
    6884// sRGB Matrices.
    6985
    … …  
    150166}
    151167
     168// Rec2020 <-> LinearRec2020 conversions.
     169
     170LinearRec2020<float> toLinearRec2020(const Rec2020<float>& color)
     171{
     172    return toLinear<Rec2020TransferFunction<float, TransferFunctionMode::Clamped>>(color);
     173}
     174
     175Rec2020<float> toRec2020(const LinearRec2020<float>& color)
     176{
     177    return toGammaEncoded<Rec2020TransferFunction<float, TransferFunctionMode::Clamped>>(color);
     178}
     179
    152180// SRGBA <-> LinearSRGBA conversions.
    153181
    … …  
    198226{
    199227    return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearSRGBToXYZMatrix.transformedColorComponents(asColorComponents(color)));
     228}
     229
     230// - LinearRec2020 matrix conversions.
     231
     232LinearRec2020<float> toLinearRec2020(const XYZA<float>& color)
     233{
     234    return makeFromComponentsClampingExceptAlpha<LinearRec2020<float>>(xyzToLinearRec2020Matrix.transformedColorComponents(asColorComponents(color)));
     235}
     236
     237XYZA<float> toXYZA(const LinearRec2020<float>& color)
     238{
     239    return makeFromComponentsClampingExceptAlpha<XYZA<float>>(linearRec2020ToXYZMatrix.transformedColorComponents(asColorComponents(color)));
    200240}
    201241
    … …  
    469509}
    470510
     511// - Rec2020 combination functions.
     512
     513XYZA<float> toXYZA(const Rec2020<float>& color)
     514{
     515    return toXYZA(toLinearRec2020(color));
     516}
     517
     518Rec2020<float> toRec2020(const XYZA<float>& color)
     519{
     520    return toRec2020(toLinearRec2020(color));
     521}
     522
    471523// - SRGB combination functions.
    472524

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

    r272066 r272123  
    9292WEBCORE_EXPORT ExtendedSRGBA<float> toExtendedSRGBA(const LinearExtendedSRGBA<float>&);
    9393
     94// LinearRec2020
     95WEBCORE_EXPORT XYZA<float> toXYZA(const LinearRec2020<float>&);
     96WEBCORE_EXPORT LinearRec2020<float> toLinearRec2020(const XYZA<float>&);
     97// Additions
     98WEBCORE_EXPORT Rec2020<float> toRec2020(const LinearRec2020<float>&);
     99
    94100// LinearSRGBA
    95101WEBCORE_EXPORT XYZA<float> toXYZA(const LinearSRGBA<float>&);
    … …  
    97103// Additions
    98104WEBCORE_EXPORT SRGBA<float> toSRGBA(const LinearSRGBA<float>&);
     105
     106// Rec2020
     107WEBCORE_EXPORT XYZA<float> toXYZA(const Rec2020<float>&);
     108WEBCORE_EXPORT Rec2020<float> toRec2020(const XYZA<float>&);
     109// Additions
     110WEBCORE_EXPORT LinearRec2020<float> toLinearRec2020(const Rec2020<float>&);
    99111
    100112// SRGBA
    … …  
    117129constexpr LinearDisplayP3<float> toLinearDisplayP3(const LinearDisplayP3<float>& color) { return color; }
    118130constexpr LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const LinearExtendedSRGBA<float>& color) { return color; }
     131constexpr LinearRec2020<float> toLinearRec2020(const LinearRec2020<float>& color) { return color; }
    119132constexpr LinearSRGBA<float> toLinearSRGBA(const LinearSRGBA<float>& color) { return color; }
     133constexpr Rec2020<float> toRec2020(const Rec2020<float>& color) { return color; }
    120134constexpr SRGBA<float> toSRGBA(const SRGBA<float>& color) { return color; }
    121135constexpr XYZA<float> toXYZA(const XYZA<float>& color) { return color; }
    … …  
    162176}
    163177
     178template<typename T> LinearDisplayP3<float> toLinearDisplayP3(const T& color)
     179{
     180    return toLinearDisplayP3(toXYZA(color));
     181}
     182
    164183template<typename T> LinearExtendedSRGBA<float> toLinearExtendedSRGBA(const T& color)
    165184{
    … …  
    167186}
    168187
    169 template<typename T> LinearDisplayP3<float> toLinearDisplayP3(const T& color)
    170 {
    171     return toLinearDisplayP3(toXYZA(color));
     188template<typename T> LinearRec2020<float> toLinearRec2020(const T& color)
     189{
     190    return toLinearRec2020(toXYZA(color));
    172191}
    173192
    … …  
    175194{
    176195    return toLinearSRGBA(toXYZA(color));
     196}
     197
     198template<typename T> Rec2020<float> toRec2020(const T& color)
     199{
     200    return toRec2020(toXYZA(color));
    177201}
    178202
    … …  
    194218    case ColorSpace::LinearRGB:
    195219        return std::invoke(std::forward<Functor>(functor), makeFromComponents<LinearSRGBA<T>>(components));
     220    case ColorSpace::Rec2020:
     221        return std::invoke(std::forward<Functor>(functor), makeFromComponents<Rec2020<T>>(components));
    196222    case ColorSpace::SRGB:
    197223        return std::invoke(std::forward<Functor>(functor), makeFromComponents<SRGBA<T>>(components));

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

    r272033 r272123  
    6969    case ColorSpace::LinearRGB:
    7070        return "linear-srgb"_s;
     71    case ColorSpace::Rec2020:
     72        return "rec2020"_s;
    7173    case ColorSpace::SRGB:
    7274        return "srgb"_s;
    … …  
    154156
    155157String serializationForRenderTreeAsText(const LinearSRGBA<float>& color)
     158{
     159    return serialization(color);
     160}
     161
     162// MARK: Rec2020<float> overloads
     163
     164String serializationForCSS(const Rec2020<float>& color)
     165{
     166    return serialization(color);
     167}
     168
     169String serializationForHTML(const Rec2020<float>& color)
     170{
     171    return serialization(color);
     172}
     173
     174String serializationForRenderTreeAsText(const Rec2020<float>& color)
    156175{
    157176    return serialization(color);

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

    r272033 r272123  
    3636template<typename> struct Lab;
    3737template<typename> struct LinearSRGBA;
     38template<typename> struct Rec2020;
    3839template<typename> struct SRGBA;
    3940
    … …  
    6465WEBCORE_EXPORT String serializationForRenderTreeAsText(const LinearSRGBA<float>&);
    6566
     67WEBCORE_EXPORT String serializationForCSS(const Rec2020<float>&);
     68WEBCORE_EXPORT String serializationForHTML(const Rec2020<float>&);
     69WEBCORE_EXPORT String serializationForRenderTreeAsText(const Rec2020<float>&);
     70
    6671WEBCORE_EXPORT String serializationForCSS(const SRGBA<float>&);
    6772WEBCORE_EXPORT String serializationForHTML(const SRGBA<float>&);

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

    r272033 r272123  
    4646        ts << "LinearRGB";
    4747        break;
     48    case ColorSpace::Rec2020:
     49        ts << "Rec2020";
     50        break;
    4851    case ColorSpace::SRGB:
    4952        ts << "sRGB";

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

    r272033 r272123  
    3737    Lab,
    3838    LinearRGB,
     39    Rec2020,
    3940    SRGB,
    4041};

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

    r272066 r272123  
    4444
    4545template<typename T, TransferFunctionMode mode>
     46struct Rec2020TransferFunction {
     47    static constexpr T alpha = 1.09929682680944;
     48    static constexpr T beta = 0.018053968510807;
     49    static constexpr T gamma = 0.45;
     50
     51    static T toGammaEncoded(T);
     52    static T toLinear(T);
     53};
     54
     55template<typename T, TransferFunctionMode mode>
    4656struct SRGBTransferFunction {
    4757    static T toGammaEncoded(T);
    4858    static T toLinear(T);
    4959};
     60
     61// MARK: A98RGBTransferFunction.
    5062
    5163template<typename T, TransferFunctionMode mode> T A98RGBTransferFunction<T, mode>::toGammaEncoded(T c)
    … …  
    6678    return result;
    6779}
     80
     81// MARK: Rec2020TransferFunction.
     82
     83template<typename T, TransferFunctionMode mode> T Rec2020TransferFunction<T, mode>::toGammaEncoded(T c)
     84{
     85    if constexpr (mode == TransferFunctionMode::Clamped) {
     86        if (c <= beta)
     87            return 4.5f * c;
     88
     89        return clampTo<T>(alpha * std::pow(c, gamma) - (alpha - 1.0f), 0, 1);
     90    } else {
     91        if (std::abs(c) <= beta)
     92            return 4.5f * c;
     93
     94        float sign = std::signbit(c) ? -1.0 : 1.0;
     95        return sign * alpha * std::pow(c, gamma) - (alpha - 1.0);
     96    }
     97}
     98
     99template<typename T, TransferFunctionMode mode> T Rec2020TransferFunction<T, mode>::toLinear(T c)
     100{
     101    if constexpr (mode == TransferFunctionMode::Clamped) {
     102        if (c < beta * 4.5f)
     103            return c / 4.5f;
     104        return clampTo<T>(std::pow((c + alpha - 1.0) / alpha, 1.0 / gamma), 0, 1);
     105    } else {
     106        if (std::abs(c) < beta * 4.5f)
     107            return c / 4.5f;
     108
     109        float sign = std::signbit(c) ? -1.0 : 1.0;
     110        return std::pow((c + alpha - 1.0) / alpha, 1.0 / gamma) * sign;
     111    }
     112}
     113
     114// MARK: SRGBTransferFunction.
    68115
    69116template<typename T, TransferFunctionMode mode> T SRGBTransferFunction<T, mode>::toGammaEncoded(T c)

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

    r272066 r272123  
    4141template<typename> struct LinearDisplayP3;
    4242template<typename> struct LinearExtendedSRGBA;
     43template<typename> struct LinearRec2020;
    4344template<typename> struct LinearSRGBA;
     45template<typename> struct Rec2020;
    4446template<typename> struct SRGBA;
    4547template<typename> struct XYZ;
    … …  
    257259template<typename T> LinearExtendedSRGBA(T, T, T, T) -> LinearExtendedSRGBA<T>;
    258260
     261template<typename T> struct LinearRec2020 : RGBAType<LinearRec2020, T, RGBModel<T>> {
     262    using RGBAType<LinearRec2020, T, RGBModel<T>>::RGBAType;
     263    using GammaEncodedCounterpart = Rec2020<T>;
     264};
     265template<typename T> LinearRec2020(T, T, T, T) -> LinearRec2020<T>;
     266
    259267template<typename T> struct LinearSRGBA : RGBAType<LinearSRGBA, T, RGBModel<T>> {
    260268    using RGBAType<LinearSRGBA, T, RGBModel<T>>::RGBAType;
    … …  
    263271};
    264272template<typename T> LinearSRGBA(T, T, T, T) -> LinearSRGBA<T>;
     273
     274template<typename T> struct Rec2020 : RGBAType<Rec2020, T, RGBModel<T>> {
     275    using RGBAType<Rec2020, T, RGBModel<T>>::RGBAType;
     276    using LinearCounterpart = LinearRec2020<T>;
     277    static constexpr auto colorSpace { ColorSpace::Rec2020 };
     278};
     279template<typename T> Rec2020(T, T, T, T) -> Rec2020<T>;
    265280
    266281template<typename T> struct SRGBA : RGBAType<SRGBA, T, RGBModel<T>> {

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

    r272033 r272123  
    101101}
    102102
     103CGColorSpaceRef rec2020ColorSpaceRef()
     104{
     105    static CGColorSpaceRef rec2020ColorSpace;
     106    static std::once_flag onceFlag;
     107    std::call_once(onceFlag, [] {
     108#if PLATFORM(COCOA)
     109        rec2020ColorSpace = CGColorSpaceCreateWithName(kCGColorSpaceITUR_2020);
     110#else
     111        rec2020ColorSpace = sRGBColorSpaceRef();
     112#endif
     113    });
     114    return rec2020ColorSpace;
     115}
     116
    103117CGColorSpaceRef sRGBColorSpaceRef()
    104118{

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

    r272033 r272123  
    5151    case ColorSpace::LinearRGB:
    5252        return linearRGBColorSpaceRef();
     53    case ColorSpace::Rec2020:
     54        return rec2020ColorSpaceRef();
    5355    case ColorSpace::SRGB:
    5456        return sRGBColorSpaceRef();
Note: See TracChangeset for help on using the changeset viewer.