OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2016 Google Inc. | 2 * Copyright 2016 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkColorPriv.h" | 8 #include "SkColorPriv.h" |
9 #include "SkColorSpace_Base.h" | 9 #include "SkColorSpace_Base.h" |
10 #include "SkColorSpacePriv.h" | 10 #include "SkColorSpacePriv.h" |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
131 v = v * 255.0f; | 131 v = v * 255.0f; |
132 if (v >= 254.5f) { | 132 if (v >= 254.5f) { |
133 return 255; | 133 return 255; |
134 } else if (v >= 0.5f) { | 134 } else if (v >= 0.5f) { |
135 return (uint8_t) (v + 0.5f); | 135 return (uint8_t) (v + 0.5f); |
136 } else { | 136 } else { |
137 return 0; | 137 return 0; |
138 } | 138 } |
139 } | 139 } |
140 | 140 |
141 static const int kDstGammaTableSize = | 141 static const int kDstGammaTableSize = SkColorSpaceXform_Base::kDstGammaTableSize
; |
142 SkColorSpaceXform_Base<kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpac
eMatch> | |
143 ::kDstGammaTableSize; | |
144 | 142 |
145 static void build_table_linear_to_gamma(uint8_t* outTable, float exponent) { | 143 static void build_table_linear_to_gamma(uint8_t* outTable, float exponent) { |
146 float toGammaExp = 1.0f / exponent; | 144 float toGammaExp = 1.0f / exponent; |
147 | 145 |
148 for (int i = 0; i < kDstGammaTableSize; i++) { | 146 for (int i = 0; i < kDstGammaTableSize; i++) { |
149 float x = ((float) i) * (1.0f / ((float) (kDstGammaTableSize - 1))); | 147 float x = ((float) i) * (1.0f / ((float) (kDstGammaTableSize - 1))); |
150 outTable[i] = clamp_normalized_float_to_byte(powf(x, toGammaExp)); | 148 outTable[i] = clamp_normalized_float_to_byte(powf(x, toGammaExp)); |
151 } | 149 } |
152 } | 150 } |
153 | 151 |
(...skipping 95 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
249 nullptr, | 247 nullptr, |
250 nullptr, | 248 nullptr, |
251 &build_table_linear_to_gamma, | 249 &build_table_linear_to_gamma, |
252 &build_table_linear_to_gamma, | 250 &build_table_linear_to_gamma, |
253 &build_table_linear_to_gamma, | 251 &build_table_linear_to_gamma, |
254 }; | 252 }; |
255 | 253 |
256 // Build tables to transform src gamma to linear. | 254 // Build tables to transform src gamma to linear. |
257 template <typename T> | 255 template <typename T> |
258 static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage,
int gammaTableSize, | 256 static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage,
int gammaTableSize, |
259 SkColorSpace* space, const GammaFns<T>& fns, bool
gammasAreMatching) | 257 const SkColorSpace* space, const GammaFns<T>& fns
, |
| 258 bool gammasAreMatching) |
260 { | 259 { |
261 switch (as_CSB(space)->gammaNamed()) { | 260 switch (as_CSB(space)->gammaNamed()) { |
262 case kSRGB_SkGammaNamed: | 261 case kSRGB_SkGammaNamed: |
263 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRG
BTable; | 262 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRG
BTable; |
264 break; | 263 break; |
265 case k2Dot2Curve_SkGammaNamed: | 264 case k2Dot2Curve_SkGammaNamed: |
266 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Do
t2Table; | 265 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Do
t2Table; |
267 break; | 266 break; |
268 case kLinear_SkGammaNamed: | 267 case kLinear_SkGammaNamed: |
269 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = nullptr; | 268 outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = nullptr; |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
319 build_table(0); | 318 build_table(0); |
320 build_table(1); | 319 build_table(1); |
321 build_table(2); | 320 build_table(2); |
322 } | 321 } |
323 | 322 |
324 break; | 323 break; |
325 } | 324 } |
326 } | 325 } |
327 } | 326 } |
328 | 327 |
| 328 void SkColorSpaceXform_Base::BuildDstGammaTables(const uint8_t* dstGammaTables[3
], |
| 329 uint8_t* dstStorage, const SkCo
lorSpace* space, |
| 330 bool gammasAreMatching) { |
| 331 build_gamma_tables(dstGammaTables, dstStorage, kDstGammaTableSize, space, kF
romLinear, |
| 332 gammasAreMatching); |
| 333 } |
| 334 |
329 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 335 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
330 | 336 |
331 static inline bool is_almost_identity(const SkMatrix44& srcToDst) { | 337 static inline bool is_almost_identity(const SkMatrix44& srcToDst) { |
332 for (int i = 0; i < 4; i++) { | 338 for (int i = 0; i < 4; i++) { |
333 for (int j = 0; j < 4; j++) { | 339 for (int j = 0; j < 4; j++) { |
334 float expected = (i == j) ? 1.0f : 0.0f; | 340 float expected = (i == j) ? 1.0f : 0.0f; |
335 if (!color_space_almost_equal(srcToDst.getFloat(i,j), expected)) { | 341 if (!color_space_almost_equal(srcToDst.getFloat(i,j), expected)) { |
336 return false; | 342 return false; |
337 } | 343 } |
338 } | 344 } |
(...skipping 22 matching lines...) Expand all Loading... |
361 srcToDst.setIdentity(); | 367 srcToDst.setIdentity(); |
362 csm = kGamut_ColorSpaceMatch; | 368 csm = kGamut_ColorSpaceMatch; |
363 } | 369 } |
364 } | 370 } |
365 | 371 |
366 switch (csm) { | 372 switch (csm) { |
367 case kNone_ColorSpaceMatch: | 373 case kNone_ColorSpaceMatch: |
368 switch (as_CSB(dstSpace)->gammaNamed()) { | 374 switch (as_CSB(dstSpace)->gammaNamed()) { |
369 case kSRGB_SkGammaNamed: | 375 case kSRGB_SkGammaNamed: |
370 if (srcSpace->gammaIsLinear()) { | 376 if (srcSpace->gammaIsLinear()) { |
371 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 377 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
372 <kLinear_SrcGamma, kSRGB_DstGamma, kNone_ColorSp
aceMatch> | 378 <kLinear_SrcGamma, kSRGB_DstGamma, kNone_ColorSp
aceMatch> |
373 (srcSpace, srcToDst, dstSpace)); | 379 (srcSpace, srcToDst, dstSpace)); |
374 } else { | 380 } else { |
375 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 381 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
376 <kTable_SrcGamma, kSRGB_DstGamma, kNone_ColorSpa
ceMatch> | 382 <kTable_SrcGamma, kSRGB_DstGamma, kNone_ColorSpa
ceMatch> |
377 (srcSpace, srcToDst, dstSpace)); | 383 (srcSpace, srcToDst, dstSpace)); |
378 } | 384 } |
379 case k2Dot2Curve_SkGammaNamed: | 385 case k2Dot2Curve_SkGammaNamed: |
380 if (srcSpace->gammaIsLinear()) { | 386 if (srcSpace->gammaIsLinear()) { |
381 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 387 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
382 <kLinear_SrcGamma, k2Dot2_DstGamma, kNone_ColorS
paceMatch> | 388 <kLinear_SrcGamma, k2Dot2_DstGamma, kNone_ColorS
paceMatch> |
383 (srcSpace, srcToDst, dstSpace)); | 389 (srcSpace, srcToDst, dstSpace)); |
384 } else { | 390 } else { |
385 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 391 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
386 <kTable_SrcGamma, k2Dot2_DstGamma, kNone_ColorSp
aceMatch> | 392 <kTable_SrcGamma, k2Dot2_DstGamma, kNone_ColorSp
aceMatch> |
387 (srcSpace, srcToDst, dstSpace)); | 393 (srcSpace, srcToDst, dstSpace)); |
388 } | 394 } |
389 case kLinear_SkGammaNamed: | 395 case kLinear_SkGammaNamed: |
390 if (srcSpace->gammaIsLinear()) { | 396 if (srcSpace->gammaIsLinear()) { |
391 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 397 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
392 <kLinear_SrcGamma, kLinear_DstGamma, kNone_Color
SpaceMatch> | 398 <kLinear_SrcGamma, kLinear_DstGamma, kNone_Color
SpaceMatch> |
393 (srcSpace, srcToDst, dstSpace)); | 399 (srcSpace, srcToDst, dstSpace)); |
394 } else { | 400 } else { |
395 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 401 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
396 <kTable_SrcGamma, kLinear_DstGamma, kNone_ColorS
paceMatch> | 402 <kTable_SrcGamma, kLinear_DstGamma, kNone_ColorS
paceMatch> |
397 (srcSpace, srcToDst, dstSpace)); | 403 (srcSpace, srcToDst, dstSpace)); |
398 } | 404 } |
399 default: | 405 default: |
400 if (srcSpace->gammaIsLinear()) { | 406 if (srcSpace->gammaIsLinear()) { |
401 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 407 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
402 <kLinear_SrcGamma, kTable_DstGamma, kNone_ColorS
paceMatch> | 408 <kLinear_SrcGamma, kTable_DstGamma, kNone_ColorS
paceMatch> |
403 (srcSpace, srcToDst, dstSpace)); | 409 (srcSpace, srcToDst, dstSpace)); |
404 } else { | 410 } else { |
405 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 411 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
406 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSp
aceMatch> | 412 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSp
aceMatch> |
407 (srcSpace, srcToDst, dstSpace)); | 413 (srcSpace, srcToDst, dstSpace)); |
408 } | 414 } |
409 } | 415 } |
410 case kGamut_ColorSpaceMatch: | 416 case kGamut_ColorSpaceMatch: |
411 switch (as_CSB(dstSpace)->gammaNamed()) { | 417 switch (as_CSB(dstSpace)->gammaNamed()) { |
412 case kSRGB_SkGammaNamed: | 418 case kSRGB_SkGammaNamed: |
413 if (srcSpace->gammaIsLinear()) { | 419 if (srcSpace->gammaIsLinear()) { |
414 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 420 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
415 <kLinear_SrcGamma, kSRGB_DstGamma, kGamut_ColorS
paceMatch> | 421 <kLinear_SrcGamma, kSRGB_DstGamma, kGamut_ColorS
paceMatch> |
416 (srcSpace, srcToDst, dstSpace)); | 422 (srcSpace, srcToDst, dstSpace)); |
417 } else { | 423 } else { |
418 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 424 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
419 <kTable_SrcGamma, kSRGB_DstGamma, kGamut_ColorSp
aceMatch> | 425 <kTable_SrcGamma, kSRGB_DstGamma, kGamut_ColorSp
aceMatch> |
420 (srcSpace, srcToDst, dstSpace)); | 426 (srcSpace, srcToDst, dstSpace)); |
421 } | 427 } |
422 case k2Dot2Curve_SkGammaNamed: | 428 case k2Dot2Curve_SkGammaNamed: |
423 if (srcSpace->gammaIsLinear()) { | 429 if (srcSpace->gammaIsLinear()) { |
424 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 430 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
425 <kLinear_SrcGamma, k2Dot2_DstGamma, kGamut_Color
SpaceMatch> | 431 <kLinear_SrcGamma, k2Dot2_DstGamma, kGamut_Color
SpaceMatch> |
426 (srcSpace, srcToDst, dstSpace)); | 432 (srcSpace, srcToDst, dstSpace)); |
427 } else { | 433 } else { |
428 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 434 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
429 <kTable_SrcGamma, k2Dot2_DstGamma, kGamut_ColorS
paceMatch> | 435 <kTable_SrcGamma, k2Dot2_DstGamma, kGamut_ColorS
paceMatch> |
430 (srcSpace, srcToDst, dstSpace)); | 436 (srcSpace, srcToDst, dstSpace)); |
431 } | 437 } |
432 case kLinear_SkGammaNamed: | 438 case kLinear_SkGammaNamed: |
433 if (srcSpace->gammaIsLinear()) { | 439 if (srcSpace->gammaIsLinear()) { |
434 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 440 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
435 <kLinear_SrcGamma, kLinear_DstGamma, kGamut_Colo
rSpaceMatch> | 441 <kLinear_SrcGamma, kLinear_DstGamma, kGamut_Colo
rSpaceMatch> |
436 (srcSpace, srcToDst, dstSpace)); | 442 (srcSpace, srcToDst, dstSpace)); |
437 } else { | 443 } else { |
438 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 444 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
439 <kTable_SrcGamma, kLinear_DstGamma, kGamut_Color
SpaceMatch> | 445 <kTable_SrcGamma, kLinear_DstGamma, kGamut_Color
SpaceMatch> |
440 (srcSpace, srcToDst, dstSpace)); | 446 (srcSpace, srcToDst, dstSpace)); |
441 } | 447 } |
442 default: | 448 default: |
443 if (srcSpace->gammaIsLinear()) { | 449 if (srcSpace->gammaIsLinear()) { |
444 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 450 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
445 <kLinear_SrcGamma, kTable_DstGamma, kGamut_Color
SpaceMatch> | 451 <kLinear_SrcGamma, kTable_DstGamma, kGamut_Color
SpaceMatch> |
446 (srcSpace, srcToDst, dstSpace)); | 452 (srcSpace, srcToDst, dstSpace)); |
447 } else { | 453 } else { |
448 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_Base | 454 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpa
ceXform_XYZ |
449 <kTable_SrcGamma, kTable_DstGamma, kGamut_ColorS
paceMatch> | 455 <kTable_SrcGamma, kTable_DstGamma, kGamut_ColorS
paceMatch> |
450 (srcSpace, srcToDst, dstSpace)); | 456 (srcSpace, srcToDst, dstSpace)); |
451 } | 457 } |
452 } | 458 } |
453 case kFull_ColorSpaceMatch: | 459 case kFull_ColorSpaceMatch: |
454 switch (as_CSB(dstSpace)->gammaNamed()) { | 460 switch (as_CSB(dstSpace)->gammaNamed()) { |
455 case kSRGB_SkGammaNamed: | 461 case kSRGB_SkGammaNamed: |
456 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_Base | 462 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_XYZ |
457 <kTable_SrcGamma, kSRGB_DstGamma, kFull_ColorSpaceMa
tch> | 463 <kTable_SrcGamma, kSRGB_DstGamma, kFull_ColorSpaceMa
tch> |
458 (srcSpace, srcToDst, dstSpace)); | 464 (srcSpace, srcToDst, dstSpace)); |
459 case k2Dot2Curve_SkGammaNamed: | 465 case k2Dot2Curve_SkGammaNamed: |
460 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_Base | 466 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_XYZ |
461 <kTable_SrcGamma, k2Dot2_DstGamma, kFull_ColorSpaceM
atch> | 467 <kTable_SrcGamma, k2Dot2_DstGamma, kFull_ColorSpaceM
atch> |
462 (srcSpace, srcToDst, dstSpace)); | 468 (srcSpace, srcToDst, dstSpace)); |
463 case kLinear_SkGammaNamed: | 469 case kLinear_SkGammaNamed: |
464 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_Base | 470 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_XYZ |
465 <kLinear_SrcGamma, kLinear_DstGamma, kFull_ColorSpac
eMatch> | 471 <kLinear_SrcGamma, kLinear_DstGamma, kFull_ColorSpac
eMatch> |
466 (srcSpace, srcToDst, dstSpace)); | 472 (srcSpace, srcToDst, dstSpace)); |
467 default: | 473 default: |
468 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_Base | 474 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXf
orm_XYZ |
469 <kTable_SrcGamma, kTable_DstGamma, kFull_ColorSpaceM
atch> | 475 <kTable_SrcGamma, kTable_DstGamma, kFull_ColorSpaceM
atch> |
470 (srcSpace, srcToDst, dstSpace)); | 476 (srcSpace, srcToDst, dstSpace)); |
471 } | 477 } |
472 default: | 478 default: |
473 SkASSERT(false); | 479 SkASSERT(false); |
474 return nullptr; | 480 return nullptr; |
475 } | 481 } |
476 } | 482 } |
477 | 483 |
478 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 484 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
(...skipping 757 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1236 (gammas->data(0) == gammas->data(2)); | 1242 (gammas->data(0) == gammas->data(2)); |
1237 | 1243 |
1238 // It's likely that each component will have the same gamma. In thi
s case, | 1244 // It's likely that each component will have the same gamma. In thi
s case, |
1239 // we only need to build one table. | 1245 // we only need to build one table. |
1240 return gammasAreMatching ? 1 : 3; | 1246 return gammasAreMatching ? 1 : 3; |
1241 } | 1247 } |
1242 } | 1248 } |
1243 } | 1249 } |
1244 | 1250 |
1245 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM> | 1251 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM> |
1246 SkColorSpaceXform_Base<kSrc, kDst, kCSM> | 1252 SkColorSpaceXform_XYZ<kSrc, kDst, kCSM> |
1247 ::SkColorSpaceXform_Base(SkColorSpace* srcSpace, const SkMatrix44& srcToDst, SkC
olorSpace* dstSpace) | 1253 ::SkColorSpaceXform_XYZ(SkColorSpace* srcSpace, const SkMatrix44& srcToDst, SkCo
lorSpace* dstSpace) |
1248 : fColorLUT(sk_ref_sp((SkColorLookUpTable*) as_CSB(srcSpace)->colorLUT())) | 1254 : fColorLUT(sk_ref_sp((SkColorLookUpTable*) as_CSB(srcSpace)->colorLUT())) |
1249 { | 1255 { |
1250 srcToDst.asColMajorf(fSrcToDst); | 1256 srcToDst.asColMajorf(fSrcToDst); |
1251 | 1257 |
1252 const int numSrcTables = num_tables(srcSpace); | 1258 const int numSrcTables = num_tables(srcSpace); |
| 1259 const size_t srcEntries = numSrcTables * 256; |
| 1260 const bool srcGammasAreMatching = (1 >= numSrcTables); |
| 1261 fSrcStorage.reset(srcEntries); |
| 1262 build_gamma_tables(fSrcGammaTables, fSrcStorage.get(), 256, srcSpace, kToLin
ear, |
| 1263 srcGammasAreMatching); |
| 1264 |
1253 const int numDstTables = num_tables(dstSpace); | 1265 const int numDstTables = num_tables(dstSpace); |
1254 const size_t srcTableBytes = numSrcTables * 256 * sizeof(float); | 1266 as_CSB(dstSpace)->toDstGammaTables(fDstGammaTables, &fDstStorage, numDstTabl
es); |
1255 const size_t dstTableBytes = numDstTables * kDstGammaTableSize * sizeof(uint
8_t); | |
1256 fStorage.reset(srcTableBytes + dstTableBytes); | |
1257 float* srcStorage = (float*) fStorage.get(); | |
1258 uint8_t* dstStorage = SkTAddOffset<uint8_t>(fStorage.get(), srcTableBytes); | |
1259 | |
1260 const bool srcGammasAreMatching = (1 >= numSrcTables); | |
1261 const bool dstGammasAreMatching = (1 >= numDstTables); | |
1262 build_gamma_tables(fSrcGammaTables, srcStorage, 256, srcSpace, kToLinear, sr
cGammasAreMatching); | |
1263 build_gamma_tables(fDstGammaTables, dstStorage, kDstGammaTableSize, dstSpace
, kFromLinear, | |
1264 dstGammasAreMatching); | |
1265 } | 1267 } |
1266 | 1268 |
1267 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 1269 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
1268 | 1270 |
1269 template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM> | 1271 template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM> |
1270 static inline bool apply_set_alpha(void* dst, const void* src, int len, SkAlphaT
ype alphaType, | 1272 static inline bool apply_set_alpha(void* dst, const void* src, int len, SkAlphaT
ype alphaType, |
1271 const float* const srcTables[3], const float
matrix[16], | 1273 const float* const srcTables[3], const float
matrix[16], |
1272 const uint8_t* const dstTables[3]) { | 1274 const uint8_t* const dstTables[3]) { |
1273 switch (alphaType) { | 1275 switch (alphaType) { |
1274 case kOpaque_SkAlphaType: | 1276 case kOpaque_SkAlphaType: |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1311 case kTable_SrcGamma: | 1313 case kTable_SrcGamma: |
1312 return apply_set_alpha<kBGRA_8888_Table_SrcFormat, kDst, kCS
M> | 1314 return apply_set_alpha<kBGRA_8888_Table_SrcFormat, kDst, kCS
M> |
1313 (dst, src, len, alphaType, srcTables, matrix, dstTab
les); | 1315 (dst, src, len, alphaType, srcTables, matrix, dstTab
les); |
1314 } | 1316 } |
1315 default: | 1317 default: |
1316 return false; | 1318 return false; |
1317 } | 1319 } |
1318 } | 1320 } |
1319 | 1321 |
1320 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM> | 1322 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM> |
1321 bool SkColorSpaceXform_Base<kSrc, kDst, kCSM> | 1323 bool SkColorSpaceXform_XYZ<kSrc, kDst, kCSM> |
1322 ::onApply(ColorFormat dstColorFormat, void* dst, ColorFormat srcColorFormat, con
st void* src, | 1324 ::onApply(ColorFormat dstColorFormat, void* dst, ColorFormat srcColorFormat, con
st void* src, |
1323 int len, SkAlphaType alphaType) const | 1325 int len, SkAlphaType alphaType) const |
1324 { | 1326 { |
1325 if (kFull_ColorSpaceMatch == kCSM) { | 1327 if (kFull_ColorSpaceMatch == kCSM) { |
1326 switch (alphaType) { | 1328 switch (alphaType) { |
1327 case kPremul_SkAlphaType: | 1329 case kPremul_SkAlphaType: |
1328 // We can't skip the xform since we need to perform a premultipl
y in the | 1330 // We can't skip the xform since we need to perform a premultipl
y in the |
1329 // linear space. | 1331 // linear space. |
1330 break; | 1332 break; |
1331 default: | 1333 default: |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1414 (dst, src, len, alphaType, fSrcGammaTables, fSrcToDs
t, nullptr, | 1416 (dst, src, len, alphaType, fSrcGammaTables, fSrcToDs
t, nullptr, |
1415 srcColorFormat); | 1417 srcColorFormat); |
1416 default: | 1418 default: |
1417 return false; | 1419 return false; |
1418 } | 1420 } |
1419 default: | 1421 default: |
1420 return false; | 1422 return false; |
1421 } | 1423 } |
1422 } | 1424 } |
1423 | 1425 |
| 1426 bool SkColorSpaceXform::apply(ColorFormat dstColorFormat, void* dst, ColorFormat
srcColorFormat, |
| 1427 const void* src, int len, SkAlphaType alphaType) c
onst { |
| 1428 return ((SkColorSpaceXform_Base*) this)->onApply(dstColorFormat, dst, srcCol
orFormat, src, len, |
| 1429 alphaType); |
| 1430 } |
| 1431 |
1424 ////////////////////////////////////////////////////////////////////////////////
/////////////////// | 1432 ////////////////////////////////////////////////////////////////////////////////
/////////////////// |
1425 | 1433 |
1426 std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(SkColorSpace* space) { | 1434 std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(SkColorSpace* space) { |
1427 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base | 1435 return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_XYZ |
1428 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch> | 1436 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch> |
1429 (space, SkMatrix::I(), space)); | 1437 (space, SkMatrix::I(), space)); |
1430 } | 1438 } |
OLD | NEW |