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 "Sk4fLinearGradient.h"
   9 #include "SkColorSpace_XYZ.h"
  10 #include "SkGradientShaderPriv.h"
  11 #include "SkHalf.h"
  12 #include "SkLinearGradient.h"
  13 #include "SkRadialGradient.h"
  14 #include "SkTwoPointConicalGradient.h"
  15 #include "SkSweepGradient.h"
  16
  17 enum GradientSerializationFlags {
  18     // Bits 29:31 used for various boolean flags
  19     kHasPosition_GSF    = 0x80000000,
  20     kHasLocalMatrix_GSF = 0x40000000,
  21     kHasColorSpace_GSF  = 0x20000000,
  22
  23     // Bits 12:28 unused
  24
  25     // Bits 8:11 for fTileMode
  26     kTileModeShift_GSF  = 8,
  27     kTileModeMask_GSF   = 0xF,
  28
  29     // Bits 0:7 for fGradFlags (note that kForce4fContext_PrivateFlag is 0x80)
  30     kGradFlagsShift_GSF = 0,
  31     kGradFlagsMask_GSF  = 0xFF,
  32 };
  33
  34 void SkGradientShaderBase::Descriptor::flatten(SkWriteBuffer& buffer) const {
  35     uint32_t flags = 0;
  36     if (fPos) {
  37         flags |= kHasPosition_GSF;
  38     }
  39     if (fLocalMatrix) {
  40         flags |= kHasLocalMatrix_GSF;
  41     }
  42     sk_sp<SkData> colorSpaceData = fColorSpace ? fColorSpace->serialize() : nullptr;
  43     if (colorSpaceData) {
  44         flags |= kHasColorSpace_GSF;
  45     }
  46     SkASSERT(static_cast<uint32_t>(fTileMode) <= kTileModeMask_GSF);
  47     flags |= (fTileMode << kTileModeShift_GSF);
  48     SkASSERT(fGradFlags <= kGradFlagsMask_GSF);
  49     flags |= (fGradFlags << kGradFlagsShift_GSF);
  50
  51     buffer.writeUInt(flags);
  52
  53     buffer.writeColor4fArray(fColors, fCount);
  54     if (colorSpaceData) {
  55         buffer.writeDataAsByteArray(colorSpaceData.get());
  56     }
  57     if (fPos) {
  58         buffer.writeScalarArray(fPos, fCount);
  59     }
  60     if (fLocalMatrix) {
  61         buffer.writeMatrix(*fLocalMatrix);
  62     }
  63 }
  64
  65 bool SkGradientShaderBase::DescriptorScope::unflatten(SkReadBuffer& buffer) {
  66     if (buffer.isVersionLT(SkReadBuffer::kGradientShaderFloatColor_Version)) {
  67         fCount = buffer.getArrayCount();
  68         if (fCount > kStorageCount) {
  69             size_t allocSize = (sizeof(SkColor4f) + sizeof(SkScalar)) * fCount;
  70             fDynamicStorage.reset(allocSize);
  71             fColors = (SkColor4f*)fDynamicStorage.get();
  72             fPos = (SkScalar*)(fColors + fCount);
  73         } else {
  74             fColors = fColorStorage;
  75             fPos = fPosStorage;
  76         }
  77
  78         // Old gradients serialized SkColor. Read that to a temporary location, then convert.
  79         SkSTArray<2, SkColor, true> colors;
  80         colors.resize_back(fCount);
  81         if (!buffer.readColorArray(colors.begin(), fCount)) {
  82             return false;
  83         }
  84         for (int i = 0; i < fCount; ++i) {
  85             mutableColors()[i] = SkColor4f::FromColor(colors[i]);
  86         }
  87
  88         if (buffer.readBool()) {
  89             if (!buffer.readScalarArray(const_cast<SkScalar*>(fPos), fCount)) {
  90                 return false;
  91             }
  92         } else {
  93             fPos = nullptr;
  94         }
  95
  96         fColorSpace = nullptr;
  97         fTileMode = (SkShader::TileMode)buffer.read32();
  98         fGradFlags = buffer.read32();
  99
 100         if (buffer.readBool()) {
 101             fLocalMatrix = &fLocalMatrixStorage;
 102             buffer.readMatrix(&fLocalMatrixStorage);
 103         } else {
 104             fLocalMatrix = nullptr;
 105         }
 106     } else {
 107         // New gradient format. Includes floating point color, color space, densely packed flags
 108         uint32_t flags = buffer.readUInt();
 109
 110         fTileMode = (SkShader::TileMode)((flags >> kTileModeShift_GSF) & kTileModeMask_GSF);
 111         fGradFlags = (flags >> kGradFlagsShift_GSF) & kGradFlagsMask_GSF;
 112
 113         fCount = buffer.getArrayCount();
 114         if (fCount > kStorageCount) {
 115             size_t allocSize = (sizeof(SkColor4f) + sizeof(SkScalar)) * fCount;
 116             fDynamicStorage.reset(allocSize);
 117             fColors = (SkColor4f*)fDynamicStorage.get();
 118             fPos = (SkScalar*)(fColors + fCount);
 119         } else {
 120             fColors = fColorStorage;
 121             fPos = fPosStorage;
 122         }
 123         if (!buffer.readColor4fArray(mutableColors(), fCount)) {
 124             return false;
 125         }
 126         if (SkToBool(flags & kHasColorSpace_GSF)) {
 127             sk_sp<SkData> data = buffer.readByteArrayAsData();
 128             fColorSpace = SkColorSpace::Deserialize(data->data(), data->size());
 129         } else {
 130             fColorSpace = nullptr;
 131         }
 132         if (SkToBool(flags & kHasPosition_GSF)) {
 133             if (!buffer.readScalarArray(mutablePos(), fCount)) {
 134                 return false;
 135             }
 136         } else {
 137             fPos = nullptr;
 138         }
 139         if (SkToBool(flags & kHasLocalMatrix_GSF)) {
 140             fLocalMatrix = &fLocalMatrixStorage;
 141             buffer.readMatrix(&fLocalMatrixStorage);
 142         } else {
 143             fLocalMatrix = nullptr;
 144         }
 145     }
 146     return buffer.isValid();
 147 }
 148
 149 ////////////////////////////////////////////////////////////////////////////////////////////
 150
 151 SkGradientShaderBase::SkGradientShaderBase(const Descriptor& desc, const SkMatrix& ptsToUnit)
 152     : INHERITED(desc.fLocalMatrix)
 153     , fPtsToUnit(ptsToUnit)
 154 {
 155     fPtsToUnit.getType();  // Precache so reads are threadsafe.
 156     SkASSERT(desc.fCount > 1);
 157
 158     fGradFlags = static_cast<uint8_t>(desc.fGradFlags);
 159
 160     SkASSERT((unsigned)desc.fTileMode < SkShader::kTileModeCount);
 161     SkASSERT(SkShader::kTileModeCount == SK_ARRAY_COUNT(gTileProcs));
 162     fTileMode = desc.fTileMode;
 163     fTileProc = gTileProcs[desc.fTileMode];
 164
 165     /*  Note: we let the caller skip the first and/or last position.
 166         i.e. pos[0] = 0.3, pos[1] = 0.7
 167         In these cases, we insert dummy entries to ensure that the final data
 168         will be bracketed by [0, 1].
 169         i.e. our_pos[0] = 0, our_pos[1] = 0.3, our_pos[2] = 0.7, our_pos[3] = 1
 170
 171         Thus colorCount (the caller's value, and fColorCount (our value) may
 172         differ by up to 2. In the above example:
 173             colorCount = 2
 174             fColorCount = 4
 175      */
 176     fColorCount = desc.fCount;
 177     // check if we need to add in dummy start and/or end position/colors
 178     bool dummyFirst = false;
 179     bool dummyLast = false;
 180     if (desc.fPos) {
 181         dummyFirst = desc.fPos[0] != 0;
 182         dummyLast = desc.fPos[desc.fCount - 1] != SK_Scalar1;
 183         fColorCount += dummyFirst + dummyLast;
 184     }
 185
 186     if (fColorCount > kColorStorageCount) {
 187         size_t size = sizeof(SkColor) + sizeof(SkColor4f) + sizeof(Rec);
 188         if (desc.fPos) {
 189             size += sizeof(SkScalar);
 190         }
 191         fOrigColors = reinterpret_cast<SkColor*>(sk_malloc_throw(size * fColorCount));
 192     }
 193     else {
 194         fOrigColors = fStorage;
 195     }
 196
 197     fOrigColors4f = (SkColor4f*)(fOrigColors + fColorCount);
 198
 199     // Now copy over the colors, adding the dummies as needed
 200     SkColor4f* origColors = fOrigColors4f;
 201     if (dummyFirst) {
 202         *origColors++ = desc.fColors[0];
 203     }
 204     memcpy(origColors, desc.fColors, desc.fCount * sizeof(SkColor4f));
 205     if (dummyLast) {
 206         origColors += desc.fCount;
 207         *origColors = desc.fColors[desc.fCount - 1];
 208     }
 209
 210     // Convert our SkColor4f colors to SkColor as well. Note that this is incorrect if the
 211     // source colors are not in sRGB gamut. We would need to do a gamut transformation, but
 212     // SkColorSpaceXform can't do that (yet). GrColorSpaceXform can, but we may not have GPU
 213     // support compiled in here. For the common case (sRGB colors), this does the right thing.
 214     for (int i = 0; i < fColorCount; ++i) {
 215         fOrigColors[i] = fOrigColors4f[i].toSkColor();
 216     }
 217
 218     if (!desc.fColorSpace) {
 219         // This happens if we were constructed from SkColors, so our colors are really sRGB
 220         fColorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
 221     } else {
 222         // The color space refers to the float colors, so it must be linear gamma
 223         SkASSERT(desc.fColorSpace->gammaIsLinear());
 224         fColorSpace = desc.fColorSpace;
 225     }
 226
 227     if (desc.fPos && fColorCount) {
 228         fOrigPos = (SkScalar*)(fOrigColors4f + fColorCount);
 229         fRecs = (Rec*)(fOrigPos + fColorCount);
 230     } else {
 231         fOrigPos = nullptr;
 232         fRecs = (Rec*)(fOrigColors4f + fColorCount);
 233     }
 234
 235     if (fColorCount > 2) {
 236         Rec* recs = fRecs;
 237         recs->fPos = 0;
 238         //  recs->fScale = 0; // unused;
 239         recs += 1;
 240         if (desc.fPos) {
 241             SkScalar* origPosPtr = fOrigPos;
 242             *origPosPtr++ = 0;
 243
 244             /*  We need to convert the user's array of relative positions into
 245                 fixed-point positions and scale factors. We need these results
 246                 to be strictly monotonic (no two values equal or out of order).
 247                 Hence this complex loop that just jams a zero for the scale
 248                 value if it sees a segment out of order, and it assures that
 249                 we start at 0 and end at 1.0
 250             */
 251             SkScalar prev = 0;
 252             int startIndex = dummyFirst ? 0 : 1;
 253             int count = desc.fCount + dummyLast;
 254             for (int i = startIndex; i < count; i++) {
 255                 // force the last value to be 1.0
 256                 SkScalar curr;
 257                 if (i == desc.fCount) {  // we're really at the dummyLast
 258                     curr = 1;
 259                 } else {
 260                     curr = SkScalarPin(desc.fPos[i], 0, 1);
 261                 }
 262                 *origPosPtr++ = curr;
 263
 264                 recs->fPos = SkScalarToFixed(curr);
 265                 SkFixed diff = SkScalarToFixed(curr - prev);
 266                 if (diff > 0) {
 267                     recs->fScale = (1 << 24) / diff;
 268                 } else {
 269                     recs->fScale = 0; // ignore this segment
 270                 }
 271                 // get ready for the next value
 272                 prev = curr;
 273                 recs += 1;
 274             }
 275         } else {    // assume even distribution
 276             fOrigPos = nullptr;
 277
 278             SkFixed dp = SK_Fixed1 / (desc.fCount - 1);
 279             SkFixed p = dp;
 280             SkFixed scale = (desc.fCount - 1) << 8;  // (1 << 24) / dp
 281             for (int i = 1; i < desc.fCount - 1; i++) {
 282                 recs->fPos   = p;
 283                 recs->fScale = scale;
 284                 recs += 1;
 285                 p += dp;
 286             }
 287             recs->fPos = SK_Fixed1;
 288             recs->fScale = scale;
 289         }
 290     } else if (desc.fPos) {
 291         SkASSERT(2 == fColorCount);
 292         fOrigPos[0] = SkScalarPin(desc.fPos[0], 0, 1);
 293         fOrigPos[1] = SkScalarPin(desc.fPos[1], fOrigPos[0], 1);
 294         if (0 == fOrigPos[0] && 1 == fOrigPos[1]) {
 295             fOrigPos = nullptr;
 296         }
 297     }
 298     this->initCommon();
 299 }
 300
 301 SkGradientShaderBase::~SkGradientShaderBase() {
 302     if (fOrigColors != fStorage) {
 303         sk_free(fOrigColors);
 304     }
 305 }
 306
 307 void SkGradientShaderBase::initCommon() {
 308     unsigned colorAlpha = 0xFF;
 309     for (int i = 0; i < fColorCount; i++) {
 310         colorAlpha &= SkColorGetA(fOrigColors[i]);
 311     }
 312     fColorsAreOpaque = colorAlpha == 0xFF;
 313 }
 314
 315 void SkGradientShaderBase::flatten(SkWriteBuffer& buffer) const {
 316     Descriptor desc;
 317     desc.fColors = fOrigColors4f;
 318     desc.fColorSpace = fColorSpace;
 319     desc.fPos = fOrigPos;
 320     desc.fCount = fColorCount;
 321     desc.fTileMode = fTileMode;
 322     desc.fGradFlags = fGradFlags;
 323
 324     const SkMatrix& m = this->getLocalMatrix();
 325     desc.fLocalMatrix = m.isIdentity() ? nullptr : &m;
 326     desc.flatten(buffer);
 327 }
 328
 329 void SkGradientShaderBase::FlipGradientColors(SkColor* colorDst, Rec* recDst,
 330                                               SkColor* colorSrc, Rec* recSrc,
 331                                               int count) {
 332     SkAutoSTArray<8, SkColor> colorsTemp(count);
 333     for (int i = 0; i < count; ++i) {
 334         int offset = count - i - 1;
 335         colorsTemp[i] = colorSrc[offset];
 336     }
 337     if (count > 2) {
 338         SkAutoSTArray<8, Rec> recsTemp(count);
 339         for (int i = 0; i < count; ++i) {
 340             int offset = count - i - 1;
 341             recsTemp[i].fPos = SK_Fixed1 - recSrc[offset].fPos;
 342             recsTemp[i].fScale = recSrc[offset].fScale;
 343         }
 344         memcpy(recDst, recsTemp.get(), count * sizeof(Rec));
 345     }
 346     memcpy(colorDst, colorsTemp.get(), count * sizeof(SkColor));
 347 }
 348
 349 bool SkGradientShaderBase::isOpaque() const {
 350     return fColorsAreOpaque;
 351 }
 352
 353 static unsigned rounded_divide(unsigned numer, unsigned denom) {
 354     return (numer + (denom >> 1)) / denom;
 355 }
 356
 357 bool SkGradientShaderBase::onAsLuminanceColor(SkColor* lum) const {
 358     // we just compute an average color.
 359     // possibly we could weight this based on the proportional width for each color
 360     //   assuming they are not evenly distributed in the fPos array.
 361     int r = 0;
 362     int g = 0;
 363     int b = 0;
 364     const int n = fColorCount;
 365     for (int i = 0; i < n; ++i) {
 366         SkColor c = fOrigColors[i];
 367         r += SkColorGetR(c);
 368         g += SkColorGetG(c);
 369         b += SkColorGetB(c);
 370     }
 371     *lum = SkColorSetRGB(rounded_divide(r, n), rounded_divide(g, n), rounded_divide(b, n));
 372     return true;
 373 }
 374
 375 SkGradientShaderBase::GradientShaderBaseContext::GradientShaderBaseContext(
 376         const SkGradientShaderBase& shader, const ContextRec& rec)
 377     : INHERITED(shader, rec)
 378 #ifdef SK_SUPPORT_LEGACY_GRADIENT_DITHERING
 379     , fDither(true)
 380 #else
 381     , fDither(rec.fPaint->isDither())
 382 #endif
 383     , fCache(shader.refCache(getPaintAlpha(), fDither))
 384 {
 385     const SkMatrix& inverse = this->getTotalInverse();
 386
 387     fDstToIndex.setConcat(shader.fPtsToUnit, inverse);
 388
 389     fDstToIndexProc = fDstToIndex.getMapXYProc();
 390     fDstToIndexClass = (uint8_t)SkShader::Context::ComputeMatrixClass(fDstToIndex);
 391
 392     // now convert our colors in to PMColors
 393     unsigned paintAlpha = this->getPaintAlpha();
 394
 395     fFlags = this->INHERITED::getFlags();
 396     if (shader.fColorsAreOpaque && paintAlpha == 0xFF) {
 397         fFlags |= kOpaqueAlpha_Flag;
 398     }
 399 }
 400
 401 bool SkGradientShaderBase::GradientShaderBaseContext::isValid() const {
 402     return fDstToIndex.isFinite();
 403 }
 404
 405 SkGradientShaderBase::GradientShaderCache::GradientShaderCache(
 406         U8CPU alpha, bool dither, const SkGradientShaderBase& shader)
 407     : fCacheAlpha(alpha)
 408     , fCacheDither(dither)
 409     , fShader(shader)
 410 {
 411     // Only initialize the cache in getCache32.
 412     fCache32 = nullptr;
 413     fCache32PixelRef = nullptr;
 414 }
 415
 416 SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {
 417     SkSafeUnref(fCache32PixelRef);
 418 }
 419
 420 /*
 421  *  r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in
 422  *  release builds, we saw a compiler error where the 0xFF parameter in
 423  *  SkPackARGB32() was being totally ignored whenever it was called with
 424  *  a non-zero add (e.g. 0x8000).
 425  *
 426  *  We found two work-arounds:
 427  *      1. change r,g,b to unsigned (or just one of them)
 428  *      2. change SkPackARGB32 to + its (a << SK_A32_SHIFT) value instead
 429  *         of using |
 430  *
 431  *  We chose #1 just because it was more localized.
 432  *  See http://code.google.com/p/skia/issues/detail?id=1113
 433  *
 434  *  The type SkUFixed encapsulate this need for unsigned, but logically Fixed.
 435  */
 436 typedef uint32_t SkUFixed;
 437
 438 void SkGradientShaderBase::GradientShaderCache::Build32bitCache(
 439         SkPMColor cache[], SkColor c0, SkColor c1,
 440         int count, U8CPU paintAlpha, uint32_t gradFlags, bool dither) {
 441     SkASSERT(count > 1);
 442
 443     // need to apply paintAlpha to our two endpoints
 444     uint32_t a0 = SkMulDiv255Round(SkColorGetA(c0), paintAlpha);
 445     uint32_t a1 = SkMulDiv255Round(SkColorGetA(c1), paintAlpha);
 446
 447
 448     const bool interpInPremul = SkToBool(gradFlags &
 449                            SkGradientShader::kInterpolateColorsInPremul_Flag);
 450
 451     uint32_t r0 = SkColorGetR(c0);
 452     uint32_t g0 = SkColorGetG(c0);
 453     uint32_t b0 = SkColorGetB(c0);
 454
 455     uint32_t r1 = SkColorGetR(c1);
 456     uint32_t g1 = SkColorGetG(c1);
 457     uint32_t b1 = SkColorGetB(c1);
 458
 459     if (interpInPremul) {
 460         r0 = SkMulDiv255Round(r0, a0);
 461         g0 = SkMulDiv255Round(g0, a0);
 462         b0 = SkMulDiv255Round(b0, a0);
 463
 464         r1 = SkMulDiv255Round(r1, a1);
 465         g1 = SkMulDiv255Round(g1, a1);
 466         b1 = SkMulDiv255Round(b1, a1);
 467     }
 468
 469     SkFixed da = SkIntToFixed(a1 - a0) / (count - 1);
 470     SkFixed dr = SkIntToFixed(r1 - r0) / (count - 1);
 471     SkFixed dg = SkIntToFixed(g1 - g0) / (count - 1);
 472     SkFixed db = SkIntToFixed(b1 - b0) / (count - 1);
 473
 474     /*  We pre-add 1/8 to avoid having to add this to our [0] value each time
 475         in the loop. Without this, the bias for each would be
 476             0x2000  0xA000  0xE000  0x6000
 477         With this trick, we can add 0 for the first (no-op) and just adjust the
 478         others.
 479      */
 480     const SkUFixed bias0 = dither ? 0x2000 : 0x8000;
 481     const SkUFixed bias1 = dither ? 0x8000 : 0;
 482     const SkUFixed bias2 = dither ? 0xC000 : 0;
 483     const SkUFixed bias3 = dither ? 0x4000 : 0;
 484
 485     SkUFixed a = SkIntToFixed(a0) + bias0;
 486     SkUFixed r = SkIntToFixed(r0) + bias0;
 487     SkUFixed g = SkIntToFixed(g0) + bias0;
 488     SkUFixed b = SkIntToFixed(b0) + bias0;
 489
 490     /*
 491      *  Our dither-cell (spatially) is
 492      *      0 2
 493      *      3 1
 494      *  Where
 495      *      [0] -> [-1/8 ... 1/8 ) values near 0
 496      *      [1] -> [ 1/8 ... 3/8 ) values near 1/4
 497      *      [2] -> [ 3/8 ... 5/8 ) values near 1/2
 498      *      [3] -> [ 5/8 ... 7/8 ) values near 3/4
 499      */
 500
 501     if (0xFF == a0 && 0 == da) {
 502         do {
 503             cache[kCache32Count*0] = SkPackARGB32(0xFF, (r + 0    ) >> 16,
 504                                                         (g + 0    ) >> 16,
 505                                                         (b + 0    ) >> 16);
 506             cache[kCache32Count*1] = SkPackARGB32(0xFF, (r + bias1) >> 16,
 507                                                         (g + bias1) >> 16,
 508                                                         (b + bias1) >> 16);
 509             cache[kCache32Count*2] = SkPackARGB32(0xFF, (r + bias2) >> 16,
 510                                                         (g + bias2) >> 16,
 511                                                         (b + bias2) >> 16);
 512             cache[kCache32Count*3] = SkPackARGB32(0xFF, (r + bias3) >> 16,
 513                                                         (g + bias3) >> 16,
 514                                                         (b + bias3) >> 16);
 515             cache += 1;
 516             r += dr;
 517             g += dg;
 518             b += db;
 519         } while (--count != 0);
 520     } else if (interpInPremul) {
 521         do {
 522             cache[kCache32Count*0] = SkPackARGB32((a + 0    ) >> 16,
 523                                                   (r + 0    ) >> 16,
 524                                                   (g + 0    ) >> 16,
 525                                                   (b + 0    ) >> 16);
 526             cache[kCache32Count*1] = SkPackARGB32((a + bias1) >> 16,
 527                                                   (r + bias1) >> 16,
 528                                                   (g + bias1) >> 16,
 529                                                   (b + bias1) >> 16);
 530             cache[kCache32Count*2] = SkPackARGB32((a + bias2) >> 16,
 531                                                   (r + bias2) >> 16,
 532                                                   (g + bias2) >> 16,
 533                                                   (b + bias2) >> 16);
 534             cache[kCache32Count*3] = SkPackARGB32((a + bias3) >> 16,
 535                                                   (r + bias3) >> 16,
 536                                                   (g + bias3) >> 16,
 537                                                   (b + bias3) >> 16);
 538             cache += 1;
 539             a += da;
 540             r += dr;
 541             g += dg;
 542             b += db;
 543         } while (--count != 0);
 544     } else {    // interpolate in unpreml space
 545         do {
 546             cache[kCache32Count*0] = SkPremultiplyARGBInline((a + 0     ) >> 16,
 547                                                              (r + 0     ) >> 16,
 548                                                              (g + 0     ) >> 16,
 549                                                              (b + 0     ) >> 16);
 550             cache[kCache32Count*1] = SkPremultiplyARGBInline((a + bias1) >> 16,
 551                                                              (r + bias1) >> 16,
 552                                                              (g + bias1) >> 16,
 553                                                              (b + bias1) >> 16);
 554             cache[kCache32Count*2] = SkPremultiplyARGBInline((a + bias2) >> 16,
 555                                                              (r + bias2) >> 16,
 556                                                              (g + bias2) >> 16,
 557                                                              (b + bias2) >> 16);
 558             cache[kCache32Count*3] = SkPremultiplyARGBInline((a + bias3) >> 16,
 559                                                              (r + bias3) >> 16,
 560                                                              (g + bias3) >> 16,
 561                                                              (b + bias3) >> 16);
 562             cache += 1;
 563             a += da;
 564             r += dr;
 565             g += dg;
 566             b += db;
 567         } while (--count != 0);
 568     }
 569 }
 570
 571 static inline int SkFixedToFFFF(SkFixed x) {
 572     SkASSERT((unsigned)x <= SK_Fixed1);
 573     return x - (x >> 16);
 574 }
 575
 576 const SkPMColor* SkGradientShaderBase::GradientShaderCache::getCache32() {
 577     fCache32InitOnce(SkGradientShaderBase::GradientShaderCache::initCache32, this);
 578     SkASSERT(fCache32);
 579     return fCache32;
 580 }
 581
 582 void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache* cache) {
 583     const int kNumberOfDitherRows = 4;
 584     const SkImageInfo info = SkImageInfo::MakeN32Premul(kCache32Count, kNumberOfDitherRows);
 585
 586     SkASSERT(nullptr == cache->fCache32PixelRef);
 587     cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, nullptr);
 588     cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->getAddr();
 589     if (cache->fShader.fColorCount == 2) {
 590         Build32bitCache(cache->fCache32, cache->fShader.fOrigColors[0],
 591                         cache->fShader.fOrigColors[1], kCache32Count, cache->fCacheAlpha,
 592                         cache->fShader.fGradFlags, cache->fCacheDither);
 593     } else {
 594         Rec* rec = cache->fShader.fRecs;
 595         int prevIndex = 0;
 596         for (int i = 1; i < cache->fShader.fColorCount; i++) {
 597             int nextIndex = SkFixedToFFFF(rec[i].fPos) >> kCache32Shift;
 598             SkASSERT(nextIndex < kCache32Count);
 599
 600             if (nextIndex > prevIndex)
 601                 Build32bitCache(cache->fCache32 + prevIndex, cache->fShader.fOrigColors[i-1],
 602                                 cache->fShader.fOrigColors[i], nextIndex - prevIndex + 1,
 603                                 cache->fCacheAlpha, cache->fShader.fGradFlags, cache->fCacheDither);
 604             prevIndex = nextIndex;
 605         }
 606     }
 607 }
 608
 609 void SkGradientShaderBase::initLinearBitmap(SkBitmap* bitmap) const {
 610     const bool interpInPremul = SkToBool(fGradFlags &
 611                                          SkGradientShader::kInterpolateColorsInPremul_Flag);
 612     bitmap->lockPixels();
 613     SkHalf* pixelsF16 = reinterpret_cast<SkHalf*>(bitmap->getPixels());
 614     uint32_t* pixelsS32 = reinterpret_cast<uint32_t*>(bitmap->getPixels());
 615
 616     typedef std::function<void(const Sk4f&, int)> pixelWriteFn_t;
 617
 618     pixelWriteFn_t writeF16Pixel = [&](const Sk4f& x, int index) {
 619         Sk4h c = SkFloatToHalf_finite_ftz(x);
 620         pixelsF16[4*index+0] = c[0];
 621         pixelsF16[4*index+1] = c[1];
 622         pixelsF16[4*index+2] = c[2];
 623         pixelsF16[4*index+3] = c[3];
 624     };
 625     pixelWriteFn_t writeS32Pixel = [&](const Sk4f& c, int index) {
 626         pixelsS32[index] = Sk4f_toS32(c);
 627     };
 628
 629     pixelWriteFn_t writeSizedPixel =
 630         (kRGBA_F16_SkColorType == bitmap->colorType()) ? writeF16Pixel : writeS32Pixel;
 631     pixelWriteFn_t writeUnpremulPixel = [&](const Sk4f& c, int index) {
 632         writeSizedPixel(c * Sk4f(c[3], c[3], c[3], 1.0f), index);
 633     };
 634
 635     pixelWriteFn_t writePixel = interpInPremul ? writeSizedPixel : writeUnpremulPixel;
 636
 637     int prevIndex = 0;
 638     for (int i = 1; i < fColorCount; i++) {
 639         int nextIndex = (fColorCount == 2) ? (kCache32Count - 1)
 640             : SkFixedToFFFF(fRecs[i].fPos) >> kCache32Shift;
 641         SkASSERT(nextIndex < kCache32Count);
 642
 643         if (nextIndex > prevIndex) {
 644             Sk4f c0 = Sk4f::Load(fOrigColors4f[i - 1].vec());
 645             Sk4f c1 = Sk4f::Load(fOrigColors4f[i].vec());
 646             if (interpInPremul) {
 647                 c0 = c0 * Sk4f(c0[3], c0[3], c0[3], 1.0f);
 648                 c1 = c1 * Sk4f(c1[3], c1[3], c1[3], 1.0f);
 649             }
 650
 651             Sk4f step = Sk4f(1.0f / static_cast<float>(nextIndex - prevIndex));
 652             Sk4f delta = (c1 - c0) * step;
 653
 654             for (int curIndex = prevIndex; curIndex <= nextIndex; ++curIndex) {
 655                 writePixel(c0, curIndex);
 656                 c0 += delta;
 657             }
 658         }
 659         prevIndex = nextIndex;
 660     }
 661     SkASSERT(prevIndex == kCache32Count - 1);
 662     bitmap->unlockPixels();
 663 }
 664
 665 /*
 666  *  The gradient holds a cache for the most recent value of alpha. Successive
 667  *  callers with the same alpha value will share the same cache.
 668  */
 669 sk_sp<SkGradientShaderBase::GradientShaderCache> SkGradientShaderBase::refCache(U8CPU alpha,
 670                                                                           bool dither) const {
 671     SkAutoMutexAcquire ama(fCacheMutex);
 672     if (!fCache || fCache->getAlpha() != alpha || fCache->getDither() != dither) {
 673         fCache.reset(new GradientShaderCache(alpha, dither, *this));
 674     }
 675     // Increment the ref counter inside the mutex to ensure the returned pointer is still valid.
 676     // Otherwise, the pointer may have been overwritten on a different thread before the object's
 677     // ref count was incremented.
 678     return fCache;
 679 }
 680
 681 SK_DECLARE_STATIC_MUTEX(gGradientCacheMutex);
 682 /*
 683  *  Because our caller might rebuild the same (logically the same) gradient
 684  *  over and over, we'd like to return exactly the same "bitmap" if possible,
 685  *  allowing the client to utilize a cache of our bitmap (e.g. with a GPU).
 686  *  To do that, we maintain a private cache of built-bitmaps, based on our
 687  *  colors and positions. Note: we don't try to flatten the fMapper, so if one
 688  *  is present, we skip the cache for now.
 689  */
 690 void SkGradientShaderBase::getGradientTableBitmap(SkBitmap* bitmap,
 691                                                   GradientBitmapType bitmapType) const {
 692     // our caller assumes no external alpha, so we ensure that our cache is built with 0xFF
 693     sk_sp<GradientShaderCache> cache(this->refCache(0xFF, true));
 694
 695     // build our key: [numColors + colors[] + {positions[]} + flags + colorType ]
 696     int count = 1 + fColorCount + 1 + 1;
 697     if (fColorCount > 2) {
 698         count += fColorCount - 1;    // fRecs[].fPos
 699     }
 700
 701     SkAutoSTMalloc<16, int32_t> storage(count);
 702     int32_t* buffer = storage.get();
 703
 704     *buffer++ = fColorCount;
 705     memcpy(buffer, fOrigColors, fColorCount * sizeof(SkColor));
 706     buffer += fColorCount;
 707     if (fColorCount > 2) {
 708         for (int i = 1; i < fColorCount; i++) {
 709             *buffer++ = fRecs[i].fPos;
 710         }
 711     }
 712     *buffer++ = fGradFlags;
 713     *buffer++ = static_cast<int32_t>(bitmapType);
 714     SkASSERT(buffer - storage.get() == count);
 715
 716     ///////////////////////////////////
 717
 718     static SkGradientBitmapCache* gCache;
 719     // each cache cost 1K or 2K of RAM, since each bitmap will be 1x256 at either 32bpp or 64bpp
 720     static const int MAX_NUM_CACHED_GRADIENT_BITMAPS = 32;
 721     SkAutoMutexAcquire ama(gGradientCacheMutex);
 722
 723     if (nullptr == gCache) {
 724         gCache = new SkGradientBitmapCache(MAX_NUM_CACHED_GRADIENT_BITMAPS);
 725     }
 726     size_t size = count * sizeof(int32_t);
 727
 728     if (!gCache->find(storage.get(), size, bitmap)) {
 729         if (GradientBitmapType::kLegacy == bitmapType) {
 730             // force our cache32pixelref to be built
 731             (void)cache->getCache32();
 732             bitmap->setInfo(SkImageInfo::MakeN32Premul(kCache32Count, 1));
 733             bitmap->setPixelRef(cache->getCache32PixelRef());
 734         } else {
 735             // For these cases we use the bitmap cache, but not the GradientShaderCache. So just
 736             // allocate and populate the bitmap's data directly.
 737
 738             SkImageInfo info;
 739             switch (bitmapType) {
 740                 case GradientBitmapType::kSRGB:
 741                     info = SkImageInfo::Make(kCache32Count, 1, kRGBA_8888_SkColorType,
 742                                              kPremul_SkAlphaType,
 743                                              SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named));
 744                     break;
 745                 case GradientBitmapType::kHalfFloat:
 746                     info = SkImageInfo::Make(
 747                         kCache32Count, 1, kRGBA_F16_SkColorType, kPremul_SkAlphaType,
 748                         SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named));
 749                     break;
 750                 default:
 751                     SkFAIL("Unexpected bitmap type");
 752                     return;
 753             }
 754             bitmap->allocPixels(info);
 755             this->initLinearBitmap(bitmap);
 756         }
 757         gCache->add(storage.get(), size, *bitmap);
 758     }
 759 }
 760
 761 void SkGradientShaderBase::commonAsAGradient(GradientInfo* info, bool flipGrad) const {
 762     if (info) {
 763         if (info->fColorCount >= fColorCount) {
 764             SkColor* colorLoc;
 765             Rec*     recLoc;
 766             if (flipGrad && (info->fColors || info->fColorOffsets)) {
 767                 SkAutoSTArray<8, SkColor> colorStorage(fColorCount);
 768                 SkAutoSTArray<8, Rec> recStorage(fColorCount);
 769                 colorLoc = colorStorage.get();
 770                 recLoc = recStorage.get();
 771                 FlipGradientColors(colorLoc, recLoc, fOrigColors, fRecs, fColorCount);
 772             } else {
 773                 colorLoc = fOrigColors;
 774                 recLoc = fRecs;
 775             }
 776             if (info->fColors) {
 777                 memcpy(info->fColors, colorLoc, fColorCount * sizeof(SkColor));
 778             }
 779             if (info->fColorOffsets) {
 780                 if (fColorCount == 2) {
 781                     info->fColorOffsets[0] = 0;
 782                     info->fColorOffsets[1] = SK_Scalar1;
 783                 } else if (fColorCount > 2) {
 784                     for (int i = 0; i < fColorCount; ++i) {
 785                         info->fColorOffsets[i] = SkFixedToScalar(recLoc[i].fPos);
 786                     }
 787                 }
 788             }
 789         }
 790         info->fColorCount = fColorCount;
 791         info->fTileMode = fTileMode;
 792         info->fGradientFlags = fGradFlags;
 793     }
 794 }
 795
 796 #ifndef SK_IGNORE_TO_STRING
 797 void SkGradientShaderBase::toString(SkString* str) const {
 798
 799     str->appendf("%d colors: ", fColorCount);
 800
 801     for (int i = 0; i < fColorCount; ++i) {
 802         str->appendHex(fOrigColors[i], 8);
 803         if (i < fColorCount-1) {
 804             str->append(", ");
 805         }
 806     }
 807
 808     if (fColorCount > 2) {
 809         str->append(" points: (");
 810         for (int i = 0; i < fColorCount; ++i) {
 811             str->appendScalar(SkFixedToScalar(fRecs[i].fPos));
 812             if (i < fColorCount-1) {
 813                 str->append(", ");
 814             }
 815         }
 816         str->append(")");
 817     }
 818
 819     static const char* gTileModeName[SkShader::kTileModeCount] = {
 820         "clamp", "repeat", "mirror"
 821     };
 822
 823     str->append(" ");
 824     str->append(gTileModeName[fTileMode]);
 825
 826     this->INHERITED::toString(str);
 827 }
 828 #endif
 829
 830 ///////////////////////////////////////////////////////////////////////////////
 831 ///////////////////////////////////////////////////////////////////////////////
 832
 833 // Return true if these parameters are valid/legal/safe to construct a gradient
 834 //
 835 static bool valid_grad(const SkColor4f colors[], const SkScalar pos[], int count,
 836                        unsigned tileMode) {
 837     return nullptr != colors && count >= 1 && tileMode < (unsigned)SkShader::kTileModeCount;
 838 }
 839
 840 static void desc_init(SkGradientShaderBase::Descriptor* desc,
 841                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
 842                       const SkScalar pos[], int colorCount,
 843                       SkShader::TileMode mode, uint32_t flags, const SkMatrix* localMatrix) {
 844     SkASSERT(colorCount > 1);
 845
 846     desc->fColors       = colors;
 847     desc->fColorSpace   = std::move(colorSpace);
 848     desc->fPos          = pos;
 849     desc->fCount        = colorCount;
 850     desc->fTileMode     = mode;
 851     desc->fGradFlags    = flags;
 852     desc->fLocalMatrix  = localMatrix;
 853 }
 854
 855 // assumes colors is SkColor4f* and pos is SkScalar*
 856 #define EXPAND_1_COLOR(count)                \
 857      SkColor4f tmp[2];                       \
 858      do {                                    \
 859          if (1 == count) {                   \
 860              tmp[0] = tmp[1] = colors[0];    \
 861              colors = tmp;                   \
 862              pos = nullptr;                  \
 863              count = 2;                      \
 864          }                                   \
 865      } while (0)
 866
 867 struct ColorStopOptimizer {
 868     ColorStopOptimizer(const SkColor4f* colors, const SkScalar* pos,
 869                        int count, SkShader::TileMode mode)
 870         : fColors(colors)
 871         , fPos(pos)
 872         , fCount(count) {
 873
 874             if (!pos || count != 3) {
 875                 return;
 876             }
 877
 878             if (SkScalarNearlyEqual(pos[0], 0.0f) &&
 879                 SkScalarNearlyEqual(pos[1], 0.0f) &&
 880                 SkScalarNearlyEqual(pos[2], 1.0f)) {
 881
 882                 if (SkShader::kRepeat_TileMode == mode ||
 883                     SkShader::kMirror_TileMode == mode ||
 884                     colors[0] == colors[1]) {
 885
 886                     // Ignore the leftmost color/pos.
 887                     fColors += 1;
 888                     fPos    += 1;
 889                     fCount   = 2;
 890                 }
 891             } else if (SkScalarNearlyEqual(pos[0], 0.0f) &&
 892                        SkScalarNearlyEqual(pos[1], 1.0f) &&
 893                        SkScalarNearlyEqual(pos[2], 1.0f)) {
 894
 895                 if (SkShader::kRepeat_TileMode == mode ||
 896                     SkShader::kMirror_TileMode == mode ||
 897                     colors[1] == colors[2]) {
 898
 899                     // Ignore the rightmost color/pos.
 900                     fCount  = 2;
 901                 }
 902             }
 903     }
 904
 905     const SkColor4f* fColors;
 906     const SkScalar*  fPos;
 907     int              fCount;
 908 };
 909
 910 struct ColorConverter {
 911     ColorConverter(const SkColor* colors, int count) {
 912         for (int i = 0; i < count; ++i) {
 913             fColors4f.push_back(SkColor4f::FromColor(colors[i]));
 914         }
 915     }
 916
 917     SkSTArray<2, SkColor4f, true> fColors4f;
 918 };
 919
 920 sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
 921                                              const SkColor colors[],
 922                                              const SkScalar pos[], int colorCount,
 923                                              SkShader::TileMode mode,
 924                                              uint32_t flags,
 925                                              const SkMatrix* localMatrix) {
 926     ColorConverter converter(colors, colorCount);
 927     return MakeLinear(pts, converter.fColors4f.begin(), nullptr, pos, colorCount, mode, flags,
 928                       localMatrix);
 929 }
 930
 931 sk_sp<SkShader> SkGradientShader::MakeLinear(const SkPoint pts[2],
 932                                              const SkColor4f colors[],
 933                                              sk_sp<SkColorSpace> colorSpace,
 934                                              const SkScalar pos[], int colorCount,
 935                                              SkShader::TileMode mode,
 936                                              uint32_t flags,
 937                                              const SkMatrix* localMatrix) {
 938     if (!pts || !SkScalarIsFinite((pts[1] - pts[0]).length())) {
 939         return nullptr;
 940     }
 941     if (!valid_grad(colors, pos, colorCount, mode)) {
 942         return nullptr;
 943     }
 944     if (1 == colorCount) {
 945         return SkShader::MakeColorShader(colors[0], std::move(colorSpace));
 946     }
 947
 948     ColorStopOptimizer opt(colors, pos, colorCount, mode);
 949
 950     SkGradientShaderBase::Descriptor desc;
 951     desc_init(&desc, opt.fColors, std::move(colorSpace), opt.fPos, opt.fCount, mode, flags,
 952               localMatrix);
 953     return sk_make_sp<SkLinearGradient>(pts, desc);
 954 }
 955
 956 sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius,
 957                                              const SkColor colors[],
 958                                              const SkScalar pos[], int colorCount,
 959                                              SkShader::TileMode mode,
 960                                              uint32_t flags,
 961                                              const SkMatrix* localMatrix) {
 962     ColorConverter converter(colors, colorCount);
 963     return MakeRadial(center, radius, converter.fColors4f.begin(), nullptr, pos, colorCount, mode,
 964                       flags, localMatrix);
 965 }
 966
 967 sk_sp<SkShader> SkGradientShader::MakeRadial(const SkPoint& center, SkScalar radius,
 968                                              const SkColor4f colors[],
 969                                              sk_sp<SkColorSpace> colorSpace,
 970                                              const SkScalar pos[], int colorCount,
 971                                              SkShader::TileMode mode,
 972                                              uint32_t flags,
 973                                              const SkMatrix* localMatrix) {
 974     if (radius <= 0) {
 975         return nullptr;
 976     }
 977     if (!valid_grad(colors, pos, colorCount, mode)) {
 978         return nullptr;
 979     }
 980     if (1 == colorCount) {
 981         return SkShader::MakeColorShader(colors[0], std::move(colorSpace));
 982     }
 983
 984     ColorStopOptimizer opt(colors, pos, colorCount, mode);
 985
 986     SkGradientShaderBase::Descriptor desc;
 987     desc_init(&desc, opt.fColors, std::move(colorSpace), opt.fPos, opt.fCount, mode, flags,
 988               localMatrix);
 989     return sk_make_sp<SkRadialGradient>(center, radius, desc);
 990 }
 991
 992 sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start,
 993                                                       SkScalar startRadius,
 994                                                       const SkPoint& end,
 995                                                       SkScalar endRadius,
 996                                                       const SkColor colors[],
 997                                                       const SkScalar pos[],
 998                                                       int colorCount,
 999                                                       SkShader::TileMode mode,
