/src/skia/include/core/SkColorSpace.h

Source
/*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkColorSpace_DEFINED
#define SkColorSpace_DEFINED

#include "include/core/SkRefCnt.h"
#include "include/private/SkFixed.h"
#include "include/private/SkOnce.h"
#include "include/third_party/skcms/skcms.h"
#include <memory>

class SkData;

/**
 *  Describes a color gamut with primaries and a white point.
 */
struct SK_API SkColorSpacePrimaries {
    float fRX;
    float fRY;
    float fGX;
    float fGY;
    float fBX;
    float fBY;
    float fWX;
    float fWY;

    /**
     *  Convert primaries and a white point to a toXYZD50 matrix, the preferred color gamut
     *  representation of SkColorSpace.
     */
    bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;
};

namespace SkNamedTransferFn {

// Like SkNamedGamut::kSRGB, keeping this bitwise exactly the same as skcms makes things fastest.
static constexpr skcms_TransferFunction kSRGB =
    { 2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0.0f, 0.0f };

static constexpr skcms_TransferFunction k2Dot2 =
    { 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };

static constexpr skcms_TransferFunction kLinear =
    { 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };

static constexpr skcms_TransferFunction kRec2020 =
    {2.22222f, 0.909672f, 0.0903276f, 0.222222f, 0.0812429f, 0, 0};

static constexpr skcms_TransferFunction kPQ =
    {-2.0f, -107/128.0f, 1.0f, 32/2523.0f, 2413/128.0f, -2392/128.0f, 8192/1305.0f };

static constexpr skcms_TransferFunction kHLG =
    {-3.0f, 2.0f, 2.0f, 1/0.17883277f, 0.28466892f, 0.55991073f, 0.0f };

}  // namespace SkNamedTransferFn

namespace SkNamedGamut {

static constexpr skcms_Matrix3x3 kSRGB = {{
    // ICC fixed-point (16.16) representation, taken from skcms. Please keep them exactly in sync.
    // 0.436065674f, 0.385147095f, 0.143066406f,
    // 0.222488403f, 0.716873169f, 0.060607910f,
    // 0.013916016f, 0.097076416f, 0.714096069f,
    { SkFixedToFloat(0x6FA2), SkFixedToFloat(0x6299), SkFixedToFloat(0x24A0) },
    { SkFixedToFloat(0x38F5), SkFixedToFloat(0xB785), SkFixedToFloat(0x0F84) },
    { SkFixedToFloat(0x0390), SkFixedToFloat(0x18DA), SkFixedToFloat(0xB6CF) },
}};

static constexpr skcms_Matrix3x3 kAdobeRGB = {{
    // ICC fixed-point (16.16) repesentation of:
    // 0.60974, 0.20528, 0.14919,
    // 0.31111, 0.62567, 0.06322,
    // 0.01947, 0.06087, 0.74457,
    { SkFixedToFloat(0x9c18), SkFixedToFloat(0x348d), SkFixedToFloat(0x2631) },
    { SkFixedToFloat(0x4fa5), SkFixedToFloat(0xa02c), SkFixedToFloat(0x102f) },
    { SkFixedToFloat(0x04fc), SkFixedToFloat(0x0f95), SkFixedToFloat(0xbe9c) },
}};

static constexpr skcms_Matrix3x3 kDisplayP3 = {{
    {  0.515102f,   0.291965f,  0.157153f  },
    {  0.241182f,   0.692236f,  0.0665819f },
    { -0.00104941f, 0.0418818f, 0.784378f  },
}};

static constexpr skcms_Matrix3x3 kRec2020 = {{
    {  0.673459f,   0.165661f,  0.125100f  },
    {  0.279033f,   0.675338f,  0.0456288f },
    { -0.00193139f, 0.0299794f, 0.797162f  },
}};

static constexpr skcms_Matrix3x3 kXYZ = {{
    { 1.0f, 0.0f, 0.0f },
    { 0.0f, 1.0f, 0.0f },
    { 0.0f, 0.0f, 1.0f },
}};

}  // namespace SkNamedGamut

