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