1 /* 2 * Copyright 2006 The Android Open Source Project 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 "SkGradientShaderPriv.h" 9 #include "SkLinearGradient.h" 10 #include "SkRadialGradient.h" 11 #include "SkTwoPointRadialGradient.h" 12 #include "SkTwoPointConicalGradient.h" 13 #include "SkSweepGradient.h" 14 15 void SkGradientShaderBase::Descriptor::flatten(SkWriteBuffer& buffer) const { 16 buffer.writeColorArray(fColors, fCount); 17 if (fPos) { 18 buffer.writeBool(true); 19 buffer.writeScalarArray(fPos, fCount); 20 } else { 21 buffer.writeBool(false); 22 } 23 buffer.write32(fTileMode); 24 buffer.write32(fGradFlags); 25 if (fLocalMatrix) { 26 buffer.writeBool(true); 27 buffer.writeMatrix(*fLocalMatrix); 28 } else { 29 buffer.writeBool(false); 30 } 31 } 32 33 bool SkGradientShaderBase::DescriptorScope::unflatten(SkReadBuffer& buffer) { 34 fCount = buffer.getArrayCount(); 35 if (fCount > kStorageCount) { 36 size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar)) * fCount; 37 fDynamicStorage.reset(allocSize); 38 fColors = (SkColor*)fDynamicStorage.get(); 39 fPos = (SkScalar*)(fColors + fCount); 40 } else { 41 fColors = fColorStorage; 42 fPos = fPosStorage; 43 } 44 45 if (!buffer.readColorArray(const_cast<SkColor*>(fColors), fCount)) { 46 return false; 47 } 48 if (buffer.readBool()) { 49 if (!buffer.readScalarArray(const_cast<SkScalar*>(fPos), fCount)) { 50 return false; 51 } 52 } else { 53 fPos = NULL; 54 } 55 56 fTileMode = (SkShader::TileMode)buffer.read32(); 57 fGradFlags = buffer.read32(); 58 59 if (buffer.readBool()) { 60 fLocalMatrix = &fLocalMatrixStorage; 61 buffer.readMatrix(&fLocalMatrixStorage); 62 } else { 63 fLocalMatrix = NULL; 64 } 65 return buffer.isValid(); 66 } 67 68 //////////////////////////////////////////////////////////////////////////////////////////// 69 70 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc) 71 : INHERITED(desc.fLocalMatrix) 72 { 73 SkASSERT(desc.fCount > 1); 74 75 fGradFlags = SkToU8(desc.fGradFlags); 76 77 SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount); 78 SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs)); 79 fTileMode = desc.fTileMode; 80 fTileProc = gTileProcs[desc.fTileMode]; 81 82 /* Note: we let the caller skip the first and/or last position. 83 i.e. pos[0] = 0.3, pos[1] = 0.7 84 In these cases, we insert dummy entries to ensure that the final data 85 will be bracketed by [0, 1]. 86 i.e. our_pos[0] = 0, our_pos[1] = 0.3, our_pos[2] = 0.7, our_pos[3] = 1 87 88 Thus colorCount (the caller's value, and fColorCount (our value) may 89 differ by up to 2. In the above example: 90 colorCount = 2 91 fColorCount = 4 92 */ 93 fColorCount = desc.fCount; 94 // check if we need to add in dummy start and/or end position/colors 95 bool dummyFirst = false; 96 bool dummyLast = false; 97 if (desc.fPos) { 98 dummyFirst = desc.fPos[0] != 0; 99 dummyLast = desc.fPos[desc.fCount - 1] != SK_Scalar1; 100 fColorCount += dummyFirst + dummyLast; 101 } 102 103 if (fColorCount > kColorStorageCount) { 104 size_t size = sizeof(SkColor) + sizeof(Rec); 105 if (desc.fPos) { 106 size += sizeof(SkScalar); 107 } 108 fOrigColors = reinterpret_cast<SkColor*>( 109 sk_malloc_throw(size * fColorCount)); 110 } 111 else { 112 fOrigColors = fStorage; 113 } 114 115 // Now copy over the colors, adding the dummies as needed 116 { 117 SkColor* origColors = fOrigColors; 118 if (dummyFirst) { 119 *origColors++ = desc.fColors[0]; 120 } 121 memcpy(origColors, desc.fColors, desc.fCount * sizeof(SkColor)); 122 if (dummyLast) { 123 origColors += desc.fCount; 124 *origColors = desc.fColors[desc.fCount - 1]; 125 } 126 } 127 128 if (desc.fPos && fColorCount) { 129 fOrigPos = (SkScalar*)(fOrigColors + fColorCount); 130 fRecs = (Rec*)(fOrigPos + fColorCount); 131 } else { 132 fOrigPos = NULL; 133 fRecs = (Rec*)(fOrigColors + fColorCount); 134 } 135 136 if (fColorCount > 2) { 137 Rec* recs = fRecs; 138 recs->fPos = 0; 139 // recs->fScale = 0; // unused; 140 recs += 1; 141 if (desc.fPos) { 142 SkScalar* origPosPtr = fOrigPos; 143 *origPosPtr++ = 0; 144 145 /* We need to convert the user's array of relative positions into 146 fixed-point positions and scale factors. We need these results 147 to be strictly monotonic (no two values equal or out of order). 148 Hence this complex loop that just jams a zero for the scale 149 value if it sees a segment out of order, and it assures that 150 we start at 0 and end at 1.0 151 */ 152 SkScalar prev = 0; 153 int startIndex = dummyFirst ? 0 : 1; 154 int count = desc.fCount + dummyLast; 155 for (int i = startIndex; i < count; i++) { 156 // force the last value to be 1.0 157 SkScalar curr; 158 if (i == desc.fCount) { // we're really at the dummyLast 159 curr = 1; 160 } else { 161 curr = SkScalarPin(desc.fPos[i], 0, 1); 162 } 163 *origPosPtr++ = curr; 164 165 recs->fPos = SkScalarToFixed(curr); 166 SkFixed diff = SkScalarToFixed(curr - prev); 167 if (diff > 0) { 168 recs->fScale = (1 << 24) / diff; 169 } else { 170 recs->fScale = 0; // ignore this segment 171 } 172 // get ready for the next value 173 prev = curr; 174 recs += 1; 175 } 176 } else { // assume even distribution 177 fOrigPos = NULL; 178 179 SkFixed dp = SK_Fixed1 / (desc.fCount - 1); 180 SkFixed p = dp; 181 SkFixed scale = (desc.fCount - 1) << 8; // (1 << 24) / dp 182 for (int i = 1; i < desc.fCount - 1; i++) { 183 recs->fPos = p; 184 recs->fScale = scale; 185 recs += 1; 186 p += dp; 187 } 188 recs->fPos = SK_Fixed1; 189 recs->fScale = scale; 190 } 191 } else if (desc.fPos) { 192 SkASSERT(2 == fColorCount); 193 fOrigPos[0] = SkScalarPin(desc.fPos[0], 0, 1); 194 fOrigPos[1] = SkScalarPin(desc.fPos[1], fOrigPos[0], 1); 195 if (0 == fOrigPos[0] && 1 == fOrigPos[1]) { 196 fOrigPos = NULL; 197 } 198 } 199 this->initCommon(); 200 } 201 202 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 203 static SkShader::TileMode unpack_mode(uint32_t packed) { 204 return (SkShader::TileMode)(packed & 0xF); 205 } 206 207 static uint32_t unpack_flags(uint32_t packed) { 208 return packed >> 4; 209 } 210 211 SkGradientShaderBase::SkGradientShaderBase(SkReadBuffer& buffer) : INHERITED(buffer) { 212 if (buffer.isVersionLT(SkReadBuffer::kNoUnitMappers_Version)) { 213 // skip the old SkUnitMapper slot 214 buffer.skipFlattenable(); 215 } 216 217 int colorCount = fColorCount = buffer.getArrayCount(); 218 if (colorCount > kColorStorageCount) { 219 size_t allocSize = (sizeof(SkColor) + sizeof(SkScalar) + sizeof(Rec)) * colorCount; 220 if (buffer.validateAvailable(allocSize)) { 221 fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(allocSize)); 222 } else { 223 fOrigColors = NULL; 224 colorCount = fColorCount = 0; 225 } 226 } else { 227 fOrigColors = fStorage; 228 } 229 buffer.readColorArray(fOrigColors, colorCount); 230 231 fOrigPos = (SkScalar*)(fOrigColors + colorCount); 232 233 { 234 uint32_t packed = buffer.readUInt(); 235 fGradFlags = SkToU8(unpack_flags(packed)); 236 fTileMode = unpack_mode(packed); 237 } 238 fTileProc = gTileProcs[fTileMode]; 239 fRecs = (Rec*)(fOrigPos + colorCount); 240 if (colorCount > 2) { 241 Rec* recs = fRecs; 242 recs[0].fPos = 0; 243 fOrigPos[0] = 0; 244 for (int i = 1; i < colorCount; i++) { 245 recs[i].fPos = buffer.readInt(); 246 recs[i].fScale = buffer.readUInt(); 247 fOrigPos[i] = SkFixedToScalar(recs[i].fPos); 248 } 249 } else { 250 fOrigPos = NULL; 251 } 252 buffer.readMatrix(&fPtsToUnit); 253 this->initCommon(); 254 } 255 #endif 256 257 SkGradientShaderBase::~SkGradientShaderBase() { 258 if (fOrigColors != fStorage) { 259 sk_free(fOrigColors); 260 } 261 } 262 263 void SkGradientShaderBase::initCommon() { 264 unsigned colorAlpha = 0xFF; 265 for (int i = 0; i < fColorCount; i++) { 266 colorAlpha &= SkColorGetA(fOrigColors[i]); 267 } 268 fColorsAreOpaque = colorAlpha == 0xFF; 269 } 270 271 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const { 272 Descriptor desc; 273 desc.fColors = fOrigColors; 274 desc.fPos = fOrigPos; 275 desc.fCount = fColorCount; 276 desc.fTileMode = fTileMode; 277 desc.fGradFlags = fGradFlags; 278 279 const SkMatrix& m = this->getLocalMatrix(); 280 desc.fLocalMatrix = m.isIdentity() ? NULL : &m; 281 desc.flatten(buffer); 282 } 283 284 SkGradientShaderBase::GpuColorType SkGradientShaderBase::getGpuColorType(SkColor colors[3]) const { 285 if (fColorCount <= 3) { 286 memcpy(colors, fOrigColors, fColorCount * sizeof(SkColor)); 287 } 288 289 if (SkShader::kClamp_TileMode == fTileMode) { 290 if (2 == fColorCount) { 291 return kTwo_GpuColorType; 292 } else if (3 == fColorCount && 293 (SkScalarAbs( 294 SkFixedToScalar(fRecs[1].fPos) - SK_ScalarHalf) < SK_Scalar1 / 1000)) { 295 return kThree_GpuColorType; 296 } 297 } 298 return kTexture_GpuColorType; 299 } 300 301 void SkGradientShaderBase::FlipGradientColors(SkColor* colorDst, Rec* recDst, 302 SkColor* colorSrc, Rec* recSrc, 303 int count) { 304 SkAutoSTArray<8, SkColor> colorsTemp(count); 305 for (int i = 0; i < count; ++i) { 306 int offset = count - i - 1; 307 colorsTemp[i] = colorSrc[offset]; 308 } 309 if (count > 2) { 310 SkAutoSTArray<8, Rec> recsTemp(count); 311 for (int i = 0; i < count; ++i) { 312 int offset = count - i - 1; 313 recsTemp[i].fPos = SK_Fixed1 - recSrc[offset].fPos; 314 recsTemp[i].fScale = recSrc[offset].fScale; 315 } 316 memcpy(recDst, recsTemp.get(), count * sizeof(Rec)); 317 } 318 memcpy(colorDst, colorsTemp.get(), count * sizeof(SkColor)); 319 } 320 321 void SkGradientShaderBase::flipGradientColors() { 322 FlipGradientColors(fOrigColors, fRecs, fOrigColors, fRecs, fColorCount); 323 } 324 325 bool SkGradientShaderBase::isOpaque() const { 326 return fColorsAreOpaque; 327 } 328 329 static unsigned rounded_divide(unsigned numer, unsigned denom) { 330 return (numer + (denom >> 1)) / denom; 331 } 332 333 bool SkGradientShaderBase::onAsLuminanceColor(SkColor* lum) const { 334 // we just compute an average color. 335 // possibly we could weight this based on the proportional width for each color 336 // assuming they are not evenly distributed in the fPos array. 337 int r = 0; 338 int g = 0; 339 int b = 0; 340 const int n = fColorCount; 341 for (int i = 0; i < n; ++i) { 342 SkColor c = fOrigColors[i]; 343 r += SkColorGetR(c); 344 g += SkColorGetG(c); 345 b += SkColorGetB(c); 346 } 347 *lum = SkColorSetRGB(rounded_divide(r, n), rounded_divide(g, n), rounded_divide(b, n)); 348 return true; 349 } 350 351 SkGradientShaderBase::GradientShaderBaseContext::GradientShaderBaseContext( 352 const SkGradientShaderBase& shader, const ContextRec& rec) 353 : INHERITED(shader, rec) 354 , fCache(shader.refCache(getPaintAlpha())) 355 { 356 const SkMatrix& inverse = this->getTotalInverse(); 357 358 fDstToIndex.setConcat(shader.fPtsToUnit, inverse); 359 360 fDstToIndexProc = fDstToIndex.getMapXYProc(); 361 fDstToIndexClass = (uint8_t)SkShader::Context::ComputeMatrixClass(fDstToIndex); 362 363 // now convert our colors in to PMColors 364 unsigned paintAlpha = this->getPaintAlpha(); 365 366 fFlags = this->INHERITED::getFlags(); 367 if (shader.fColorsAreOpaque && paintAlpha == 0xFF) { 368 fFlags |= kOpaqueAlpha_Flag; 369 } 370 // we can do span16 as long as our individual colors are opaque, 371 // regardless of the paint's alpha 372 if (shader.fColorsAreOpaque) { 373 fFlags |= kHasSpan16_Flag; 374 } 375 } 376 377 SkGradientShaderBase::GradientShaderCache::GradientShaderCache( 378 U8CPU alpha, const SkGradientShaderBase& shader) 379 : fCacheAlpha(alpha) 380 , fShader(shader) 381 , fCache16Inited(false) 382 , fCache32Inited(false) 383 { 384 // Only initialize the cache in getCache16/32. 385 fCache16 = NULL; 386 fCache32 = NULL; 387 fCache16Storage = NULL; 388 fCache32PixelRef = NULL; 389 } 390 391 SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() { 392 sk_free(fCache16Storage); 393 SkSafeUnref(fCache32PixelRef); 394 } 395 396 #define Fixed_To_Dot8(x) (((x) + 0x80) >> 8) 397 398 /** We take the original colors, not our premultiplied PMColors, since we can 399 build a 16bit table as long as the original colors are opaque, even if the 400 paint specifies a non-opaque alpha. 401 */ 402 void SkGradientShaderBase::GradientShaderCache::Build16bitCache( 403 uint16_t cache[], SkColor c0, SkColor c1, int count) { 404 SkASSERT(count > 1); 405 SkASSERT(SkColorGetA(c0) == 0xFF); 406 SkASSERT(SkColorGetA(c1) == 0xFF); 407 408 SkFixed r = SkColorGetR(c0); 409 SkFixed g = SkColorGetG(c0); 410 SkFixed b = SkColorGetB(c0); 411 412 SkFixed dr = SkIntToFixed(SkColorGetR(c1) - r) / (count - 1); 413 SkFixed dg = SkIntToFixed(SkColorGetG(c1) - g) / (count - 1); 414 SkFixed db = SkIntToFixed(SkColorGetB(c1) - b) / (count - 1); 415 416 r = SkIntToFixed(r) + 0x8000; 417 g = SkIntToFixed(g) + 0x8000; 418 b = SkIntToFixed(b) + 0x8000; 419 420 do { 421 unsigned rr = r >> 16; 422 unsigned gg = g >> 16; 423 unsigned bb = b >> 16; 424 cache[0] = SkPackRGB16(SkR32ToR16(rr), SkG32ToG16(gg), SkB32ToB16(bb)); 425 cache[kCache16Count] = SkDitherPack888ToRGB16(rr, gg, bb); 426 cache += 1; 427 r += dr; 428 g += dg; 429 b += db; 430 } while (--count != 0); 431 } 432 433 /* 434 * r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in 435 * release builds, we saw a compiler error where the 0xFF parameter in 436 * SkPackARGB32() was being totally ignored whenever it was called with 437 * a non-zero add (e.g. 0x8000). 438 * 439 * We found two work-arounds: 440 * 1. change r,g,b to unsigned (or just one of them) 441 * 2. change SkPackARGB32 to + its (a << SK_A32_SHIFT) value instead 442 * of using | 443 * 444 * We chose #1 just because it was more localized. 445 * See http://code.google.com/p/skia/issues/detail?id=1113 446 * 447 * The type SkUFixed encapsulate this need for unsigned, but logically Fixed. 448 */ 449 typedef uint32_t SkUFixed; 450 451 void SkGradientShaderBase::GradientShaderCache::Build32bitCache( 452 SkPMColor cache[], SkColor c0, SkColor c1, 453 int count, U8CPU paintAlpha, uint32_t gradFlags) { 454 SkASSERT(count > 1); 455 456 // need to apply paintAlpha to our two endpoints 457 uint32_t a0 = SkMulDiv255Round(SkColorGetA(c0), paintAlpha); 458 uint32_t a1 = SkMulDiv255Round(SkColorGetA(c1), paintAlpha); 459 460 461 const bool interpInPremul = SkToBool(gradFlags & 462 SkGradientShader::kInterpolateColorsInPremul_Flag); 463 464 uint32_t r0 = SkColorGetR(c0); 465 uint32_t g0 = SkColorGetG(c0); 466 uint32_t b0 = SkColorGetB(c0); 467 468 uint32_t r1 = SkColorGetR(c1); 469 uint32_t g1 = SkColorGetG(c1); 470 uint32_t b1 = SkColorGetB(c1); 471 472 if (interpInPremul) { 473 r0 = SkMulDiv255Round(r0, a0); 474 g0 = SkMulDiv255Round(g0, a0); 475 b0 = SkMulDiv255Round(b0, a0); 476 477 r1 = SkMulDiv255Round(r1, a1); 478 g1 = SkMulDiv255Round(g1, a1); 479 b1 = SkMulDiv255Round(b1, a1); 480 } 481 482 SkFixed da = SkIntToFixed(a1 - a0) / (count - 1); 483 SkFixed dr = SkIntToFixed(r1 - r0) / (count - 1); 484 SkFixed dg = SkIntToFixed(g1 - g0) / (count - 1); 485 SkFixed db = SkIntToFixed(b1 - b0) / (count - 1); 486 487 /* We pre-add 1/8 to avoid having to add this to our [0] value each time 488 in the loop. Without this, the bias for each would be 489 0x2000 0xA000 0xE000 0x6000 490 With this trick, we can add 0 for the first (no-op) and just adjust the 491 others. 492 */ 493 SkUFixed a = SkIntToFixed(a0) + 0x2000; 494 SkUFixed r = SkIntToFixed(r0) + 0x2000; 495 SkUFixed g = SkIntToFixed(g0) + 0x2000; 496 SkUFixed b = SkIntToFixed(b0) + 0x2000; 497 498 /* 499 * Our dither-cell (spatially) is 500 * 0 2 501 * 3 1 502 * Where 503 * [0] -> [-1/8 ... 1/8 ) values near 0 504 * [1] -> [ 1/8 ... 3/8 ) values near 1/4 505 * [2] -> [ 3/8 ... 5/8 ) values near 1/2 506 * [3] -> [ 5/8 ... 7/8 ) values near 3/4 507 */ 508 509 if (0xFF == a0 && 0 == da) { 510 do { 511 cache[kCache32Count*0] = SkPackARGB32(0xFF, (r + 0 ) >> 16, 512 (g + 0 ) >> 16, 513 (b + 0 ) >> 16); 514 cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + 0x8000) >> 16, 515 (g + 0x8000) >> 16, 516 (b + 0x8000) >> 16); 517 cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + 0xC000) >> 16, 518 (g + 0xC000) >> 16, 519 (b + 0xC000) >> 16); 520 cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + 0x4000) >> 16, 521 (g + 0x4000) >> 16, 522 (b + 0x4000) >> 16); 523 cache += 1; 524 r += dr; 525 g += dg; 526 b += db; 527 } while (--count != 0); 528 } else if (interpInPremul) { 529 do { 530 cache[kCache32Count*0] = SkPackARGB32((a + 0 ) >> 16, 531 (r + 0 ) >> 16, 532 (g + 0 ) >> 16, 533 (b + 0 ) >> 16); 534 cache[kCache32Count*1] = SkPackARGB32((a + 0x8000) >> 16, 535 (r + 0x8000) >> 16, 536 (g + 0x8000) >> 16, 537 (b + 0x8000) >> 16); 538 cache[kCache32Count*2] = SkPackARGB32((a + 0xC000) >> 16, 539 (r + 0xC000) >> 16, 540 (g + 0xC000) >> 16, 541 (b + 0xC000) >> 16); 542 cache[kCache32Count*3] = SkPackARGB32((a + 0x4000) >> 16, 543 (r + 0x4000) >> 16, 544 (g + 0x4000) >> 16, 545 (b + 0x4000) >> 16); 546 cache += 1; 547 a += da; 548 r += dr; 549 g += dg; 550 b += db; 551 } while (--count != 0); 552 } else { // interpolate in unpreml space 553 do { 554 cache[kCache32Count*0] = SkPremultiplyARGBInline((a + 0 ) >> 16, 555 (r + 0 ) >> 16, 556 (g + 0 ) >> 16, 557 (b + 0 ) >> 16); 558 cache[kCache32Count*1] = SkPremultiplyARGBInline((a + 0x8000) >> 16, 559 (r + 0x8000) >> 16, 560 (g + 0x8000) >> 16, 561 (b + 0x8000) >> 16); 562 cache[kCache32Count*2] = SkPremultiplyARGBInline((a + 0xC000) >> 16, 563 (r + 0xC000) >> 16, 564 (g + 0xC000) >> 16, 565 (b + 0xC000) >> 16); 566 cache[kCache32Count*3] = SkPremultiplyARGBInline((a + 0x4000) >> 16, 567 (r + 0x4000) >> 16, 568 (g + 0x4000) >> 16, 569 (b + 0x4000) >> 16); 570 cache += 1; 571 a += da; 572 r += dr; 573 g += dg; 574 b += db; 575 } while (--count != 0); 576 } 577 } 578 579 static inline int SkFixedToFFFF(SkFixed x) { 580 SkASSERT((unsigned)x <= SK_Fixed1); 581 return x - (x >> 16); 582 } 583 584 const uint16_t* SkGradientShaderBase::GradientShaderCache::getCache16() { 585 SkOnce(&fCache16Inited, &fCache16Mutex, SkGradientShaderBase::GradientShaderCache::initCache16, 586 this); 587 SkASSERT(fCache16); 588 return fCache16; 589 } 590 591 void SkGradientShaderBase::GradientShaderCache::initCache16(GradientShaderCache* cache) { 592 // double the count for dither entries 593 const int entryCount = kCache16Count * 2; 594 const size_t allocSize = sizeof(uint16_t) * entryCount; 595 596 SkASSERT(NULL == cache->fCache16Storage); 597 cache->fCache16Storage = (uint16_t*)sk_malloc_throw(allocSize); 598 cache->fCache16 = cache->fCache16Storage; 599 if (cache->fShader.fColorCount == 2) { 600 Build16bitCache(cache->fCache16, cache->fShader.fOrigColors[0], 601 cache->fShader.fOrigColors[1], kCache16Count); 602 } else { 603 Rec* rec = cache->fShader.fRecs; 604 int prevIndex = 0; 605 for (int i = 1; i < cache->fShader.fColorCount; i++) { 606 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache16Shift; 607 SkASSERT(nextIndex < kCache16Count); 608 609 if (nextIndex > prevIndex) 610 Build16bitCache(cache->fCache16 + prevIndex, cache->fShader.fOrigColors[i-1], 611 cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1); 612 prevIndex = nextIndex; 613 } 614 } 615 } 616 617 const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() { 618 SkOnce(&fCache32Inited, &fCache32Mutex, SkGradientShaderBase::GradientShaderCache::initCache32, 619 this); 620 SkASSERT(fCache32); 621 return fCache32; 622 } 623 624 void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache* cache) { 625 const int kNumberOfDitherRows = 4; 626 const SkImageInfo info = SkImageInfo::MakeN32Premul(kCache32Count, kNumberOfDitherRows); 627 628 SkASSERT(NULL == cache->fCache32PixelRef); 629 cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, NULL); 630 cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->getAddr(); 631 if (cache->fShader.fColorCount == 2) { 632 Build32bitCache(cache->fCache32, cache->fShader.fOrigColors[0], 633 cache->fShader.fOrigColors[1], kCache32Count, cache->fCacheAlpha, 634 cache->fShader.fGradFlags); 635 } else { 636 Rec* rec = cache->fShader.fRecs; 637 int prevIndex = 0; 638 for (int i = 1; i < cache->fShader.fColorCount; i++) { 639 int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift; 640 SkASSERT(nextIndex < kCache32Count); 641 642 if (nextIndex > prevIndex) 643 Build32bitCache(cache->fCache32 + prevIndex, cache->fShader.fOrigColors[i-1], 644 cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1, 645 cache->fCacheAlpha, cache->fShader.fGradFlags); 646 prevIndex = nextIndex; 647 } 648 } 649 } 650 651 /* 652 * The gradient holds a cache for the most recent value of alpha. Successive 653 * callers with the same alpha value will share the same cache. 654 */ 655 SkGradientShaderBase::GradientShaderCache* SkGradientShaderBase::refCache(U8CPU alpha) const { 656 SkAutoMutexAcquire ama(fCacheMutex); 657 if (!fCache || fCache->getAlpha() != alpha) { 658 fCache.reset(SkNEW_ARGS(GradientShaderCache, (alpha, *this))); 659 } 660 // Increment the ref counter inside the mutex to ensure the returned pointer is still valid. 661 // Otherwise, the pointer may have been overwritten on a different thread before the object's 662 // ref count was incremented. 663 fCache.get()->ref(); 664 return fCache; 665 } 666 667 SK_DECLARE_STATIC_MUTEX(gGradientCacheMutex); 668 /* 669 * Because our caller might rebuild the same (logically the same) gradient 670 * over and over, we'd like to return exactly the same "bitmap" if possible, 671 * allowing the client to utilize a cache of our bitmap (e.g. with a GPU). 672 * To do that, we maintain a private cache of built-bitmaps, based on our 673 * colors and positions. Note: we don't try to flatten the fMapper, so if one 674 * is present, we skip the cache for now. 675 */ 676 void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap) const { 677 // our caller assumes no external alpha, so we ensure that our cache is 678 // built with 0xFF 679 SkAutoTUnref<GradientShaderCache> cache(this->refCache(0xFF)); 680 681 // build our key: [numColors + colors[] + {positions[]} + flags ] 682 int count = 1 + fColorCount + 1; 683 if (fColorCount > 2) { 684 count += fColorCount - 1; // fRecs[].fPos 685 } 686 687 SkAutoSTMalloc<16, int32_t> storage(count); 688 int32_t* buffer = storage.get(); 689 690 *buffer++ = fColorCount; 691 memcpy(buffer, fOrigColors, fColorCount * sizeof(SkColor)); 692 buffer += fColorCount; 693 if (fColorCount > 2) { 694 for (int i = 1; i < fColorCount; i++) { 695 *buffer++ = fRecs[i].fPos; 696 } 697 } 698 *buffer++ = fGradFlags; 699 SkASSERT(buffer - storage.get() == count); 700 701 /////////////////////////////////// 702 703 static SkGradientBitmapCache* gCache; 704 // each cache cost 1K of RAM, since each bitmap will be 1x256 at 32bpp 705 static const int MAX_NUM_CACHED_GRADIENT_BITMAPS = 32; 706 SkAutoMutexAcquire ama(gGradientCacheMutex); 707 708 if (NULL == gCache) { 709 gCache = SkNEW_ARGS(SkGradientBitmapCache, (MAX_NUM_CACHED_GRADIENT_BITMAPS)); 710 } 711 size_t size = count * sizeof(int32_t); 712 713 if (!gCache->find(storage.get(), size, bitmap)) { 714 // force our cahce32pixelref to be built 715 (void)cache->getCache32(); 716 bitmap->setInfo(SkImageInfo::MakeN32Premul(kCache32Count, 1)); 717 bitmap->setPixelRef(cache->getCache32PixelRef()); 718 719 gCache->add(storage.get(), size, *bitmap); 720 } 721 } 722 723 void SkGradientShaderBase::commonAsAGradient(GradientInfo* info, bool flipGrad) const { 724 if (info) { 725 if (info->fColorCount >= fColorCount) { 726 SkColor* colorLoc; 727 Rec* recLoc; 728 if (flipGrad && (info->fColors || info->fColorOffsets)) { 729 SkAutoSTArray<8, SkColor> colorStorage(fColorCount); 730 SkAutoSTArray<8, Rec> recStorage(fColorCount); 731 colorLoc = colorStorage.get(); 732 recLoc = recStorage.get(); 733 FlipGradientColors(colorLoc, recLoc, fOrigColors, fRecs, fColorCount); 734 } else { 735 colorLoc = fOrigColors; 736 recLoc = fRecs; 737 } 738 if (info->fColors) { 739 memcpy(info->fColors, colorLoc, fColorCount * sizeof(SkColor)); 740 } 741 if (info->fColorOffsets) { 742 if (fColorCount == 2) { 743 info->fColorOffsets[0] = 0; 744 info->fColorOffsets[1] = SK_Scalar1; 745 } else if (fColorCount > 2) { 746 for (int i = 0; i < fColorCount; ++i) { 747 info->fColorOffsets[i] = SkFixedToScalar(recLoc[i].fPos); 748 } 749 } 750 } 751 } 752 info->fColorCount = fColorCount; 753 info->fTileMode = fTileMode; 754 info->fGradientFlags = fGradFlags; 755 } 756 } 757 758 #ifndef SK_IGNORE_TO_STRING 759 void SkGradientShaderBase::toString(SkString* str) const { 760 761 str->appendf("%d colors: ", fColorCount); 762 763 for (int i = 0; i < fColorCount; ++i) { 764 str->appendHex(fOrigColors[i]); 765 if (i < fColorCount-1) { 766 str->append(", "); 767 } 768 } 769 770 if (fColorCount > 2) { 771 str->append(" points: ("); 772 for (int i = 0; i < fColorCount; ++i) { 773 str->appendScalar(SkFixedToScalar(fRecs[i].fPos)); 774 if (i < fColorCount-1) { 775 str->append(", "); 776 } 777 } 778 str->append(")"); 779 } 780 781 static const char* gTileModeName[SkShader::kTileModeCount] = { 782 "clamp", "repeat", "mirror" 783 }; 784 785 str->append(" "); 786 str->append(gTileModeName[fTileMode]); 787 788 this->INHERITED::toString(str); 789 } 790 #endif 791 792 /////////////////////////////////////////////////////////////////////////////// 793 /////////////////////////////////////////////////////////////////////////////// 794 795 // assumes colors is SkColor* and pos is SkScalar* 796 #define EXPAND_1_COLOR(count) \ 797 SkColor tmp[2]; \ 798 do { \ 799 if (1 == count) { \ 800 tmp[0] = tmp[1] = colors[0]; \ 801 colors = tmp; \ 802 pos = NULL; \ 803 count = 2; \ 804 } \ 805 } while (0) 806 807 static void desc_init(SkGradientShaderBase::Descriptor* desc, 808 const SkColor colors[], const SkScalar pos[], int colorCount, 809 SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) { 810 desc->fColors = colors; 811 desc->fPos = pos; 812 desc->fCount = colorCount; 813 desc->fTileMode = mode; 814 desc->fGradFlags = flags; 815 desc->fLocalMatrix = localMatrix; 816 } 817 818 SkShader* SkGradientShader::CreateLinear(const SkPoint pts[2], 819 const SkColor colors[], 820 const SkScalar pos[], int colorCount, 821 SkShader::TileMode mode, 822 uint32_t flags, 823 const SkMatrix* localMatrix) { 824 if (NULL == pts || NULL == colors || colorCount < 1) { 825 return NULL; 826 } 827 EXPAND_1_COLOR(colorCount); 828 829 SkGradientShaderBase::Descriptor desc; 830 desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); 831 return SkNEW_ARGS(SkLinearGradient, (pts, desc)); 832 } 833 834 SkShader* SkGradientShader::CreateRadial(const SkPoint& center, SkScalar radius, 835 const SkColor colors[], 836 const SkScalar pos[], int colorCount, 837 SkShader::TileMode mode, 838 uint32_t flags, 839 const SkMatrix* localMatrix) { 840 if (radius <= 0 || NULL == colors || colorCount < 1) { 841 return NULL; 842 } 843 EXPAND_1_COLOR(colorCount); 844 845 SkGradientShaderBase::Descriptor desc; 846 desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); 847 return SkNEW_ARGS(SkRadialGradient, (center, radius, desc)); 848 } 849 850 SkShader* SkGradientShader::CreateTwoPointRadial(const SkPoint& start, 851 SkScalar startRadius, 852 const SkPoint& end, 853 SkScalar endRadius, 854 const SkColor colors[], 855 const SkScalar pos[], 856 int colorCount, 857 SkShader::TileMode mode, 858 uint32_t flags, 859 const SkMatrix* localMatrix) { 860 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { 861 return NULL; 862 } 863 EXPAND_1_COLOR(colorCount); 864 865 SkGradientShaderBase::Descriptor desc; 866 desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); 867 return SkNEW_ARGS(SkTwoPointRadialGradient, 868 (start, startRadius, end, endRadius, desc)); 869 } 870 871 SkShader* SkGradientShader::CreateTwoPointConical(const SkPoint& start, 872 SkScalar startRadius, 873 const SkPoint& end, 874 SkScalar endRadius, 875 const SkColor colors[], 876 const SkScalar pos[], 877 int colorCount, 878 SkShader::TileMode mode, 879 uint32_t flags, 880 const SkMatrix* localMatrix) { 881 if (startRadius < 0 || endRadius < 0 || NULL == colors || colorCount < 1) { 882 return NULL; 883 } 884 if (start == end && startRadius == endRadius) { 885 return SkShader::CreateEmptyShader(); 886 } 887 888 EXPAND_1_COLOR(colorCount); 889 890 bool flipGradient = startRadius > endRadius; 891 892 SkGradientShaderBase::Descriptor desc; 893 894 if (!flipGradient) { 895 desc_init(&desc, colors, pos, colorCount, mode, flags, localMatrix); 896 return SkNEW_ARGS(SkTwoPointConicalGradient, 897 (start, startRadius, end, endRadius, flipGradient, desc)); 898 } else { 899 SkAutoSTArray<8, SkColor> colorsNew(colorCount); 900 SkAutoSTArray<8, SkScalar> posNew(colorCount); 901 for (int i = 0; i < colorCount; ++i) { 902 colorsNew[i] = colors[colorCount - i - 1]; 903 } 904 905 if (pos) { 906 for (int i = 0; i < colorCount; ++i) { 907 posNew[i] = 1 - pos[colorCount - i - 1]; 908 } 909 desc_init(&desc, colorsNew.get(), posNew.get(), colorCount, mode, flags, localMatrix); 910 } else { 911 desc_init(&desc, colorsNew.get(), NULL, colorCount, mode, flags, localMatrix); 912 } 913 914 return SkNEW_ARGS(SkTwoPointConicalGradient, 915 (end, endRadius, start, startRadius, flipGradient, desc)); 916 } 917 } 918 919 SkShader* SkGradientShader::CreateSweep(SkScalar cx, SkScalar cy, 920 const SkColor colors[], 921 const SkScalar pos[], 922 int colorCount, 923 uint32_t flags, 924 const SkMatrix* localMatrix) { 925 if (NULL == colors || colorCount < 1) { 926 return NULL; 927 } 928 EXPAND_1_COLOR(colorCount); 929 930 SkGradientShaderBase::Descriptor desc; 931 desc_init(&desc, colors, pos, colorCount, SkShader::kClamp_TileMode, flags, localMatrix); 932 return SkNEW_ARGS(SkSweepGradient, (cx, cy, desc)); 933 } 934 935 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader) 936 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient) 937 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient) 938 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient) 939 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointRadialGradient) 940 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient) 941 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END 942 943 /////////////////////////////////////////////////////////////////////////////// 944 945 #if SK_SUPPORT_GPU 946 947 #include "effects/GrTextureStripAtlas.h" 948 #include "GrTBackendProcessorFactory.h" 949 #include "gl/builders/GrGLProgramBuilder.h" 950 #include "SkGr.h" 951 952 GrGLGradientEffect::GrGLGradientEffect(const GrBackendProcessorFactory& factory) 953 : INHERITED(factory) 954 , fCachedYCoord(SK_ScalarMax) { 955 } 956 957 GrGLGradientEffect::~GrGLGradientEffect() { } 958 959 void GrGLGradientEffect::emitUniforms(GrGLProgramBuilder* builder, uint32_t baseKey) { 960 961 if (SkGradientShaderBase::kTwo_GpuColorType == ColorTypeFromKey(baseKey)) { // 2 Color case 962 fColorStartUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 963 kVec4f_GrSLType, "GradientStartColor"); 964 fColorEndUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 965 kVec4f_GrSLType, "GradientEndColor"); 966 967 } else if (SkGradientShaderBase::kThree_GpuColorType == ColorTypeFromKey(baseKey)){ // 3 Color Case 968 fColorStartUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 969 kVec4f_GrSLType, "GradientStartColor"); 970 fColorMidUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 971 kVec4f_GrSLType, "GradientMidColor"); 972 fColorEndUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 973 kVec4f_GrSLType, "GradientEndColor"); 974 975 } else { // if not a fast case 976 fFSYUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility, 977 kFloat_GrSLType, "GradientYCoordFS"); 978 } 979 } 980 981 static inline void set_color_uni(const GrGLProgramDataManager& pdman, 982 const GrGLProgramDataManager::UniformHandle uni, 983 const SkColor* color) { 984 pdman.set4f(uni, 985 SkColorGetR(*color) / 255.f, 986 SkColorGetG(*color) / 255.f, 987 SkColorGetB(*color) / 255.f, 988 SkColorGetA(*color) / 255.f); 989 } 990 991 static inline void set_mul_color_uni(const GrGLProgramDataManager& pdman, 992 const GrGLProgramDataManager::UniformHandle uni, 993 const SkColor* color){ 994 float a = SkColorGetA(*color) / 255.f; 995 float aDiv255 = a / 255.f; 996 pdman.set4f(uni, 997 SkColorGetR(*color) * aDiv255, 998 SkColorGetG(*color) * aDiv255, 999 SkColorGetB(*color) * aDiv255, 1000 a); 1001 } 1002 1003 void GrGLGradientEffect::setData(const GrGLProgramDataManager& pdman, 1004 const GrProcessor& processor) { 1005 1006 const GrGradientEffect& e = processor.cast<GrGradientEffect>(); 1007 1008 1009 if (SkGradientShaderBase::kTwo_GpuColorType == e.getColorType()){ 1010 1011 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 1012 set_mul_color_uni(pdman, fColorStartUni, e.getColors(0)); 1013 set_mul_color_uni(pdman, fColorEndUni, e.getColors(1)); 1014 } else { 1015 set_color_uni(pdman, fColorStartUni, e.getColors(0)); 1016 set_color_uni(pdman, fColorEndUni, e.getColors(1)); 1017 } 1018 1019 } else if (SkGradientShaderBase::kThree_GpuColorType == e.getColorType()){ 1020 1021 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 1022 set_mul_color_uni(pdman, fColorStartUni, e.getColors(0)); 1023 set_mul_color_uni(pdman, fColorMidUni, e.getColors(1)); 1024 set_mul_color_uni(pdman, fColorEndUni, e.getColors(2)); 1025 } else { 1026 set_color_uni(pdman, fColorStartUni, e.getColors(0)); 1027 set_color_uni(pdman, fColorMidUni, e.getColors(1)); 1028 set_color_uni(pdman, fColorEndUni, e.getColors(2)); 1029 } 1030 } else { 1031 1032 SkScalar yCoord = e.getYCoord(); 1033 if (yCoord != fCachedYCoord) { 1034 pdman.set1f(fFSYUni, yCoord); 1035 fCachedYCoord = yCoord; 1036 } 1037 } 1038 } 1039 1040 1041 uint32_t GrGLGradientEffect::GenBaseGradientKey(const GrProcessor& processor) { 1042 const GrGradientEffect& e = processor.cast<GrGradientEffect>(); 1043 1044 uint32_t key = 0; 1045 1046 if (SkGradientShaderBase::kTwo_GpuColorType == e.getColorType()) { 1047 key |= kTwoColorKey; 1048 } else if (SkGradientShaderBase::kThree_GpuColorType == e.getColorType()){ 1049 key |= kThreeColorKey; 1050 } 1051 1052 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) { 1053 key |= kPremulBeforeInterpKey; 1054 } 1055 1056 return key; 1057 } 1058 1059 void GrGLGradientEffect::emitColor(GrGLProgramBuilder* builder, 1060 const char* gradientTValue, 1061 uint32_t baseKey, 1062 const char* outputColor, 1063 const char* inputColor, 1064 const TextureSamplerArray& samplers) { 1065 GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 1066 if (SkGradientShaderBase::kTwo_GpuColorType == ColorTypeFromKey(baseKey)){ 1067 fsBuilder->codeAppendf("\tvec4 colorTemp = mix(%s, %s, clamp(%s, 0.0, 1.0));\n", 1068 builder->getUniformVariable(fColorStartUni).c_str(), 1069 builder->getUniformVariable(fColorEndUni).c_str(), 1070 gradientTValue); 1071 // Note that we could skip this step if both colors are known to be opaque. Two 1072 // considerations: 1073 // The gradient SkShader reporting opaque is more restrictive than necessary in the two pt 1074 // case. Make sure the key reflects this optimization (and note that it can use the same 1075 // shader as thekBeforeIterp case). This same optimization applies to the 3 color case below. 1076 if (GrGradientEffect::kAfterInterp_PremulType == PremulTypeFromKey(baseKey)) { 1077 fsBuilder->codeAppend("\tcolorTemp.rgb *= colorTemp.a;\n"); 1078 } 1079 1080 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, 1081 (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str()); 1082 } else if (SkGradientShaderBase::kThree_GpuColorType == ColorTypeFromKey(baseKey)){ 1083 fsBuilder->codeAppendf("\tfloat oneMinus2t = 1.0 - (2.0 * (%s));\n", 1084 gradientTValue); 1085 fsBuilder->codeAppendf("\tvec4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s;\n", 1086 builder->getUniformVariable(fColorStartUni).c_str()); 1087 if (kTegra3_GrGLRenderer == builder->ctxInfo().renderer()) { 1088 // The Tegra3 compiler will sometimes never return if we have 1089 // min(abs(oneMinus2t), 1.0), or do the abs first in a separate expression. 1090 fsBuilder->codeAppend("\tfloat minAbs = abs(oneMinus2t);\n"); 1091 fsBuilder->codeAppend("\tminAbs = minAbs > 1.0 ? 1.0 : minAbs;\n"); 1092 fsBuilder->codeAppendf("\tcolorTemp += (1.0 - minAbs) * %s;\n", 1093 builder->getUniformVariable(fColorMidUni).c_str()); 1094 } else { 1095 fsBuilder->codeAppendf("\tcolorTemp += (1.0 - min(abs(oneMinus2t), 1.0)) * %s;\n", 1096 builder->getUniformVariable(fColorMidUni).c_str()); 1097 } 1098 fsBuilder->codeAppendf("\tcolorTemp += clamp(-oneMinus2t, 0.0, 1.0) * %s;\n", 1099 builder->getUniformVariable(fColorEndUni).c_str()); 1100 if (GrGradientEffect::kAfterInterp_PremulType == PremulTypeFromKey(baseKey)) { 1101 fsBuilder->codeAppend("\tcolorTemp.rgb *= colorTemp.a;\n"); 1102 } 1103 1104 fsBuilder->codeAppendf("\t%s = %s;\n", outputColor, 1105 (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str()); 1106 } else { 1107 fsBuilder->codeAppendf("\tvec2 coord = vec2(%s, %s);\n", 1108 gradientTValue, 1109 builder->getUniformVariable(fFSYUni).c_str()); 1110 fsBuilder->codeAppendf("\t%s = ", outputColor); 1111 fsBuilder->appendTextureLookupAndModulate(inputColor, 1112 samplers[0], 1113 "coord"); 1114 fsBuilder->codeAppend(";\n"); 1115 } 1116 } 1117 1118 ///////////////////////////////////////////////////////////////////// 1119 1120 GrGradientEffect::GrGradientEffect(GrContext* ctx, 1121 const SkGradientShaderBase& shader, 1122 const SkMatrix& matrix, 1123 SkShader::TileMode tileMode) { 1124 1125 fIsOpaque = shader.isOpaque(); 1126 1127 fColorType = shader.getGpuColorType(&fColors[0]); 1128 1129 // The two and three color specializations do not currently support tiling. 1130 if (SkGradientShaderBase::kTwo_GpuColorType == fColorType || 1131 SkGradientShaderBase::kThree_GpuColorType == fColorType) { 1132 fRow = -1; 1133 1134 if (SkGradientShader::kInterpolateColorsInPremul_Flag & shader.getGradFlags()) { 1135 fPremulType = kBeforeInterp_PremulType; 1136 } else { 1137 fPremulType = kAfterInterp_PremulType; 1138 } 1139 fCoordTransform.reset(kCoordSet, matrix); 1140 } else { 1141 // doesn't matter how this is set, just be consistent because it is part of the effect key. 1142 fPremulType = kBeforeInterp_PremulType; 1143 SkBitmap bitmap; 1144 shader.getGradientTableBitmap(&bitmap); 1145 1146 GrTextureStripAtlas::Desc desc; 1147 desc.fWidth = bitmap.width(); 1148 desc.fHeight = 32; 1149 desc.fRowHeight = bitmap.height(); 1150 desc.fContext = ctx; 1151 desc.fConfig = SkImageInfo2GrPixelConfig(bitmap.info()); 1152 fAtlas = GrTextureStripAtlas::GetAtlas(desc); 1153 SkASSERT(fAtlas); 1154 1155 // We always filter the gradient table. Each table is one row of a texture, always y-clamp. 1156 GrTextureParams params; 1157 params.setFilterMode(GrTextureParams::kBilerp_FilterMode); 1158 params.setTileModeX(tileMode); 1159 1160 fRow = fAtlas->lockRow(bitmap); 1161 if (-1 != fRow) { 1162 fYCoord = fAtlas->getYOffset(fRow) + SK_ScalarHalf * 1163 fAtlas->getVerticalScaleFactor(); 1164 fCoordTransform.reset(kCoordSet, matrix, fAtlas->getTexture()); 1165 fTextureAccess.reset(fAtlas->getTexture(), params); 1166 } else { 1167 GrTexture* texture = GrLockAndRefCachedBitmapTexture(ctx, bitmap, ¶ms); 1168 fCoordTransform.reset(kCoordSet, matrix, texture); 1169 fTextureAccess.reset(texture, params); 1170 fYCoord = SK_ScalarHalf; 1171 1172 // Unlock immediately, this is not great, but we don't have a way of 1173 // knowing when else to unlock it currently, so it may get purged from 1174 // the cache, but it'll still be ref'd until it's no longer being used. 1175 GrUnlockAndUnrefCachedBitmapTexture(texture); 1176 } 1177 this->addTextureAccess(&fTextureAccess); 1178 } 1179 this->addCoordTransform(&fCoordTransform); 1180 } 1181 1182 GrGradientEffect::~GrGradientEffect() { 1183 if (this->useAtlas()) { 1184 fAtlas->unlockRow(fRow); 1185 } 1186 } 1187 1188 bool GrGradientEffect::onIsEqual(const GrProcessor& processor) const { 1189 const GrGradientEffect& s = processor.cast<GrGradientEffect>(); 1190 1191 if (this->fColorType == s.getColorType()){ 1192 1193 if (SkGradientShaderBase::kTwo_GpuColorType == fColorType) { 1194 if (*this->getColors(0) != *s.getColors(0) || 1195 *this->getColors(1) != *s.getColors(1)) { 1196 return false; 1197 } 1198 } else if (SkGradientShaderBase::kThree_GpuColorType == fColorType) { 1199 if (*this->getColors(0) != *s.getColors(0) || 1200 *this->getColors(1) != *s.getColors(1) || 1201 *this->getColors(2) != *s.getColors(2)) { 1202 return false; 1203 } 1204 } else { 1205 if (fYCoord != s.getYCoord()) { 1206 return false; 1207 } 1208 } 1209 1210 return fTextureAccess.getTexture() == s.fTextureAccess.getTexture() && 1211 fTextureAccess.getParams().getTileModeX() == 1212 s.fTextureAccess.getParams().getTileModeX() && 1213 this->useAtlas() == s.useAtlas() && 1214 fCoordTransform.getMatrix().cheapEqualTo(s.fCoordTransform.getMatrix()); 1215 } 1216 1217 return false; 1218 } 1219 1220 void GrGradientEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const { 1221 if (fIsOpaque && (kA_GrColorComponentFlag & *validFlags) && 0xff == GrColorUnpackA(*color)) { 1222 *validFlags = kA_GrColorComponentFlag; 1223 } else { 1224 *validFlags = 0; 1225 } 1226 } 1227 1228 int GrGradientEffect::RandomGradientParams(SkRandom* random, 1229 SkColor colors[], 1230 SkScalar** stops, 1231 SkShader::TileMode* tm) { 1232 int outColors = random->nextRangeU(1, kMaxRandomGradientColors); 1233 1234 // if one color, omit stops, otherwise randomly decide whether or not to 1235 if (outColors == 1 || (outColors >= 2 && random->nextBool())) { 1236 *stops = NULL; 1237 } 1238 1239 SkScalar stop = 0.f; 1240 for (int i = 0; i < outColors; ++i) { 1241 colors[i] = random->nextU(); 1242 if (*stops) { 1243 (*stops)[i] = stop; 1244 stop = i < outColors - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f; 1245 } 1246 } 1247 *tm = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount)); 1248 1249 return outColors; 1250 } 1251 1252 #endif 1253