class SK_API SkColorSpace : public SkNVRefCnt<SkColorSpace> {
public:
    /**
     *  Create the sRGB color space.
     */
    static sk_sp<SkColorSpace> MakeSRGB();

    /**
     *  Colorspace with the sRGB primaries, but a linear (1.0) gamma.
     */
    static sk_sp<SkColorSpace> MakeSRGBLinear();

    /**
     *  Create an SkColorSpace from a transfer function and a row-major 3x3 transformation to XYZ.
     */
    static sk_sp<SkColorSpace> MakeRGB(const skcms_TransferFunction& transferFn,
                                       const skcms_Matrix3x3& toXYZ);

    /**
     *  Create an SkColorSpace from a parsed (skcms) ICC profile.
     */
    static sk_sp<SkColorSpace> Make(const skcms_ICCProfile&);

    /**
     *  Convert this color space to an skcms ICC profile struct.
     */
    void toProfile(skcms_ICCProfile*) const;

    /**
     *  Returns true if the color space gamma is near enough to be approximated as sRGB.
     */
    bool gammaCloseToSRGB() const;

    /**
     *  Returns true if the color space gamma is linear.
     */
    bool gammaIsLinear() const;

    /**
     *  Sets |fn| to the transfer function from this color space. Returns true if the transfer
     *  function can be represented as coefficients to the standard ICC 7-parameter equation.
     *  Returns false otherwise (eg, PQ, HLG).
     */
    bool isNumericalTransferFn(skcms_TransferFunction* fn) const;

    /**
     *  Returns true and sets |toXYZD50| if the color gamut can be described as a matrix.
     *  Returns false otherwise.
     */
    bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;

    /**
     *  Returns a hash of the gamut transformation to XYZ D50. Allows for fast equality checking
     *  of gamuts, at the (very small) risk of collision.
     */
    uint32_t toXYZD50Hash() const { return fToXYZD50Hash; }

    /**
     *  Returns a color space with the same gamut as this one, but with a linear gamma.
     *  For color spaces whose gamut can not be described in terms of XYZ D50, returns
     *  linear sRGB.
     */
    sk_sp<SkColorSpace> makeLinearGamma() const;

    /**
     *  Returns a color space with the same gamut as this one, with with the sRGB transfer
     *  function. For color spaces whose gamut can not be described in terms of XYZ D50, returns
     *  sRGB.
     */
    sk_sp<SkColorSpace> makeSRGBGamma() const;

    /**
     *  Returns a color space with the same transfer function as this one, but with the primary
     *  colors rotated. For any XYZ space, this produces a new color space that maps RGB to GBR
     *  (when applied to a source), and maps RGB to BRG (when applied to a destination). For other
     *  types of color spaces, returns nullptr.
     *
     *  This is used for testing, to construct color spaces that have severe and testable behavior.
     */
    sk_sp<SkColorSpace> makeColorSpin() const;

    /**
     *  Returns true if the color space is sRGB.
     *  Returns false otherwise.
     *
     *  This allows a little bit of tolerance, given that we might see small numerical error
     *  in some cases: converting ICC fixed point to float, converting white point to D50,
     *  rounding decisions on transfer function and matrix.
     *
     *  This does not consider a 2.2f exponential transfer function to be sRGB.  While these
     *  functions are similar (and it is sometimes useful to consider them together), this
     *  function checks for logical equality.
     */
    bool isSRGB() const;

    /**
     *  Returns nullptr on failure.  Fails when we fallback to serializing ICC data and
     *  the data is too large to serialize.
     */
    sk_sp<SkData> serialize() const;

    /**
     *  If |memory| is nullptr, returns the size required to serialize.
     *  Otherwise, serializes into |memory| and returns the size.
     */
    size_t writeToMemory(void* memory) const;

