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 18 static bool almost_equal(float a, float b) { 19 return SkTAbs(a - b) < 0.001f; 20 } 21 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 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 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 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 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 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 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 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 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 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 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 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 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 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 447 DEF_TEST(ColorSpace_InvalidICC, r) { 448 // This color space has a matrix that is not D50. 449 sk_sp<SkData> data = SkData::MakeFromFileName( 450 GetResourcePath("icc_profiles/SM2333SW.icc").c_str()); 451 sk_sp<SkColorSpace> cs = SkColorSpace::MakeICC(data->data(), data->size()); 452 REPORTER_ASSERT(r, !cs); 453 } 454 455 DEF_TEST(ColorSpace_MatrixHash, r) { 456 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB(); 457 458 SkColorSpaceTransferFn fn; 459 fn.fA = 1.0f; 460 fn.fB = 0.0f; 461 fn.fC = 0.0f; 462 fn.fD = 0.0f; 463 fn.fE = 0.0f; 464 fn.fF = 0.0f; 465 fn.fG = 3.0f; 466 467 SkMatrix44 srgbMat(SkMatrix44::kUninitialized_Constructor); 468 srgbMat.set3x3RowMajorf(gSRGB_toXYZD50); 469 sk_sp<SkColorSpace> strange = SkColorSpace::MakeRGB(fn, srgbMat); 470 471 REPORTER_ASSERT(r, *as_CSB(srgb)->toXYZD50() == *as_CSB(strange)->toXYZD50()); 472 REPORTER_ASSERT(r, as_CSB(srgb)->toXYZD50Hash() == as_CSB(strange)->toXYZD50Hash()); 473 } 474 475 DEF_TEST(ColorSpace_IsSRGB, r) { 476 sk_sp<SkColorSpace> srgb0 = SkColorSpace::MakeSRGB(); 477 478 SkColorSpaceTransferFn fn; 479 fn.fA = 1.0f; 480 fn.fB = 0.0f; 481 fn.fC = 0.0f; 482 fn.fD = 0.0f; 483 fn.fE = 0.0f; 484 fn.fF = 0.0f; 485 fn.fG = 2.2f; 486 sk_sp<SkColorSpace> twoDotTwo = SkColorSpace::MakeRGB(fn, SkColorSpace::kSRGB_Gamut); 487 488 REPORTER_ASSERT(r, srgb0->isSRGB()); 489 REPORTER_ASSERT(r, !twoDotTwo->isSRGB()); 490 } 491