Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(75)

Side by Side Diff: src/core/SkColorSpaceXform.cpp

Issue 2413383002: Cache dst LUTs in SkColorSpaceXform (Closed)
Patch Set: Ref the storage on SkColorSpaceXform Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/core/SkColorSpace.cpp ('k') | src/core/SkColorSpaceXform_Base.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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 }
OLDNEW
« no previous file with comments | « src/core/SkColorSpace.cpp ('k') | src/core/SkColorSpaceXform_Base.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698