    static sk_sp<SkColorSpace> Deserialize(const void* data, size_t length);

    /**
     *  If both are null, we return true.  If one is null and the other is not, we return false.
     *  If both are non-null, we do a deeper compare.
     */
    static bool Equals(const SkColorSpace*, const SkColorSpace*);

    void       transferFn(float gabcdef[7]) const;  // DEPRECATED: Remove when webview usage is gone
    void       transferFn(skcms_TransferFunction* fn) const;
    void    invTransferFn(skcms_TransferFunction* fn) const;
    void gamutTransformTo(const SkColorSpace* dst, skcms_Matrix3x3* src_to_dst) const;

    uint32_t transferFnHash() const { return fTransferFnHash; }
    uint64_t           hash() const { return (uint64_t)fTransferFnHash << 32 | fToXYZD50Hash; }

private:
    friend class SkColorSpaceSingletonFactory;

    SkColorSpace(const skcms_TransferFunction& transferFn, const skcms_Matrix3x3& toXYZ);

    void computeLazyDstFields() const;

    uint32_t                            fTransferFnHash;
    uint32_t                            fToXYZD50Hash;

    skcms_TransferFunction              fTransferFn;
    skcms_Matrix3x3                     fToXYZD50;

    mutable skcms_TransferFunction      fInvTransferFn;
    mutable skcms_Matrix3x3             fFromXYZD50;
    mutable SkOnce                      fLazyDstFieldsOnce;
};

#endif

Coverage Report

Created: 2021-08-22 09:07

