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 #ifndef SkColorSpacePriv_DEFINED
8 #define SkColorSpacePriv_DEFINED
9
10 #include <math.h>
11
12 #include "SkColorSpace.h"
13 #include "SkFixed.h"
14
15 #define SkColorSpacePrintf(...)
16
17 static constexpr float gSRGB_toXYZD50[] {
18 0.4360747f, 0.3850649f, 0.1430804f, // Rx, Gx, Bx
19 0.2225045f, 0.7168786f, 0.0606169f, // Ry, Gy, Gz
20 0.0139322f, 0.0971045f, 0.7141733f, // Rz, Gz, Bz
21 };
22
23 static constexpr float gAdobeRGB_toXYZD50[] {
24 #ifdef SK_SUPPORT_LEGACY_ADOBE_XYZ
25 0.6097559f, 0.2052401f, 0.1492240f, // Rx, Gx, Bx
26 0.3111242f, 0.6256560f, 0.0632197f, // Ry, Gy, Gz
27 0.0194811f, 0.0608902f, 0.7448387f, // Rz, Gz, Bz
28 #else
29 // ICC fixed-point (16.16) repesentation of:
30 // 0.60974, 0.20528, 0.14919,
31 // 0.31111, 0.62567, 0.06322,
32 // 0.01947, 0.06087, 0.74457,
33 SkFixedToFloat(0x9c18), SkFixedToFloat(0x348d), SkFixedToFloat(0x2631), // Rx, Gx, Bx
34 SkFixedToFloat(0x4fa5), SkFixedToFloat(0xa02c), SkFixedToFloat(0x102f), // Ry, Gy, Gz
35 SkFixedToFloat(0x04fc), SkFixedToFloat(0x0f95), SkFixedToFloat(0xbe9c), // Rz, Gz, Bz
36 #endif
37 };
38
39 static constexpr float gDCIP3_toXYZD50[] {
40 0.515102f, 0.291965f, 0.157153f, // Rx, Gx, Bx
41 0.241182f, 0.692236f, 0.0665819f, // Ry, Gy, Gz
42 -0.00104941f, 0.0418818f, 0.784378f, // Rz, Gz, Bz
43 };
44
45 static constexpr float gRec2020_toXYZD50[] {
46 0.673459f, 0.165661f, 0.125100f, // Rx, Gx, Bx
47 0.279033f, 0.675338f, 0.0456288f, // Ry, Gy, Gz
48 -0.00193139f, 0.0299794f, 0.797162f, // Rz, Gz, Bz
49 };
50
51 static constexpr SkColorSpaceTransferFn gSRGB_TransferFn =
52 { 2.4f, 1.0f / 1.055f, 0.055f / 1.055f, 1.0f / 12.92f, 0.04045f, 0.0f, 0.0f };
53
54 static constexpr SkColorSpaceTransferFn g2Dot2_TransferFn =
55 { 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
56
57 // gLinear_TransferFn.fD > 1.0f: Make sure that we use the linear segment of
58 // the transfer function even when the x-value is 1.0f.
59 static constexpr SkColorSpaceTransferFn gLinear_TransferFn =
60 { 0.0f, 0.0f, 0.0f, 1.0f, 1.0000001f, 0.0f, 0.0f };
61
62 static constexpr SkColorSpaceTransferFn gDCIP3_TransferFn =
63 { 2.399994f, 0.947998047f, 0.0520019531f, 0.0769958496f, 0.0390014648f, 0.0f, 0.0f };
64
to_xyz_d50(SkMatrix44 * toXYZD50,SkColorSpace::Gamut gamut)65 static inline void to_xyz_d50(SkMatrix44* toXYZD50, SkColorSpace::Gamut gamut) {
66 switch (gamut) {
67 case SkColorSpace::kSRGB_Gamut:
68 toXYZD50->set3x3RowMajorf(gSRGB_toXYZD50);
69 break;
70 case SkColorSpace::kAdobeRGB_Gamut:
71 toXYZD50->set3x3RowMajorf(gAdobeRGB_toXYZD50);
72 break;
73 case SkColorSpace::kDCIP3_D65_Gamut:
74 toXYZD50->set3x3RowMajorf(gDCIP3_toXYZD50);
75 break;
76 case SkColorSpace::kRec2020_Gamut:
77 toXYZD50->set3x3RowMajorf(gRec2020_toXYZD50);
78 break;
79 }
80 }
81
color_space_almost_equal(float a,float b)82 static inline bool color_space_almost_equal(float a, float b) {
83 return SkTAbs(a - b) < 0.01f;
84 }
85
86 // Let's use a stricter version for transfer functions. Worst case, these are encoded
87 // in ICC format, which offers 16-bits of fractional precision.
transfer_fn_almost_equal(float a,float b)88 static inline bool transfer_fn_almost_equal(float a, float b) {
89 return SkTAbs(a - b) < 0.001f;
90 }
91
is_zero_to_one(float v)92 static inline bool is_zero_to_one(float v) {
93 // Because we allow a value just barely larger than 1, the client can use an
94 // entirely linear transfer function.
95 return (0.0f <= v) && (v <= nextafterf(1.0f, 2.0f));
96 }
97
is_valid_transfer_fn(const SkColorSpaceTransferFn & coeffs)98 static inline bool is_valid_transfer_fn(const SkColorSpaceTransferFn& coeffs) {
99 if (SkScalarIsNaN(coeffs.fA) || SkScalarIsNaN(coeffs.fB) ||
100 SkScalarIsNaN(coeffs.fC) || SkScalarIsNaN(coeffs.fD) ||
101 SkScalarIsNaN(coeffs.fE) || SkScalarIsNaN(coeffs.fF) ||
102 SkScalarIsNaN(coeffs.fG))
103 {
104 return false;
105 }
106
107 if (!is_zero_to_one(coeffs.fD)) {
108 return false;
109 }
110
111 if (coeffs.fD == 0.0f) {
112 // Y = (aX + b)^g + e for always
113 if (0.0f == coeffs.fA || 0.0f == coeffs.fG) {
114 SkColorSpacePrintf("A or G is zero, constant transfer function "
115 "is nonsense");
116 return false;
117 }
118 }
119
120 if (coeffs.fD >= 1.0f) {
121 // Y = cX + f for always
122 if (0.0f == coeffs.fC) {
123 SkColorSpacePrintf("C is zero, constant transfer function is "
124 "nonsense");
125 return false;
126 }
127 }
128
129 if ((0.0f == coeffs.fA || 0.0f == coeffs.fG) && 0.0f == coeffs.fC) {
130 SkColorSpacePrintf("A or G, and C are zero, constant transfer function "
131 "is nonsense");
132 return false;
133 }
134
135 if (coeffs.fC < 0.0f) {
136 SkColorSpacePrintf("Transfer function must be increasing");
137 return false;
138 }
139
140 if (coeffs.fA < 0.0f || coeffs.fG < 0.0f) {
141 SkColorSpacePrintf("Transfer function must be positive or increasing");
142 return false;
143 }
144
145 return true;
146 }
147
is_almost_srgb(const SkColorSpaceTransferFn & coeffs)148 static inline bool is_almost_srgb(const SkColorSpaceTransferFn& coeffs) {
149 return transfer_fn_almost_equal(gSRGB_TransferFn.fA, coeffs.fA) &&
150 transfer_fn_almost_equal(gSRGB_TransferFn.fB, coeffs.fB) &&
151 transfer_fn_almost_equal(gSRGB_TransferFn.fC, coeffs.fC) &&
152 transfer_fn_almost_equal(gSRGB_TransferFn.fD, coeffs.fD) &&
153 transfer_fn_almost_equal(gSRGB_TransferFn.fE, coeffs.fE) &&
154 transfer_fn_almost_equal(gSRGB_TransferFn.fF, coeffs.fF) &&
155 transfer_fn_almost_equal(gSRGB_TransferFn.fG, coeffs.fG);
156 }
157
is_almost_2dot2(const SkColorSpaceTransferFn & coeffs)158 static inline bool is_almost_2dot2(const SkColorSpaceTransferFn& coeffs) {
159 return transfer_fn_almost_equal(1.0f, coeffs.fA) &&
160 transfer_fn_almost_equal(0.0f, coeffs.fB) &&
161 transfer_fn_almost_equal(0.0f, coeffs.fE) &&
162 transfer_fn_almost_equal(2.2f, coeffs.fG) &&
163 coeffs.fD <= 0.0f;
164 }
165
is_almost_linear(const SkColorSpaceTransferFn & coeffs)166 static inline bool is_almost_linear(const SkColorSpaceTransferFn& coeffs) {
167 // OutputVal = InputVal ^ 1.0f
168 const bool linearExp =
169 transfer_fn_almost_equal(1.0f, coeffs.fA) &&
170 transfer_fn_almost_equal(0.0f, coeffs.fB) &&
171 transfer_fn_almost_equal(0.0f, coeffs.fE) &&
172 transfer_fn_almost_equal(1.0f, coeffs.fG) &&
173 coeffs.fD <= 0.0f;
174
175 // OutputVal = 1.0f * InputVal
176 const bool linearFn =
177 transfer_fn_almost_equal(1.0f, coeffs.fC) &&
178 transfer_fn_almost_equal(0.0f, coeffs.fF) &&
179 coeffs.fD >= 1.0f;
180
181 return linearExp || linearFn;
182 }
183
is_just_gamma(const SkColorSpaceTransferFn & coeffs)184 static inline bool is_just_gamma(const SkColorSpaceTransferFn& coeffs) {
185 return transfer_fn_almost_equal(coeffs.fA, 1.0f)
186 && transfer_fn_almost_equal(coeffs.fB, 0.0f)
187 && transfer_fn_almost_equal(coeffs.fC, 0.0f)
188 && transfer_fn_almost_equal(coeffs.fD, 0.0f)
189 && transfer_fn_almost_equal(coeffs.fE, 0.0f)
190 && transfer_fn_almost_equal(coeffs.fF, 0.0f);
191 }
192
193
value_to_parametric(SkColorSpaceTransferFn * coeffs,float exponent)194 static inline void value_to_parametric(SkColorSpaceTransferFn* coeffs, float exponent) {
195 coeffs->fA = 1.0f;
196 coeffs->fB = 0.0f;
197 coeffs->fC = 0.0f;
198 coeffs->fD = 0.0f;
199 coeffs->fE = 0.0f;
200 coeffs->fF = 0.0f;
201 coeffs->fG = exponent;
202 }
203
named_to_parametric(SkColorSpaceTransferFn * coeffs,SkGammaNamed gammaNamed)204 static inline bool named_to_parametric(SkColorSpaceTransferFn* coeffs,
205 SkGammaNamed gammaNamed) {
206 switch (gammaNamed) {
207 case kSRGB_SkGammaNamed:
208 *coeffs = gSRGB_TransferFn;
209 return true;
210 case k2Dot2Curve_SkGammaNamed:
211 *coeffs = g2Dot2_TransferFn;
212 return true;
213 case kLinear_SkGammaNamed:
214 *coeffs = gLinear_TransferFn;
215 return true;
216 default:
217 return false;
218 }
219 }
220 #endif // SkColorSpacePriv_DEFINED
221