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