Line	Count	Source
1		/*
2		* Copyright 2016 Google Inc.
3		*
4		* Use of this source code is governed by a BSD-style license that can be
5		* found in the LICENSE file.
6		*/
7
8		#ifndef SkColorSpace_DEFINED
9		#define SkColorSpace_DEFINED
10
11		#include "include/core/SkRefCnt.h"
12		#include "include/private/SkFixed.h"
13		#include "include/private/SkOnce.h"
14		#include "include/third_party/skcms/skcms.h"
15		#include <memory>
16
17		class SkData;
18
19		/**
20		* Describes a color gamut with primaries and a white point.
21		*/
22		struct SK_API SkColorSpacePrimaries {
23		float fRX;
24		float fRY;
25		float fGX;
26		float fGY;
27		float fBX;
28		float fBY;
29		float fWX;
30		float fWY;
31
32		/**
33		* Convert primaries and a white point to a toXYZD50 matrix, the preferred color gamut
34		* representation of SkColorSpace.
35		*/
36		bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;
37		};
38
39		namespace SkNamedTransferFn {
40
41		// Like SkNamedGamut::kSRGB, keeping this bitwise exactly the same as skcms makes things fastest.
42		static constexpr skcms_TransferFunction kSRGB =
43		{ 2.4f, (float)(1/1.055), (float)(0.055/1.055), (float)(1/12.92), 0.04045f, 0.0f, 0.0f };
44
45		static constexpr skcms_TransferFunction k2Dot2 =
46		{ 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
47
48		static constexpr skcms_TransferFunction kLinear =
49		{ 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
50
51		static constexpr skcms_TransferFunction kRec2020 =
52		{2.22222f, 0.909672f, 0.0903276f, 0.222222f, 0.0812429f, 0, 0};
53
54		static constexpr skcms_TransferFunction kPQ =
55		{-2.0f, -107/128.0f, 1.0f, 32/2523.0f, 2413/128.0f, -2392/128.0f, 8192/1305.0f };
56
57		static constexpr skcms_TransferFunction kHLG =
58		{-3.0f, 2.0f, 2.0f, 1/0.17883277f, 0.28466892f, 0.55991073f, 0.0f };
59
60		} // namespace SkNamedTransferFn
61
62		namespace SkNamedGamut {
63
64		static constexpr skcms_Matrix3x3 kSRGB = {{
65		// ICC fixed-point (16.16) representation, taken from skcms. Please keep them exactly in sync.
66		// 0.436065674f, 0.385147095f, 0.143066406f,
67		// 0.222488403f, 0.716873169f, 0.060607910f,
68		// 0.013916016f, 0.097076416f, 0.714096069f,
69		{ SkFixedToFloat(0x6FA2), SkFixedToFloat(0x6299), SkFixedToFloat(0x24A0) },
70		{ SkFixedToFloat(0x38F5), SkFixedToFloat(0xB785), SkFixedToFloat(0x0F84) },
71		{ SkFixedToFloat(0x0390), SkFixedToFloat(0x18DA), SkFixedToFloat(0xB6CF) },
72		}};
73
74		static constexpr skcms_Matrix3x3 kAdobeRGB = {{
75		// ICC fixed-point (16.16) repesentation of:
76		// 0.60974, 0.20528, 0.14919,
77		// 0.31111, 0.62567, 0.06322,
78		// 0.01947, 0.06087, 0.74457,
79		{ SkFixedToFloat(0x9c18), SkFixedToFloat(0x348d), SkFixedToFloat(0x2631) },
80		{ SkFixedToFloat(0x4fa5), SkFixedToFloat(0xa02c), SkFixedToFloat(0x102f) },
81		{ SkFixedToFloat(0x04fc), SkFixedToFloat(0x0f95), SkFixedToFloat(0xbe9c) },
82		}};
83
84		static constexpr skcms_Matrix3x3 kDisplayP3 = {{
85		{ 0.515102f, 0.291965f, 0.157153f },
86		{ 0.241182f, 0.692236f, 0.0665819f },
87		{ -0.00104941f, 0.0418818f, 0.784378f },
88		}};
89
90		static constexpr skcms_Matrix3x3 kRec2020 = {{
91		{ 0.673459f, 0.165661f, 0.125100f },
92		{ 0.279033f, 0.675338f, 0.0456288f },
93		{ -0.00193139f, 0.0299794f, 0.797162f },
94		}};
95
96		static constexpr skcms_Matrix3x3 kXYZ = {{
97		{ 1.0f, 0.0f, 0.0f },
98		{ 0.0f, 1.0f, 0.0f },
99		{ 0.0f, 0.0f, 1.0f },
100		}};
101
102		} // namespace SkNamedGamut
103
104		class SK_API SkColorSpace : public SkNVRefCnt<SkColorSpace> {
105		public:
106		/**
107		* Create the sRGB color space.
108		*/
109		static sk_sp<SkColorSpace> MakeSRGB();
110
111		/**
112		* Colorspace with the sRGB primaries, but a linear (1.0) gamma.
113		*/
114		static sk_sp<SkColorSpace> MakeSRGBLinear();
115
116		/**
117		* Create an SkColorSpace from a transfer function and a row-major 3x3 transformation to XYZ.
118		*/
119		static sk_sp<SkColorSpace> MakeRGB(const skcms_TransferFunction& transferFn,
120		const skcms_Matrix3x3& toXYZ);
121
122		/**
123		* Create an SkColorSpace from a parsed (skcms) ICC profile.
124		*/
125		static sk_sp<SkColorSpace> Make(const skcms_ICCProfile&);
126
127		/**
128		* Convert this color space to an skcms ICC profile struct.
129		*/
130		void toProfile(skcms_ICCProfile*) const;
131
132		/**
133		* Returns true if the color space gamma is near enough to be approximated as sRGB.
134		*/
135		bool gammaCloseToSRGB() const;
136
137		/**
138		* Returns true if the color space gamma is linear.
139		*/
140		bool gammaIsLinear() const;
141
142		/**
143		* Sets \|fn\| to the transfer function from this color space. Returns true if the transfer
144		* function can be represented as coefficients to the standard ICC 7-parameter equation.
145		* Returns false otherwise (eg, PQ, HLG).
146		*/
147		bool isNumericalTransferFn(skcms_TransferFunction* fn) const;
148
149		/**
150		* Returns true and sets \|toXYZD50\| if the color gamut can be described as a matrix.
151		* Returns false otherwise.
152		*/
153		bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;
154
155		/**
156		* Returns a hash of the gamut transformation to XYZ D50. Allows for fast equality checking
157		* of gamuts, at the (very small) risk of collision.
158		*/
159	1.02M	uint32_t toXYZD50Hash() const { return fToXYZD50Hash; }
160
161		/**
162		* Returns a color space with the same gamut as this one, but with a linear gamma.
163		* For color spaces whose gamut can not be described in terms of XYZ D50, returns
164		* linear sRGB.
165		*/
166		sk_sp<SkColorSpace> makeLinearGamma() const;
167
168		/**
169		* Returns a color space with the same gamut as this one, with with the sRGB transfer
170		* function. For color spaces whose gamut can not be described in terms of XYZ D50, returns
171		* sRGB.
172		*/
173		sk_sp<SkColorSpace> makeSRGBGamma() const;
174
175		/**
176		* Returns a color space with the same transfer function as this one, but with the primary
177		* colors rotated. For any XYZ space, this produces a new color space that maps RGB to GBR
178		* (when applied to a source), and maps RGB to BRG (when applied to a destination). For other
179		* types of color spaces, returns nullptr.
180		*
181		* This is used for testing, to construct color spaces that have severe and testable behavior.
182		*/
183		sk_sp<SkColorSpace> makeColorSpin() const;
184
185		/**
186		* Returns true if the color space is sRGB.
187		* Returns false otherwise.
188		*
189		* This allows a little bit of tolerance, given that we might see small numerical error
190		* in some cases: converting ICC fixed point to float, converting white point to D50,
191		* rounding decisions on transfer function and matrix.
192		*
193		* This does not consider a 2.2f exponential transfer function to be sRGB. While these
194		* functions are similar (and it is sometimes useful to consider them together), this
195		* function checks for logical equality.
196		*/
197		bool isSRGB() const;
198
199		/**
200		* Returns nullptr on failure. Fails when we fallback to serializing ICC data and
201		* the data is too large to serialize.
202		*/
203		sk_sp<SkData> serialize() const;
204
205		/**
206		* If \|memory\| is nullptr, returns the size required to serialize.
207		* Otherwise, serializes into \|memory\| and returns the size.
208		*/
209		size_t writeToMemory(void* memory) const;
210
211		static sk_sp<SkColorSpace> Deserialize(const void* data, size_t length);
212
213		/**
214		* If both are null, we return true. If one is null and the other is not, we return false.
215		* If both are non-null, we do a deeper compare.
216		*/
217		static bool Equals(const SkColorSpace, const SkColorSpace);
218
219		void transferFn(float gabcdef[7]) const; // DEPRECATED: Remove when webview usage is gone
220		void transferFn(skcms_TransferFunction* fn) const;
221		void invTransferFn(skcms_TransferFunction* fn) const;
222		void gamutTransformTo(const SkColorSpace* dst, skcms_Matrix3x3* src_to_dst) const;
223
224	734k	uint32_t transferFnHash() const { return fTransferFnHash; }
225	4.03M	uint64_t hash() const { return (uint64_t)fTransferFnHash << 32 \| fToXYZD50Hash; }
226
227		private:
228		friend class SkColorSpaceSingletonFactory;
229
230		SkColorSpace(const skcms_TransferFunction& transferFn, const skcms_Matrix3x3& toXYZ);
231
232		void computeLazyDstFields() const;
233
234		uint32_t fTransferFnHash;
235		uint32_t fToXYZD50Hash;
236
237		skcms_TransferFunction fTransferFn;
238		skcms_Matrix3x3 fToXYZD50;
239
240		mutable skcms_TransferFunction fInvTransferFn;
241		mutable skcms_Matrix3x3 fFromXYZD50;
242		mutable SkOnce fLazyDstFieldsOnce;
243		};
244
245		#endif