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 #include "Resources.h"
9 #include "SkCodec.h"
10 #include "SkColorSpace.h"
11 #include "SkColorSpace_Base.h"
12 #include "SkColorSpace_XYZ.h"
13 #include "SkColorSpacePriv.h"
14 #include "Test.h"
15
16 #include "png.h"
17
almost_equal(float a,float b)18 static bool almost_equal(float a, float b) {
19 return SkTAbs(a - b) < 0.001f;
20 }
21
test_space(skiatest::Reporter * r,SkColorSpace * space,const float red[],const float green[],const float blue[],const SkGammaNamed expectedGamma)22 static void test_space(skiatest::Reporter* r, SkColorSpace* space,
23 const float red[], const float green[], const float blue[],
24 const SkGammaNamed expectedGamma) {
25
26 REPORTER_ASSERT(r, nullptr != space);
27 SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(space)->type());
28 SkColorSpace_XYZ* csXYZ = static_cast<SkColorSpace_XYZ*>(space);
29 REPORTER_ASSERT(r, expectedGamma == csXYZ->gammaNamed());
30
31 const SkMatrix44& mat = *csXYZ->toXYZD50();
32 const float src[] = {
33 1, 0, 0, 1,
34 0, 1, 0, 1,
35 0, 0, 1, 1,
36 };
37 const float* ref[3] = { red, green, blue };
38 float dst[4];
39 for (int i = 0; i < 3; ++i) {
40 mat.mapScalars(&src[i*4], dst);
41 REPORTER_ASSERT(r, almost_equal(ref[i][0], dst[0]));
42 REPORTER_ASSERT(r, almost_equal(ref[i][1], dst[1]));
43 REPORTER_ASSERT(r, almost_equal(ref[i][2], dst[2]));
44 }
45 }
46
test_path(skiatest::Reporter * r,const char * path,const float red[],const float green[],const float blue[],const SkGammaNamed expectedGamma)47 static void test_path(skiatest::Reporter* r, const char* path,
48 const float red[], const float green[], const float blue[],
49 const SkGammaNamed expectedGamma) {
50 std::unique_ptr<SkStream> stream(GetResourceAsStream(path));
51 REPORTER_ASSERT(r, nullptr != stream);
52 if (!stream) {
53 return;
54 }
55
56 std::unique_ptr<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
57 REPORTER_ASSERT(r, nullptr != codec);
58 if (!codec) {
59 return;
60 }
61
62 SkColorSpace* colorSpace = codec->getInfo().colorSpace();
63 test_space(r, colorSpace, red, green, blue, expectedGamma);
64 }
65
66 static constexpr float g_sRGB_XYZ[]{
67 0.4358f, 0.3853f, 0.1430f, // Rx, Gx, Bx
68 0.2224f, 0.7170f, 0.0606f, // Ry, Gy, Gz
69 0.0139f, 0.0971f, 0.7139f, // Rz, Gz, Bz
70 };
71
72 static constexpr float g_sRGB_R[]{ 0.4358f, 0.2224f, 0.0139f };
73 static constexpr float g_sRGB_G[]{ 0.3853f, 0.7170f, 0.0971f };
74 static constexpr float g_sRGB_B[]{ 0.1430f, 0.0606f, 0.7139f };
75
DEF_TEST(ColorSpace_sRGB,r)76 DEF_TEST(ColorSpace_sRGB, r) {
77 test_space(r, SkColorSpace::MakeSRGB().get(),
78 g_sRGB_R, g_sRGB_G, g_sRGB_B, kSRGB_SkGammaNamed);
79
80 }
81
DEF_TEST(ColorSpaceParseICCProfiles,r)82 DEF_TEST(ColorSpaceParseICCProfiles, r) {
83
84 #if (PNG_LIBPNG_VER_MAJOR > 1) || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 6)
85 test_path(r, "color_wheel_with_profile.png", g_sRGB_R, g_sRGB_G, g_sRGB_B,
86 kSRGB_SkGammaNamed);
87 #endif
88
89 const float red[] = { 0.385117f, 0.716904f, 0.0970612f };
90 const float green[] = { 0.143051f, 0.0606079f, 0.713913f };
91 const float blue[] = { 0.436035f, 0.222488f, 0.013916f };
92 test_path(r, "icc-v2-gbr.jpg", red, green, blue, k2Dot2Curve_SkGammaNamed);
93
94 test_path(r, "webp-color-profile-crash.webp",
95 red, green, blue, kNonStandard_SkGammaNamed);
96 test_path(r, "webp-color-profile-lossless.webp",
97 red, green, blue, kNonStandard_SkGammaNamed);
98 test_path(r, "webp-color-profile-lossy.webp",
99 red, green, blue, kNonStandard_SkGammaNamed);
100 test_path(r, "webp-color-profile-lossy-alpha.webp",
101 red, green, blue, kNonStandard_SkGammaNamed);
102 }
103
DEF_TEST(ColorSpaceSRGBCompare,r)104 DEF_TEST(ColorSpaceSRGBCompare, r) {
105 // Create an sRGB color space by name
106 sk_sp<SkColorSpace> namedColorSpace = SkColorSpace::MakeSRGB();
107
108 // Create an sRGB color space by value
109 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
110 srgbToxyzD50.set3x3RowMajorf(g_sRGB_XYZ);
111 sk_sp<SkColorSpace> rgbColorSpace =
112 SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma, srgbToxyzD50);
113 REPORTER_ASSERT(r, rgbColorSpace == namedColorSpace);
114
115 SkColorSpaceTransferFn srgbFn;
116 srgbFn.fA = (1.0f / 1.055f);
117 srgbFn.fB = (0.055f / 1.055f);
118 srgbFn.fC = (1.0f / 12.92f);
119 srgbFn.fD = 0.04045f;
120 srgbFn.fE = 0.0f;
121 srgbFn.fF = 0.0f;
122 srgbFn.fG = 2.4f;
123 sk_sp<SkColorSpace> rgbColorSpace2 = SkColorSpace::MakeRGB(srgbFn, srgbToxyzD50);
124 REPORTER_ASSERT(r, rgbColorSpace2 == namedColorSpace);
125
126 // Change a single value from the sRGB matrix
127 srgbToxyzD50.set(2, 2, 0.5f);
128 sk_sp<SkColorSpace> strangeColorSpace =
129 SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma, srgbToxyzD50);
130 REPORTER_ASSERT(r, strangeColorSpace != namedColorSpace);
131 }
132
DEF_TEST(ColorSpaceSRGBLinearCompare,r)133 DEF_TEST(ColorSpaceSRGBLinearCompare, r) {
134 // Create the linear sRGB color space by name
135 sk_sp<SkColorSpace> namedColorSpace = SkColorSpace::MakeSRGBLinear();
136
137 // Create the linear sRGB color space via the sRGB color space's makeLinearGamma()
138 auto srgb = SkColorSpace::MakeSRGB();
139 auto srgbXYZ = static_cast<SkColorSpace_XYZ*>(srgb.get());
140 sk_sp<SkColorSpace> viaSrgbColorSpace = srgbXYZ->makeLinearGamma();
141 REPORTER_ASSERT(r, namedColorSpace == viaSrgbColorSpace);
142
143 // Create a linear sRGB color space by value
144 SkMatrix44 srgbToxyzD50(SkMatrix44::kUninitialized_Constructor);
145 srgbToxyzD50.set3x3RowMajorf(g_sRGB_XYZ);
146 sk_sp<SkColorSpace> rgbColorSpace =
147 SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma, srgbToxyzD50);
148 REPORTER_ASSERT(r, rgbColorSpace == namedColorSpace);
149
150 SkColorSpaceTransferFn linearExpFn;
151 linearExpFn.fA = 1.0f;
152 linearExpFn.fB = 0.0f;
153 linearExpFn.fC = 0.0f;
154 linearExpFn.fD = 0.0f;
155 linearExpFn.fE = 0.0f;
156 linearExpFn.fF = 0.0f;
157 linearExpFn.fG = 1.0f;
158 sk_sp<SkColorSpace> rgbColorSpace2 = SkColorSpace::MakeRGB(linearExpFn, srgbToxyzD50);
159 REPORTER_ASSERT(r, rgbColorSpace2 == namedColorSpace);
160
161 SkColorSpaceTransferFn linearFn;
162 linearFn.fA = 0.0f;
163 linearFn.fB = 0.0f;
164 linearFn.fC = 1.0f;
165 linearFn.fD = 1.0f;
166 linearFn.fE = 0.0f;
167 linearFn.fF = 0.0f;
168 linearFn.fG = 0.0f;
169 sk_sp<SkColorSpace> rgbColorSpace3 = SkColorSpace::MakeRGB(linearFn, srgbToxyzD50);
170 REPORTER_ASSERT(r, rgbColorSpace3 == namedColorSpace);
171
172 // Change a single value from the sRGB matrix
173 srgbToxyzD50.set(2, 2, 0.5f);
174 sk_sp<SkColorSpace> strangeColorSpace =
175 SkColorSpace::MakeRGB(SkColorSpace::kLinear_RenderTargetGamma, srgbToxyzD50);
176 REPORTER_ASSERT(r, strangeColorSpace != namedColorSpace);
177 }
178
DEF_TEST(ColorSpaceAdobeCompare,r)179 DEF_TEST(ColorSpaceAdobeCompare, r) {
180 // Create an sRGB color space by name
181 sk_sp<SkColorSpace> namedColorSpace =
182 SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kAdobeRGB_Named);
183
184 // Create an sRGB color space by value
185 SkMatrix44 adobeToxyzD50(SkMatrix44::kUninitialized_Constructor);
186 adobeToxyzD50.set3x3RowMajorf(gAdobeRGB_toXYZD50);
187
188 SkColorSpaceTransferFn fn;
189 fn.fA = 1.0f;
190 fn.fB = 0.0f;
191 fn.fC = 0.0f;
192 fn.fD = 0.0f;
193 fn.fE = 0.0f;
194 fn.fF = 0.0f;
195 fn.fG = 2.2f;
196 sk_sp<SkColorSpace> rgbColorSpace = SkColorSpace::MakeRGB(fn, adobeToxyzD50);
197 REPORTER_ASSERT(r, rgbColorSpace == namedColorSpace);
198 }
199
DEF_TEST(ColorSpace_Named,r)200 DEF_TEST(ColorSpace_Named, r) {
201 const struct {
202 SkColorSpace_Base::Named fNamed;
203 SkGammaNamed fExpectedGamma;
204 } recs[] {
205 { SkColorSpace_Base::kSRGB_Named, kSRGB_SkGammaNamed },
206 { SkColorSpace_Base::kAdobeRGB_Named, k2Dot2Curve_SkGammaNamed },
207 { SkColorSpace_Base::kSRGBLinear_Named, kLinear_SkGammaNamed },
208 };
209
210 for (auto rec : recs) {
211 auto cs = SkColorSpace_Base::MakeNamed(rec.fNamed);
212 REPORTER_ASSERT(r, cs);
213 if (cs) {
214 SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(cs)->type());
215 SkColorSpace_XYZ* csXYZ = static_cast<SkColorSpace_XYZ*>(cs.get());
216 REPORTER_ASSERT(r, rec.fExpectedGamma == csXYZ->gammaNamed());
217 }
218 }
219
220 SkImageInfo info = SkImageInfo::MakeS32(10, 10, kPremul_SkAlphaType);
221 REPORTER_ASSERT(r, info.gammaCloseToSRGB());
222 }
223
test_serialize(skiatest::Reporter * r,SkColorSpace * space,bool isNamed)224 static void test_serialize(skiatest::Reporter* r, SkColorSpace* space, bool isNamed) {
225 sk_sp<SkData> data1 = space->serialize();
226
227 size_t bytes = space->writeToMemory(nullptr);
228 sk_sp<SkData> data2 = SkData::MakeUninitialized(bytes);
229 space->writeToMemory(data2->writable_data());
230
231 sk_sp<SkColorSpace> newSpace1 = SkColorSpace::Deserialize(data1->data(), data1->size());
232 sk_sp<SkColorSpace> newSpace2 = SkColorSpace::Deserialize(data2->data(), data2->size());
233
234 if (isNamed) {
235 REPORTER_ASSERT(r, space == newSpace1.get());
236 REPORTER_ASSERT(r, space == newSpace2.get());
237 } else {
238 REPORTER_ASSERT(r, SkColorSpace::Equals(space, newSpace1.get()));
239 REPORTER_ASSERT(r, SkColorSpace::Equals(space, newSpace2.get()));
240 }
241 }
242
DEF_TEST(ColorSpace_Serialize,r)243 DEF_TEST(ColorSpace_Serialize, r) {
244 test_serialize(r, SkColorSpace::MakeSRGB().get(), true);
245 test_serialize(r, SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kAdobeRGB_Named).get(), true);
246 test_serialize(r, SkColorSpace::MakeSRGBLinear().get(), true);
247
248 sk_sp<SkData> monitorData = SkData::MakeFromFileName(
249 GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
250 test_serialize(r, SkColorSpace::MakeICC(monitorData->data(), monitorData->size()).get(), false);
251 monitorData = SkData::MakeFromFileName( GetResourcePath("icc_profiles/HP_Z32x.icc").c_str());
252 test_serialize(r, SkColorSpace::MakeICC(monitorData->data(), monitorData->size()).get(), false);
253 monitorData = SkData::MakeFromFileName(GetResourcePath("icc_profiles/upperLeft.icc").c_str());
254 test_serialize(r, SkColorSpace::MakeICC(monitorData->data(), monitorData->size()).get(), false);
255 monitorData = SkData::MakeFromFileName(GetResourcePath("icc_profiles/upperRight.icc").c_str());
256 test_serialize(r, SkColorSpace::MakeICC(monitorData->data(), monitorData->size()).get(), false);
257
258 SkColorSpaceTransferFn fn;
259 fn.fA = 1.0f;
260 fn.fB = 0.0f;
261 fn.fC = 1.0f;
262 fn.fD = 0.5f;
263 fn.fE = 0.0f;
264 fn.fF = 0.0f;
265 fn.fG = 1.0f;
266 SkMatrix44 toXYZ(SkMatrix44::kIdentity_Constructor);
267 test_serialize(r, SkColorSpace::MakeRGB(fn, toXYZ).get(), false);
268 }
269
DEF_TEST(ColorSpace_Equals,r)270 DEF_TEST(ColorSpace_Equals, r) {
271 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
272 sk_sp<SkColorSpace> adobe = SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kAdobeRGB_Named);
273 sk_sp<SkData> data = SkData::MakeFromFileName(
274 GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
275 sk_sp<SkColorSpace> z30 = SkColorSpace::MakeICC(data->data(), data->size());
276 data = SkData::MakeFromFileName( GetResourcePath("icc_profiles/HP_Z32x.icc").c_str());
277 sk_sp<SkColorSpace> z32 = SkColorSpace::MakeICC(data->data(), data->size());
278 data = SkData::MakeFromFileName(GetResourcePath("icc_profiles/upperLeft.icc").c_str());
279 sk_sp<SkColorSpace> upperLeft = SkColorSpace::MakeICC(data->data(), data->size());
280 data = SkData::MakeFromFileName(GetResourcePath("icc_profiles/upperRight.icc").c_str());
281 sk_sp<SkColorSpace> upperRight = SkColorSpace::MakeICC(data->data(), data->size());
282
283 SkColorSpaceTransferFn fn;
284 fn.fA = 1.0f;
285 fn.fB = 0.0f;
286 fn.fC = 1.0f;
287 fn.fD = 0.5f;
288 fn.fE = 0.0f;
289 fn.fF = 0.0f;
290 fn.fG = 1.0f;
291 SkMatrix44 toXYZ(SkMatrix44::kIdentity_Constructor);
292 sk_sp<SkColorSpace> rgb4 = SkColorSpace::MakeRGB(fn, toXYZ);
293
294 REPORTER_ASSERT(r, SkColorSpace::Equals(nullptr, nullptr));
295 REPORTER_ASSERT(r, SkColorSpace::Equals(srgb.get(), srgb.get()));
296 REPORTER_ASSERT(r, SkColorSpace::Equals(adobe.get(), adobe.get()));
297 REPORTER_ASSERT(r, SkColorSpace::Equals(z30.get(), z30.get()));
298 REPORTER_ASSERT(r, SkColorSpace::Equals(z32.get(), z32.get()));
299 REPORTER_ASSERT(r, SkColorSpace::Equals(upperLeft.get(), upperLeft.get()));
300 REPORTER_ASSERT(r, SkColorSpace::Equals(upperRight.get(), upperRight.get()));
301 REPORTER_ASSERT(r, SkColorSpace::Equals(rgb4.get(), rgb4.get()));
302
303 REPORTER_ASSERT(r, !SkColorSpace::Equals(nullptr, srgb.get()));
304 REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), nullptr));
305 REPORTER_ASSERT(r, !SkColorSpace::Equals(adobe.get(), srgb.get()));
306 REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), srgb.get()));
307 REPORTER_ASSERT(r, !SkColorSpace::Equals(z32.get(), z30.get()));
308 REPORTER_ASSERT(r, !SkColorSpace::Equals(upperLeft.get(), srgb.get()));
309 REPORTER_ASSERT(r, !SkColorSpace::Equals(upperLeft.get(), upperRight.get()));
310 REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), upperRight.get()));
311 REPORTER_ASSERT(r, !SkColorSpace::Equals(upperRight.get(), adobe.get()));
312 REPORTER_ASSERT(r, !SkColorSpace::Equals(z30.get(), rgb4.get()));
313 REPORTER_ASSERT(r, !SkColorSpace::Equals(srgb.get(), rgb4.get()));
314 }
315
matrix_almost_equal(const SkMatrix44 & a,const SkMatrix44 & b)316 static inline bool matrix_almost_equal(const SkMatrix44& a, const SkMatrix44& b) {
317 return almost_equal(a.get(0, 0), b.get(0, 0)) &&
318 almost_equal(a.get(0, 1), b.get(0, 1)) &&
319 almost_equal(a.get(0, 2), b.get(0, 2)) &&
320 almost_equal(a.get(0, 3), b.get(0, 3)) &&
321 almost_equal(a.get(1, 0), b.get(1, 0)) &&
322 almost_equal(a.get(1, 1), b.get(1, 1)) &&
323 almost_equal(a.get(1, 2), b.get(1, 2)) &&
324 almost_equal(a.get(1, 3), b.get(1, 3)) &&
325 almost_equal(a.get(2, 0), b.get(2, 0)) &&
326 almost_equal(a.get(2, 1), b.get(2, 1)) &&
327 almost_equal(a.get(2, 2), b.get(2, 2)) &&
328 almost_equal(a.get(2, 3), b.get(2, 3)) &&
329 almost_equal(a.get(3, 0), b.get(3, 0)) &&
330 almost_equal(a.get(3, 1), b.get(3, 1)) &&
331 almost_equal(a.get(3, 2), b.get(3, 2)) &&
332 almost_equal(a.get(3, 3), b.get(3, 3));
333 }
334
check_primaries(skiatest::Reporter * r,const SkColorSpacePrimaries & primaries,const SkMatrix44 & reference)335 static inline void check_primaries(skiatest::Reporter* r, const SkColorSpacePrimaries& primaries,
336 const SkMatrix44& reference) {
337 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
338 bool result = primaries.toXYZD50(&toXYZ);
339 REPORTER_ASSERT(r, result);
340 REPORTER_ASSERT(r, matrix_almost_equal(toXYZ, reference));
341 }
342
DEF_TEST(ColorSpace_Primaries,r)343 DEF_TEST(ColorSpace_Primaries, r) {
344 // sRGB primaries (D65)
345 SkColorSpacePrimaries srgb;
346 srgb.fRX = 0.64f;
347 srgb.fRY = 0.33f;
348 srgb.fGX = 0.30f;
349 srgb.fGY = 0.60f;
350 srgb.fBX = 0.15f;
351 srgb.fBY = 0.06f;
352 srgb.fWX = 0.3127f;
353 srgb.fWY = 0.3290f;
354 SkMatrix44 srgbToXYZ(SkMatrix44::kUninitialized_Constructor);
355 bool result = srgb.toXYZD50(&srgbToXYZ);
356 REPORTER_ASSERT(r, result);
357
358 sk_sp<SkColorSpace> space = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
359 srgbToXYZ);
360 REPORTER_ASSERT(r, SkColorSpace::MakeSRGB() == space);
361
362 // AdobeRGB primaries (D65)
363 SkColorSpacePrimaries adobe;
364 adobe.fRX = 0.64f;
365 adobe.fRY = 0.33f;
366 adobe.fGX = 0.21f;
367 adobe.fGY = 0.71f;
368 adobe.fBX = 0.15f;
369 adobe.fBY = 0.06f;
370 adobe.fWX = 0.3127f;
371 adobe.fWY = 0.3290f;
372 SkMatrix44 adobeToXYZ(SkMatrix44::kUninitialized_Constructor);
373 result = adobe.toXYZD50(&adobeToXYZ);
374 REPORTER_ASSERT(r, result);
375
376 SkColorSpaceTransferFn fn;
377 fn.fA = 1.0f;
378 fn.fB = fn.fC = fn.fD = fn.fE = fn.fF = 0.0f;
379 fn.fG = 2.2f;
380 space = SkColorSpace::MakeRGB(fn, adobeToXYZ);
381 REPORTER_ASSERT(r, SkColorSpace_Base::MakeNamed(SkColorSpace_Base::kAdobeRGB_Named) == space);
382
383 // ProPhoto (D50)
384 SkColorSpacePrimaries proPhoto;
385 proPhoto.fRX = 0.7347f;
386 proPhoto.fRY = 0.2653f;
387 proPhoto.fGX = 0.1596f;
388 proPhoto.fGY = 0.8404f;
389 proPhoto.fBX = 0.0366f;
390 proPhoto.fBY = 0.0001f;
391 proPhoto.fWX = 0.34567f;
392 proPhoto.fWY = 0.35850f;
393 SkMatrix44 proToXYZ(SkMatrix44::kUninitialized_Constructor);
394 proToXYZ.set3x3(0.7976749f, 0.2880402f, 0.0000000f,
395 0.1351917f, 0.7118741f, 0.0000000f,
396 0.0313534f, 0.0000857f, 0.8252100f);
397 check_primaries(r, proPhoto, proToXYZ);
398
399 // NTSC (C)
400 SkColorSpacePrimaries ntsc;
401 ntsc.fRX = 0.67f;
402 ntsc.fRY = 0.33f;
403 ntsc.fGX = 0.21f;
404 ntsc.fGY = 0.71f;
405 ntsc.fBX = 0.14f;
406 ntsc.fBY = 0.08f;
407 ntsc.fWX = 0.31006f;
408 ntsc.fWY = 0.31616f;
409 SkMatrix44 ntscToXYZ(SkMatrix44::kUninitialized_Constructor);
410 ntscToXYZ.set3x3(0.6343706f, 0.3109496f, -0.0011817f,
411 0.1852204f, 0.5915984f, 0.0555518f,
412 0.1446290f, 0.0974520f, 0.7708399f);
413 check_primaries(r, ntsc, ntscToXYZ);
414
415 // DCI P3 (D65)
416 SkColorSpacePrimaries p3;
417 p3.fRX = 0.680f;
418 p3.fRY = 0.320f;
419 p3.fGX = 0.265f;
420 p3.fGY = 0.690f;
421 p3.fBX = 0.150f;
422 p3.fBY = 0.060f;
423 p3.fWX = 0.3127f;
424 p3.fWY = 0.3290f;
425 space = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
426 SkColorSpace::kDCIP3_D65_Gamut);
427 SkMatrix44 reference(SkMatrix44::kUninitialized_Constructor);
428 SkAssertResult(space->toXYZD50(&reference));
429 check_primaries(r, p3, reference);
430
431 // Rec 2020 (D65)
432 SkColorSpacePrimaries rec2020;
433 rec2020.fRX = 0.708f;
434 rec2020.fRY = 0.292f;
435 rec2020.fGX = 0.170f;
436 rec2020.fGY = 0.797f;
437 rec2020.fBX = 0.131f;
438 rec2020.fBY = 0.046f;
439 rec2020.fWX = 0.3127f;
440 rec2020.fWY = 0.3290f;
441 space = SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
442 SkColorSpace::kRec2020_Gamut);
443 SkAssertResult(space->toXYZD50(&reference));
444 check_primaries(r, rec2020, reference);
445 }
446
DEF_TEST(ColorSpace_InvalidICC,r)447 DEF_TEST(ColorSpace_InvalidICC, r) {
448 // This color space has a matrix that is not D50.
449 sk_sp<SkData> data = GetResourceAsData("icc_profiles/SM2333SW.icc");
450 if (!data) {
451 return;
452 }
453 sk_sp<SkColorSpace> cs = SkColorSpace::MakeICC(data->data(), data->size());
454 REPORTER_ASSERT(r, !cs);
455
456 // The color space has a color lut with only one entry in each dimension.
457 data = GetResourceAsData("icc_profiles/invalid_color_lut.icc");
458 if (!data) {
459 return;
460 }
461
462 cs = SkColorSpace::MakeICC(data->data(), data->size());
463 REPORTER_ASSERT(r, !cs);
464 }
465
DEF_TEST(ColorSpace_MatrixHash,r)466 DEF_TEST(ColorSpace_MatrixHash, r) {
467 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
468
469 SkColorSpaceTransferFn fn;
470 fn.fA = 1.0f;
471 fn.fB = 0.0f;
472 fn.fC = 0.0f;
473 fn.fD = 0.0f;
474 fn.fE = 0.0f;
475 fn.fF = 0.0f;
476 fn.fG = 3.0f;
477
478 SkMatrix44 srgbMat(SkMatrix44::kUninitialized_Constructor);
479 srgbMat.set3x3RowMajorf(gSRGB_toXYZD50);
480 sk_sp<SkColorSpace> strange = SkColorSpace::MakeRGB(fn, srgbMat);
481
482 REPORTER_ASSERT(r, *as_CSB(srgb)->toXYZD50() == *as_CSB(strange)->toXYZD50());
483 REPORTER_ASSERT(r, as_CSB(srgb)->toXYZD50Hash() == as_CSB(strange)->toXYZD50Hash());
484 }
485
DEF_TEST(ColorSpace_IsSRGB,r)486 DEF_TEST(ColorSpace_IsSRGB, r) {
487 sk_sp<SkColorSpace> srgb0 = SkColorSpace::MakeSRGB();
488
489 SkColorSpaceTransferFn fn;
490 fn.fA = 1.0f;
491 fn.fB = 0.0f;
492 fn.fC = 0.0f;
493 fn.fD = 0.0f;
494 fn.fE = 0.0f;
495 fn.fF = 0.0f;
496 fn.fG = 2.2f;
497 sk_sp<SkColorSpace> twoDotTwo = SkColorSpace::MakeRGB(fn, SkColorSpace::kSRGB_Gamut);
498
499 REPORTER_ASSERT(r, srgb0->isSRGB());
500 REPORTER_ASSERT(r, !twoDotTwo->isSRGB());
501 }
502