src/third_party/skia/src/effects/gradients/SkGradientShader.cpp

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