1000                                                       uint32_t flags,
1001                                                       const SkMatrix* localMatrix) {
1002     ColorConverter converter(colors, colorCount);
1003     return MakeTwoPointConical(start, startRadius, end, endRadius, converter.fColors4f.begin(),
1004                                nullptr, pos, colorCount, mode, flags, localMatrix);
1005 }
1006
1007 sk_sp<SkShader> SkGradientShader::MakeTwoPointConical(const SkPoint& start,
1008                                                       SkScalar startRadius,
1009                                                       const SkPoint& end,
1010                                                       SkScalar endRadius,
1011                                                       const SkColor4f colors[],
1012                                                       sk_sp<SkColorSpace> colorSpace,
1013                                                       const SkScalar pos[],
1014                                                       int colorCount,
1015                                                       SkShader::TileMode mode,
1016                                                       uint32_t flags,
1017                                                       const SkMatrix* localMatrix) {
1018     if (startRadius < 0 || endRadius < 0) {
1019         return nullptr;
1020     }
1021     if (!valid_grad(colors, pos, colorCount, mode)) {
1022         return nullptr;
1023     }
1024     if (startRadius == endRadius) {
1025         if (start == end || startRadius == 0) {
1026             return SkShader::MakeEmptyShader();
1027         }
1028     }
1029     EXPAND_1_COLOR(colorCount);
1030
1031     ColorStopOptimizer opt(colors, pos, colorCount, mode);
1032
1033     bool flipGradient = startRadius > endRadius;
1034
1035     SkGradientShaderBase::Descriptor desc;
1036
1037     if (!flipGradient) {
1038         desc_init(&desc, opt.fColors, std::move(colorSpace), opt.fPos, opt.fCount, mode, flags,
1039                   localMatrix);
1040         return sk_make_sp<SkTwoPointConicalGradient>(start, startRadius, end, endRadius,
1041                                                      flipGradient, desc);
1042     } else {
1043         SkAutoSTArray<8, SkColor4f> colorsNew(opt.fCount);
1044         SkAutoSTArray<8, SkScalar> posNew(opt.fCount);
1045         for (int i = 0; i < opt.fCount; ++i) {
1046             colorsNew[i] = opt.fColors[opt.fCount - i - 1];
1047         }
1048
1049         if (pos) {
1050             for (int i = 0; i < opt.fCount; ++i) {
1051                 posNew[i] = 1 - opt.fPos[opt.fCount - i - 1];
1052             }
1053             desc_init(&desc, colorsNew.get(), std::move(colorSpace), posNew.get(), opt.fCount, mode,
1054                       flags, localMatrix);
1055         } else {
1056             desc_init(&desc, colorsNew.get(), std::move(colorSpace), nullptr, opt.fCount, mode,
1057                       flags, localMatrix);
1058         }
1059
1060         return sk_make_sp<SkTwoPointConicalGradient>(end, endRadius, start, startRadius,
1061                                                      flipGradient, desc);
1062     }
1063 }
1064
1065 sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy,
1066                                             const SkColor colors[],
1067                                             const SkScalar pos[],
1068                                             int colorCount,
1069                                             uint32_t flags,
1070                                             const SkMatrix* localMatrix) {
1071     ColorConverter converter(colors, colorCount);
1072     return MakeSweep(cx, cy, converter.fColors4f.begin(), nullptr, pos, colorCount, flags,
1073                      localMatrix);
1074 }
1075
1076 sk_sp<SkShader> SkGradientShader::MakeSweep(SkScalar cx, SkScalar cy,
1077                                             const SkColor4f colors[],
1078                                             sk_sp<SkColorSpace> colorSpace,
1079                                             const SkScalar pos[],
1080                                             int colorCount,
1081                                             uint32_t flags,
1082                                             const SkMatrix* localMatrix) {
1083     if (!valid_grad(colors, pos, colorCount, SkShader::kClamp_TileMode)) {
1084         return nullptr;
1085     }
1086     if (1 == colorCount) {
1087         return SkShader::MakeColorShader(colors[0], std::move(colorSpace));
1088     }
1089
1090     auto mode = SkShader::kClamp_TileMode;
1091
1092     ColorStopOptimizer opt(colors, pos, colorCount, mode);
1093
1094     SkGradientShaderBase::Descriptor desc;
1095     desc_init(&desc, opt.fColors, std::move(colorSpace), opt.fPos, opt.fCount, mode, flags,
1096               localMatrix);
1097     return sk_make_sp<SkSweepGradient>(cx, cy, desc);
1098 }
1099
1100 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkGradientShader)
1101     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLinearGradient)
1102     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkRadialGradient)
1103     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSweepGradient)
1104     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkTwoPointConicalGradient)
1105 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END
1106
1107 ///////////////////////////////////////////////////////////////////////////////
1108
1109 #if SK_SUPPORT_GPU
1110
1111 #include "GrContext.h"
1112 #include "GrInvariantOutput.h"
1113 #include "GrShaderCaps.h"
1114 #include "GrTextureStripAtlas.h"
1115 #include "gl/GrGLContext.h"
1116 #include "glsl/GrGLSLColorSpaceXformHelper.h"
1117 #include "glsl/GrGLSLFragmentShaderBuilder.h"
1118 #include "glsl/GrGLSLProgramDataManager.h"
1119 #include "glsl/GrGLSLUniformHandler.h"
1120 #include "SkGr.h"
1121
1122 static inline bool close_to_one_half(const SkFixed& val) {
1123     return SkScalarNearlyEqual(SkFixedToScalar(val), SK_ScalarHalf);
1124 }
1125
1126 static inline int color_type_to_color_count(GrGradientEffect::ColorType colorType) {
1127     switch (colorType) {
1128 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1129         case GrGradientEffect::kSingleHardStop_ColorType:
1130             return 4;
1131         case GrGradientEffect::kHardStopLeftEdged_ColorType:
1132         case GrGradientEffect::kHardStopRightEdged_ColorType:
1133             return 3;
1134 #endif
1135         case GrGradientEffect::kTwo_ColorType:
1136             return 2;
1137         case GrGradientEffect::kThree_ColorType:
1138             return 3;
1139         case GrGradientEffect::kTexture_ColorType:
1140             return 0;
1141     }
1142
1143     SkDEBUGFAIL("Unhandled ColorType in color_type_to_color_count()");
1144     return -1;
1145 }
1146
1147 GrGradientEffect::ColorType GrGradientEffect::determineColorType(
1148         const SkGradientShaderBase& shader) {
1149 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1150     if (shader.fOrigPos) {
1151         if (4 == shader.fColorCount) {
1152             if (SkScalarNearlyEqual(shader.fOrigPos[0], 0.0f) &&
1153                 SkScalarNearlyEqual(shader.fOrigPos[1], shader.fOrigPos[2]) &&
1154                 SkScalarNearlyEqual(shader.fOrigPos[3], 1.0f)) {
1155
1156                 return kSingleHardStop_ColorType;
1157             }
1158         } else if (3 == shader.fColorCount) {
1159             if (SkScalarNearlyEqual(shader.fOrigPos[0], 0.0f) &&
1160                 SkScalarNearlyEqual(shader.fOrigPos[1], 0.0f) &&
1161                 SkScalarNearlyEqual(shader.fOrigPos[2], 1.0f)) {
1162
1163                 return kHardStopLeftEdged_ColorType;
1164             } else if (SkScalarNearlyEqual(shader.fOrigPos[0], 0.0f) &&
1165                        SkScalarNearlyEqual(shader.fOrigPos[1], 1.0f) &&
1166                        SkScalarNearlyEqual(shader.fOrigPos[2], 1.0f)) {
1167
1168                 return kHardStopRightEdged_ColorType;
1169             }
1170         }
1171     }
1172 #endif
1173
1174     if (SkShader::kClamp_TileMode == shader.getTileMode()) {
1175         if (2 == shader.fColorCount) {
1176             return kTwo_ColorType;
1177         } else if (3 == shader.fColorCount &&
1178                    close_to_one_half(shader.getRecs()[1].fPos)) {
1179             return kThree_ColorType;
1180         }
1181     }
1182
1183     return kTexture_ColorType;
1184 }
1185
1186 void GrGradientEffect::GLSLProcessor::emitUniforms(GrGLSLUniformHandler* uniformHandler,
1187                                                    const GrGradientEffect& ge) {
1188     if (int colorCount = color_type_to_color_count(ge.getColorType())) {
1189         fColorsUni = uniformHandler->addUniformArray(kFragment_GrShaderFlag,
1190                                                      kVec4f_GrSLType,
1191                                                      kDefault_GrSLPrecision,
1192                                                      "Colors",
1193                                                      colorCount);
1194         if (ge.fColorType == kSingleHardStop_ColorType) {
1195             fHardStopT = uniformHandler->addUniform(kFragment_GrShaderFlag, kFloat_GrSLType,
1196                                                     kDefault_GrSLPrecision, "HardStopT");
1197         }
1198     } else {
1199         fFSYUni = uniformHandler->addUniform(kFragment_GrShaderFlag,
1200                                              kFloat_GrSLType, kDefault_GrSLPrecision,
1201                                              "GradientYCoordFS");
1202     }
1203 }
1204
1205 static inline void set_after_interp_color_uni_array(
1206                                                   const GrGLSLProgramDataManager& pdman,
1207                                                   const GrGLSLProgramDataManager::UniformHandle uni,
1208                                                   const SkTDArray<SkColor4f>& colors,
1209                                                   const GrColorSpaceXform* colorSpaceXform) {
1210     int count = colors.count();
1211     if (colorSpaceXform) {
1212         constexpr int kSmallCount = 10;
1213         SkAutoSTArray<4 * kSmallCount, float> vals(4 * count);
1214
1215         for (int i = 0; i < count; i++) {
1216             colorSpaceXform->srcToDst().mapScalars(colors[i].vec(), &vals[4 * i]);
1217         }
1218
1219         pdman.set4fv(uni, count, vals.get());
1220     } else {
1221         pdman.set4fv(uni, count, (float*)&colors[0]);
1222     }
1223 }
1224
1225 static inline void set_before_interp_color_uni_array(
1226                                                   const GrGLSLProgramDataManager& pdman,
1227                                                   const GrGLSLProgramDataManager::UniformHandle uni,
1228                                                   const SkTDArray<SkColor4f>& colors,
1229                                                   const GrColorSpaceXform* colorSpaceXform) {
1230     int count = colors.count();
1231     constexpr int kSmallCount = 10;
1232     SkAutoSTArray<4 * kSmallCount, float> vals(4 * count);
1233
1234     for (int i = 0; i < count; i++) {
1235         float a = colors[i].fA;
1236         vals[4 * i + 0] = colors[i].fR * a;
1237         vals[4 * i + 1] = colors[i].fG * a;
1238         vals[4 * i + 2] = colors[i].fB * a;
1239         vals[4 * i + 3] = a;
1240     }
1241
1242     if (colorSpaceXform) {
1243         for (int i = 0; i < count; i++) {
1244             colorSpaceXform->srcToDst().mapScalars(&vals[4 * i]);
1245         }
1246     }
1247
1248     pdman.set4fv(uni, count, vals.get());
1249 }
1250
1251 static inline void set_after_interp_color_uni_array(const GrGLSLProgramDataManager& pdman,
1252                                        const GrGLSLProgramDataManager::UniformHandle uni,
1253                                        const SkTDArray<SkColor>& colors) {
1254     int count = colors.count();
1255     constexpr int kSmallCount = 10;
1256
1257     SkAutoSTArray<4*kSmallCount, float> vals(4*count);
1258
1259     for (int i = 0; i < colors.count(); i++) {
1260         // RGBA
1261         vals[4*i + 0] = SkColorGetR(colors[i]) / 255.f;
1262         vals[4*i + 1] = SkColorGetG(colors[i]) / 255.f;
1263         vals[4*i + 2] = SkColorGetB(colors[i]) / 255.f;
1264         vals[4*i + 3] = SkColorGetA(colors[i]) / 255.f;
1265     }
1266
1267     pdman.set4fv(uni, colors.count(), vals.get());
1268 }
1269
1270 static inline void set_before_interp_color_uni_array(const GrGLSLProgramDataManager& pdman,
1271                                               const GrGLSLProgramDataManager::UniformHandle uni,
1272                                               const SkTDArray<SkColor>& colors) {
1273     int count = colors.count();
1274     constexpr int kSmallCount = 10;
1275
1276     SkAutoSTArray<4*kSmallCount, float> vals(4*count);
1277
1278     for (int i = 0; i < count; i++) {
1279         float a = SkColorGetA(colors[i]) / 255.f;
1280         float aDiv255 = a / 255.f;
1281
1282         // RGBA
1283         vals[4*i + 0] = SkColorGetR(colors[i]) * aDiv255;
1284         vals[4*i + 1] = SkColorGetG(colors[i]) * aDiv255;
1285         vals[4*i + 2] = SkColorGetB(colors[i]) * aDiv255;
1286         vals[4*i + 3] = a;
1287     }
1288
1289     pdman.set4fv(uni, count, vals.get());
1290 }
1291
1292 void GrGradientEffect::GLSLProcessor::onSetData(const GrGLSLProgramDataManager& pdman,
1293                                                 const GrProcessor& processor) {
1294     const GrGradientEffect& e = processor.cast<GrGradientEffect>();
1295
1296     switch (e.getColorType()) {
1297 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1298         case GrGradientEffect::kSingleHardStop_ColorType:
1299             pdman.set1f(fHardStopT, e.fPositions[1]);
1300             // fall through
1301         case GrGradientEffect::kHardStopLeftEdged_ColorType:
1302         case GrGradientEffect::kHardStopRightEdged_ColorType:
1303 #endif
1304         case GrGradientEffect::kTwo_ColorType:
1305         case GrGradientEffect::kThree_ColorType: {
1306             if (e.fColors4f.count() > 0) {
1307                 // Gamma-correct / color-space aware
1308                 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
1309                     set_before_interp_color_uni_array(pdman, fColorsUni, e.fColors4f,
1310                                                       e.fColorSpaceXform.get());
1311                 } else {
1312                     set_after_interp_color_uni_array(pdman, fColorsUni, e.fColors4f,
1313                                                      e.fColorSpaceXform.get());
1314                 }
1315             } else {
1316                 // Legacy mode. Would be nice if we had converted the 8-bit colors to float earlier
1317                 if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
1318                     set_before_interp_color_uni_array(pdman, fColorsUni, e.fColors);
1319                 } else {
1320                     set_after_interp_color_uni_array(pdman, fColorsUni, e.fColors);
1321                 }
1322             }
1323
1324             break;
1325         }
1326
1327         case GrGradientEffect::kTexture_ColorType: {
1328             SkScalar yCoord = e.getYCoord();
1329             if (yCoord != fCachedYCoord) {
1330                 pdman.set1f(fFSYUni, yCoord);
1331                 fCachedYCoord = yCoord;
1332             }
1333             if (SkToBool(e.fColorSpaceXform)) {
1334                 pdman.setSkMatrix44(fColorSpaceXformUni, e.fColorSpaceXform->srcToDst());
1335             }
1336             break;
1337         }
1338     }
1339 }
1340
1341 uint32_t GrGradientEffect::GLSLProcessor::GenBaseGradientKey(const GrProcessor& processor) {
1342     const GrGradientEffect& e = processor.cast<GrGradientEffect>();
1343
1344     uint32_t key = 0;
1345
1346     if (GrGradientEffect::kBeforeInterp_PremulType == e.getPremulType()) {
1347         key |= kPremulBeforeInterpKey;
1348     }
1349
1350     if (GrGradientEffect::kTwo_ColorType == e.getColorType()) {
1351         key |= kTwoColorKey;
1352     } else if (GrGradientEffect::kThree_ColorType == e.getColorType()) {
1353         key |= kThreeColorKey;
1354     }
1355 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1356     else if (GrGradientEffect::kSingleHardStop_ColorType == e.getColorType()) {
1357         key |= kHardStopCenteredKey;
1358     } else if (GrGradientEffect::kHardStopLeftEdged_ColorType == e.getColorType()) {
1359         key |= kHardStopZeroZeroOneKey;
1360     } else if (GrGradientEffect::kHardStopRightEdged_ColorType == e.getColorType()) {
1361         key |= kHardStopZeroOneOneKey;
1362     }
1363
1364     if (SkShader::TileMode::kClamp_TileMode == e.fTileMode) {
1365         key |= kClampTileMode;
1366     } else if (SkShader::TileMode::kRepeat_TileMode == e.fTileMode) {
1367         key |= kRepeatTileMode;
1368     } else {
1369         key |= kMirrorTileMode;
1370     }
1371 #endif
1372
1373     key |= GrColorSpaceXform::XformKey(e.fColorSpaceXform.get()) << kReservedBits;
1374
1375     return key;
1376 }
1377
1378 void GrGradientEffect::GLSLProcessor::emitColor(GrGLSLFPFragmentBuilder* fragBuilder,
1379                                                 GrGLSLUniformHandler* uniformHandler,
1380                                                 const GrShaderCaps* shaderCaps,
1381                                                 const GrGradientEffect& ge,
1382                                                 const char* gradientTValue,
1383                                                 const char* outputColor,
1384                                                 const char* inputColor,
1385                                                 const TextureSamplers& texSamplers) {
1386     switch (ge.getColorType()) {
1387 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1388         case kSingleHardStop_ColorType: {
1389             const char* t      = gradientTValue;
1390             const char* colors = uniformHandler->getUniformCStr(fColorsUni);
1391             const char* stopT = uniformHandler->getUniformCStr(fHardStopT);
1392
1393             fragBuilder->codeAppendf("float clamp_t = clamp(%s, 0.0, 1.0);", t);
1394
1395             // Account for tile mode
1396             if (SkShader::kRepeat_TileMode == ge.fTileMode) {
1397                 fragBuilder->codeAppendf("clamp_t = fract(%s);", t);
1398             } else if (SkShader::kMirror_TileMode == ge.fTileMode) {
1399                 fragBuilder->codeAppendf("if (%s < 0.0 || %s > 1.0) {", t, t);
1400                 fragBuilder->codeAppendf("    if (mod(floor(%s), 2.0) == 0.0) {", t);
1401                 fragBuilder->codeAppendf("        clamp_t = fract(%s);", t);
1402                 fragBuilder->codeAppendf("    } else {");
1403                 fragBuilder->codeAppendf("        clamp_t = 1.0 - fract(%s);", t);
1404                 fragBuilder->codeAppendf("    }");
1405                 fragBuilder->codeAppendf("}");
1406             }
1407
1408             // Calculate color
1409             fragBuilder->codeAppend ("vec4 start, end;");
1410             fragBuilder->codeAppend ("float relative_t;");
1411             fragBuilder->codeAppendf("if (clamp_t < %s) {", stopT);
1412             fragBuilder->codeAppendf("    start = %s[0];", colors);
1413             fragBuilder->codeAppendf("    end   = %s[1];", colors);
1414             fragBuilder->codeAppendf("    relative_t = clamp_t / %s;", stopT);
1415             fragBuilder->codeAppend ("} else {");
1416             fragBuilder->codeAppendf("    start = %s[2];", colors);
1417             fragBuilder->codeAppendf("    end   = %s[3];", colors);
1418             fragBuilder->codeAppendf("    relative_t = (clamp_t - %s) / (1 - %s);", stopT, stopT);
1419             fragBuilder->codeAppend ("}");
1420             fragBuilder->codeAppend ("vec4 colorTemp = mix(start, end, relative_t);");
1421
1422             if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
1423                 fragBuilder->codeAppend("colorTemp.rgb *= colorTemp.a;");
1424             }
1425             fragBuilder->codeAppendf("%s = %s;", outputColor,
1426                                      (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str());
1427
1428             break;
1429         }
1430
1431         case kHardStopLeftEdged_ColorType: {
1432             const char* t      = gradientTValue;
1433             const char* colors = uniformHandler->getUniformCStr(fColorsUni);
1434
1435             fragBuilder->codeAppendf("float clamp_t = clamp(%s, 0.0, 1.0);", t);
1436
1437             // Account for tile mode
1438             if (SkShader::kRepeat_TileMode == ge.fTileMode) {
1439                 fragBuilder->codeAppendf("clamp_t = fract(%s);", t);
1440             } else if (SkShader::kMirror_TileMode == ge.fTileMode) {
1441                 fragBuilder->codeAppendf("if (%s < 0.0 || %s > 1.0) {", t, t);
1442                 fragBuilder->codeAppendf("    if (mod(floor(%s), 2.0) == 0.0) {", t);
1443                 fragBuilder->codeAppendf("        clamp_t = fract(%s);", t);
1444                 fragBuilder->codeAppendf("    } else {");
1445                 fragBuilder->codeAppendf("        clamp_t = 1.0 - fract(%s);", t);
1446                 fragBuilder->codeAppendf("    }");
1447                 fragBuilder->codeAppendf("}");
1448             }
1449
1450             fragBuilder->codeAppendf("vec4 colorTemp = mix(%s[1], %s[2], clamp_t);", colors,
1451                                      colors);
1452             if (SkShader::kClamp_TileMode == ge.fTileMode) {
1453                 fragBuilder->codeAppendf("if (%s < 0.0) {", t);
1454                 fragBuilder->codeAppendf("    colorTemp = %s[0];", colors);
1455                 fragBuilder->codeAppendf("}");
1456             }
1457
1458             if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
1459                 fragBuilder->codeAppend("colorTemp.rgb *= colorTemp.a;");
1460             }
1461             fragBuilder->codeAppendf("%s = %s;", outputColor,
1462                                      (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str());
1463
1464             break;
1465         }
1466
1467         case kHardStopRightEdged_ColorType: {
1468             const char* t      = gradientTValue;
1469             const char* colors = uniformHandler->getUniformCStr(fColorsUni);
1470
1471             fragBuilder->codeAppendf("float clamp_t = clamp(%s, 0.0, 1.0);", t);
1472
1473             // Account for tile mode
1474             if (SkShader::kRepeat_TileMode == ge.fTileMode) {
1475                 fragBuilder->codeAppendf("clamp_t = fract(%s);", t);
1476             } else if (SkShader::kMirror_TileMode == ge.fTileMode) {
1477                 fragBuilder->codeAppendf("if (%s < 0.0 || %s > 1.0) {", t, t);
1478                 fragBuilder->codeAppendf("    if (mod(floor(%s), 2.0) == 0.0) {", t);
1479                 fragBuilder->codeAppendf("        clamp_t = fract(%s);", t);
1480                 fragBuilder->codeAppendf("    } else {");
1481                 fragBuilder->codeAppendf("        clamp_t = 1.0 - fract(%s);", t);
1482                 fragBuilder->codeAppendf("    }");
1483                 fragBuilder->codeAppendf("}");
1484             }
1485
1486             fragBuilder->codeAppendf("vec4 colorTemp = mix(%s[0], %s[1], clamp_t);", colors,
1487                                      colors);
1488             if (SkShader::kClamp_TileMode == ge.fTileMode) {
1489                 fragBuilder->codeAppendf("if (%s > 1.0) {", t);
1490                 fragBuilder->codeAppendf("    colorTemp = %s[2];", colors);
1491                 fragBuilder->codeAppendf("}");
1492             }
1493
1494             if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
1495                 fragBuilder->codeAppend("colorTemp.rgb *= colorTemp.a;");
1496             }
1497             fragBuilder->codeAppendf("%s = %s;", outputColor,
1498                                      (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str());
1499
1500             break;
1501         }
1502 #endif
1503
1504         case kTwo_ColorType: {
1505             const char* t      = gradientTValue;
1506             const char* colors = uniformHandler->getUniformCStr(fColorsUni);
1507
1508             fragBuilder->codeAppendf("vec4 colorTemp = mix(%s[0], %s[1], clamp(%s, 0.0, 1.0));",
1509                                      colors, colors, t);
1510
1511             // We could skip this step if both colors are known to be opaque. Two
1512             // considerations:
1513             // The gradient SkShader reporting opaque is more restrictive than necessary in the two
1514             // pt case. Make sure the key reflects this optimization (and note that it can use the
1515             // same shader as thekBeforeIterp case). This same optimization applies to the 3 color
1516             // case below.
1517             if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
1518                 fragBuilder->codeAppend("colorTemp.rgb *= colorTemp.a;");
1519             }
1520
1521             fragBuilder->codeAppendf("%s = %s;", outputColor,
1522                                      (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str());
1523
1524             break;
1525         }
1526
1527         case kThree_ColorType: {
1528             const char* t      = gradientTValue;
1529             const char* colors = uniformHandler->getUniformCStr(fColorsUni);
1530
1531             fragBuilder->codeAppendf("float oneMinus2t = 1.0 - (2.0 * %s);", t);
1532             fragBuilder->codeAppendf("vec4 colorTemp = clamp(oneMinus2t, 0.0, 1.0) * %s[0];",
1533                                      colors);
1534             if (!shaderCaps->canUseMinAndAbsTogether()) {
1535                 // The Tegra3 compiler will sometimes never return if we have
1536                 // min(abs(oneMinus2t), 1.0), or do the abs first in a separate expression.
1537                 fragBuilder->codeAppendf("float minAbs = abs(oneMinus2t);");
1538                 fragBuilder->codeAppendf("minAbs = minAbs > 1.0 ? 1.0 : minAbs;");
1539                 fragBuilder->codeAppendf("colorTemp += (1.0 - minAbs) * %s[1];", colors);
1540             } else {
1541                 fragBuilder->codeAppendf("colorTemp += (1.0 - min(abs(oneMinus2t), 1.0)) * %s[1];",
1542                                          colors);
1543             }
1544             fragBuilder->codeAppendf("colorTemp += clamp(-oneMinus2t, 0.0, 1.0) * %s[2];", colors);
1545
1546             if (GrGradientEffect::kAfterInterp_PremulType == ge.getPremulType()) {
1547                 fragBuilder->codeAppend("colorTemp.rgb *= colorTemp.a;");
1548             }
1549
1550             fragBuilder->codeAppendf("%s = %s;", outputColor,
1551                                      (GrGLSLExpr4(inputColor) * GrGLSLExpr4("colorTemp")).c_str());
1552
1553             break;
1554         }
1555
1556         case kTexture_ColorType: {
1557             GrGLSLColorSpaceXformHelper colorSpaceHelper(uniformHandler, ge.fColorSpaceXform.get(),
1558                                                          &fColorSpaceXformUni);
1559
1560             const char* fsyuni = uniformHandler->getUniformCStr(fFSYUni);
1561
1562             fragBuilder->codeAppendf("vec2 coord = vec2(%s, %s);", gradientTValue, fsyuni);
1563             fragBuilder->codeAppendf("%s = ", outputColor);
1564             fragBuilder->appendTextureLookupAndModulate(inputColor, texSamplers[0], "coord",
1565                                                         kVec2f_GrSLType, &colorSpaceHelper);
1566             fragBuilder->codeAppend(";");
1567
1568             break;
1569         }
1570     }
1571 }
1572
1573 /////////////////////////////////////////////////////////////////////
1574
1575 GrGradientEffect::GrGradientEffect(const CreateArgs& args) {
1576     const SkGradientShaderBase& shader(*args.fShader);
1577
1578     fIsOpaque = shader.isOpaque();
1579
1580     fColorType = this->determineColorType(shader);
1581     fColorSpaceXform = std::move(args.fColorSpaceXform);
1582
1583     if (kTexture_ColorType != fColorType) {
1584         SkASSERT(shader.fOrigColors && shader.fOrigColors4f);
1585         if (args.fGammaCorrect) {
1586             fColors4f = SkTDArray<SkColor4f>(shader.fOrigColors4f, shader.fColorCount);
1587         } else {
1588             fColors = SkTDArray<SkColor>(shader.fOrigColors, shader.fColorCount);
1589         }
1590
1591 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1592         if (shader.fOrigPos) {
1593             fPositions = SkTDArray<SkScalar>(shader.fOrigPos, shader.fColorCount);
1594         }
1595 #endif
1596     }
1597
1598 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1599     fTileMode = args.fTileMode;
1600 #endif
1601
1602     switch (fColorType) {
1603         // The two and three color specializations do not currently support tiling.
1604         case kTwo_ColorType:
1605         case kThree_ColorType:
1606 #if GR_GL_USE_ACCURATE_HARD_STOP_GRADIENTS
1607         case kHardStopLeftEdged_ColorType:
1608         case kHardStopRightEdged_ColorType:
1609         case kSingleHardStop_ColorType:
1610 #endif
1611             fRow = -1;
1612
1613             if (SkGradientShader::kInterpolateColorsInPremul_Flag & shader.getGradFlags()) {
1614                 fPremulType = kBeforeInterp_PremulType;
1615             } else {
1616                 fPremulType = kAfterInterp_PremulType;
1617             }
1618
1619             fCoordTransform.reset(*args.fMatrix);
1620
1621             break;
1622         case kTexture_ColorType:
1623             // doesn't matter how this is set, just be consistent because it is part of the
1624             // effect key.
1625             fPremulType = kBeforeInterp_PremulType;
1626
1627             SkGradientShaderBase::GradientBitmapType bitmapType =
1628                 SkGradientShaderBase::GradientBitmapType::kLegacy;
1629             if (args.fGammaCorrect) {
1630                 // Try to use F16 if we can
1631                 if (args.fContext->caps()->isConfigTexturable(kRGBA_half_GrPixelConfig)) {
1632                     bitmapType = SkGradientShaderBase::GradientBitmapType::kHalfFloat;
1633                 } else if (args.fContext->caps()->isConfigTexturable(kSRGBA_8888_GrPixelConfig)) {
1634                     bitmapType = SkGradientShaderBase::GradientBitmapType::kSRGB;
1635                 } else {
1636                     // This can happen, but only if someone explicitly creates an unsupported
1637                     // (eg sRGB) surface. Just fall back to legacy behavior.
1638                 }
1639             }
1640
1641             SkBitmap bitmap;
1642             shader.getGradientTableBitmap(&bitmap, bitmapType);
1643
1644             GrTextureStripAtlas::Desc desc;
1645             desc.fWidth  = bitmap.width();
1646             desc.fHeight = 32;
1647             desc.fRowHeight = bitmap.height();
1648             desc.fContext = args.fContext;
1649             desc.fConfig = SkImageInfo2GrPixelConfig(bitmap.info(), *args.fContext->caps());
1650             fAtlas = GrTextureStripAtlas::GetAtlas(desc);
1651             SkASSERT(fAtlas);
1652
1653             // We always filter the gradient table. Each table is one row of a texture, always
1654             // y-clamp.
1655             GrSamplerParams params;
1656             params.setFilterMode(GrSamplerParams::kBilerp_FilterMode);
1657             params.setTileModeX(args.fTileMode);
1658
1659             fRow = fAtlas->lockRow(bitmap);
1660             if (-1 != fRow) {
1661                 fYCoord = fAtlas->getYOffset(fRow)+SK_ScalarHalf*fAtlas->getNormalizedTexelHeight();
1662                 fCoordTransform.reset(*args.fMatrix, fAtlas->getTexture(), params.filterMode());
1663                 fTextureSampler.reset(fAtlas->getTexture(), params);
1664             } else {
1665                 sk_sp<GrTexture> texture(GrRefCachedBitmapTexture(args.fContext, bitmap, params));
1666                 if (!texture) {
1667                     return;
1668                 }
1669                 fCoordTransform.reset(*args.fMatrix, texture.get(), params.filterMode());
1670                 fTextureSampler.reset(texture.get(), params);
1671                 fYCoord = SK_ScalarHalf;
1672             }
1673
1674             this->addTextureSampler(&fTextureSampler);
1675
1676             break;
1677     }
1678
1679     this->addCoordTransform(&fCoordTransform);
1680 }
1681
1682 GrGradientEffect::~GrGradientEffect() {
1683     if (this->useAtlas()) {
1684         fAtlas->unlockRow(fRow);
1685     }
1686 }
1687
1688 bool GrGradientEffect::onIsEqual(const GrFragmentProcessor& processor) const {
1689     const GrGradientEffect& ge = processor.cast<GrGradientEffect>();
1690
1691     if (this->fColorType != ge.getColorType()) {
1692         return false;
1693     }
1694     SkASSERT(this->useAtlas() == ge.useAtlas());
1695     if (kTexture_ColorType == fColorType) {
1696         if (fYCoord != ge.getYCoord()) {
1697             return false;
1698         }
1699     } else {
1700         if (kSingleHardStop_ColorType == fColorType) {
1701             if (!SkScalarNearlyEqual(ge.fPositions[1], fPositions[1])) {
1702                 return false;
1703             }
1704         }
1705         if (this->getPremulType() != ge.getPremulType() ||
1706             this->fColors.count() != ge.fColors.count() ||
1707             this->fColors4f.count() != ge.fColors4f.count()) {
1708             return false;
1709         }
1710
1711         for (int i = 0; i < this->fColors.count(); i++) {
1712             if (*this->getColors(i) != *ge.getColors(i)) {
1713                 return false;
1714             }
1715         }
1716         for (int i = 0; i < this->fColors4f.count(); i++) {
1717             if (*this->getColors4f(i) != *ge.getColors4f(i)) {
1718                 return false;
1719             }
1720         }
1721     }
1722     return GrColorSpaceXform::Equals(this->fColorSpaceXform.get(), ge.fColorSpaceXform.get());
1723 }
1724
1725 void GrGradientEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
1726     if (fIsOpaque) {
1727         inout->mulByUnknownOpaqueFourComponents();
1728     } else {
1729         inout->mulByUnknownFourComponents();
1730     }
1731 }
1732
1733 GrGradientEffect::RandomGradientParams::RandomGradientParams(SkRandom* random) {
1734     fColorCount = random->nextRangeU(1, kMaxRandomGradientColors);
1735     fUseColors4f = random->nextBool();
1736
1737     // if one color, omit stops, otherwise randomly decide whether or not to
1738     if (fColorCount == 1 || (fColorCount >= 2 && random->nextBool())) {
1739         fStops = nullptr;
1740     } else {
1741         fStops = fStopStorage;
1742     }
1743
1744     // if using SkColor4f, attach a random (possibly null) color space (with linear gamma)
1745     if (fUseColors4f) {
1746         fColorSpace = GrTest::TestColorSpace(random);
1747         if (fColorSpace) {
1748             SkASSERT(SkColorSpace_Base::Type::kXYZ == as_CSB(fColorSpace)->type());
1749             fColorSpace = static_cast<SkColorSpace_XYZ*>(fColorSpace.get())->makeLinearGamma();
1750         }
1751     }
1752
1753     SkScalar stop = 0.f;
1754     for (int i = 0; i < fColorCount; ++i) {
1755         if (fUseColors4f) {
1756             fColors4f[i].fR = random->nextUScalar1();
1757             fColors4f[i].fG = random->nextUScalar1();
1758             fColors4f[i].fB = random->nextUScalar1();
1759             fColors4f[i].fA = random->nextUScalar1();
1760         } else {
1761             fColors[i] = random->nextU();
1762         }
1763         if (fStops) {
1764             fStops[i] = stop;
1765             stop = i < fColorCount - 1 ? stop + random->nextUScalar1() * (1.f - stop) : 1.f;
1766         }
1767     }
1768     fTileMode = static_cast<SkShader::TileMode>(random->nextULessThan(SkShader::kTileModeCount));
1769 }
1770
1771 #endif