Implement multi-color-stops in linear gradients using Sk4f

src/effects/gradients/SkLinearGradient.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLinearGradient.h"
 
 static inline int repeat_bits(int x, const int bits) {
@@ skipping 82 matching lines @@
     unsigned mask = SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask;
     if ((fDstToIndex.getType() & ~mask) == 0) {
         // when we dither, we are (usually) not const-in-Y
         if ((fFlags & SkShader::kHasSpan16_Flag) && !rec.fPaint->isDither()) {
             // only claim this if we do have a 16bit mode (i.e. none of our
             // colors have alpha), and if we are not dithering (which obviously
             // is not const in Y).
             fFlags |= SkShader::kConstInY16_Flag;
         }
     }
+
+    // setup for Sk4f
+    int count = shader.fColorCount;
+    fColorCount = count;
+    fColors4 = new Sk4f[count];
+    fPos = new float[count * 2];
+    fPosScale = fPos + count;
+    if (shader.fOrigPos) {
+        fPos[0] = 0;
+        fPosScale[0] = 0;   // should never get used
+        for (int i = 1; i < count; ++i) {
+            fPos[i] = SkTMin(SkTMax(fPos[i - 1], shader.fOrigPos[i]), 1.0f);
+            fPosScale[i] = 1.0f / (fPos[i] - fPos[i - 1]);
+        }
+        fPos[count - 1] = 1;    // overwrite the last value just to be sure we end at 1.0
+    } else {
+        float invScale = 1.0f / (count - 1);
+        for (int i = 0; i < count; ++i) {
+            fPos[i] = i * invScale;
+            fPosScale[i] = count - 1;
+        }
+    }
+    for (int i = 0; i < count; ++i) {
+        SkPMColor pmc = SkPreMultiplyColor(shader.fOrigColors[i]);
+        fColors4[i] = Sk4f::FromBytes((const uint8_t*)&pmc);
+        if (i > 0) {
+            SkASSERT(fPos[i - 1] <= fPos[i]);
+        }
+    }
 }
 
+SkLinearGradient::LinearGradientContext::~LinearGradientContext() {
+    delete[] fPos;
+    delete[] fColors4;
+}
+
 #define NO_CHECK_ITER               \
     do {                            \
     unsigned fi = SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache32Shift; \
     SkASSERT(fi <= 0xFF);           \
     fx += dx;                       \
     *dstC++ = cache[toggle + fi];   \
     toggle = next_dither_toggle(toggle); \
     } while (0)
 
 namespace {
@@ skipping 89 matching lines @@
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle(toggle);
     } while (--count != 0);
 }
 
 }
 
 void SkLinearGradient::LinearGradientContext::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC,
                                                         int count) {
+    if (true) {
+        this->shadeSpan4(x, y, dstC, count);
+        return;
+    }
+
     SkASSERT(count > 0);
 
     const SkLinearGradient& linearGradient = static_cast<const SkLinearGradient&>(fShader);
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = linearGradient.fTileProc;
     const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
     int                 toggle = init_dither_toggle(x, y);
 
@@ skipping 345 matching lines @@
     str->append("SkLinearGradient (");
 
     str->appendf("start: (%f, %f)", fStart.fX, fStart.fY);
     str->appendf(" end: (%f, %f) ", fEnd.fX, fEnd.fY);
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "SkNx.h"
+
+#if 0
+static Sk4f premul(const Sk4f& x) {
+    return x * scale_rgb(x.kth<SK_A32_SHIFT/8>());
+}
+
+static Sk4f unpremul(const Sk4f& x) {
+    return x * scale_rgb(1 / x.kth<SK_A32_SHIFT/8>());  // TODO: fast/approx invert?
+}
+
+static Sk4f clamp_0_1(const Sk4f& x) {
+    return Sk4f::Max(Sk4f::Min(x, Sk4f(1)), Sk4f(0));
+}
+#endif
+
+static SkPMColor round_from_255(const Sk4f& x) {
+    SkPMColor c;
+    (x + Sk4f(0.5f)).toBytes((uint8_t*)&c);
+    return c;
+}
+
+static Sk4f lerp(Sk4f a, Sk4f b, float t) {
+    return a + Sk4f(t) * (b - a);
+}
+
+static int find(float tiledX, const float pos[], int count) {
+    SkASSERT(count > 1);
+    SkASSERT(0 == pos[0]);
+    SkASSERT(1 == pos[count - 1]);
+    SkASSERT(tiledX >= 0 && tiledX <= 1);
+
+    int i = 1;
+    while (pos[i] < tiledX) {
+        i += 1;
+    }
+    return i - 1;
+}
+
+/*
+ *  TODOs
+ *
+ *  - tilemodes
+ *  - interp before or after premul
+ *  - apply paint's alpha (available when we create the context
+ *  - perspective
+ *  - dithering
+ *  - optimizations
+ *      - even spacing (how common is that?)
+ *      - use fixed (32bit or 16bit) instead of floats?
+ */
+void SkLinearGradient::LinearGradientContext::shadeSpan4(int x, int y, SkPMColor* SK_RESTRICT dstC,
+                                                         int count) {
+    SkASSERT(count > 0);
+    
+    const Sk4f* colors4 = fColors4;
+    const float* pos = fPos;
+    const float* posScale = fPosScale;
+
+    SkPoint             srcPt;
+    SkMatrix::MapXYProc dstProc = fDstToIndexProc;
+//    int                 toggle = init_dither_toggle(x, y);
+
+    float dx, fx;
+    if (fDstToIndexClass != kPerspective_MatrixClass || true) {
+        dstProc(fDstToIndex, x + SK_ScalarHalf, y + SK_ScalarHalf, &srcPt);
+        fx = srcPt.x();
+        
+        if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
+            SkFixed dxStorage[1];
+            (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), dxStorage, nullptr);
+            // todo: do we need a real/high-precision value for dx here?
+            dx = SkFixedToFloat(dxStorage[0]);
+        } else {
+            SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
+            dx = fDstToIndex.getScaleX();
+        }
+    }
+
+    int prevIndex = 0;
+    for (int i = 0; i < count; ++i) {
+        float tiledX = fx;
+        
+        // Apply the TileMode
+        if (tiledX < 0) {
+            tiledX = 0;
+        }
+        if (tiledX > 1) {
+            tiledX = 1;
+        }
+
+        // Are we in the same relative interval, or do we need to search
+        if (pos[prevIndex] > tiledX || tiledX > pos[prevIndex + 1]) {

[f(malita), 2015/11/11 05:14:16]

What if instead of projecting the span pixels onto the gradient vector (t
space?), we map the gradient colors/stops onto the span vector?

I think that would mean

1) we know exactly how many span pixels we can shade before we hit the next stop

2) for a given interval, the color differential is constant (and the division
can be hoisted out of the inner loop)

Basically my initial/uneducated float gradient idea looks like this:

while (span not done) {
  interval = nextInterval(); // magic method returning interval a) start color,
b) end color, c) len (mapped onto the current span vector, capped to count)


  // interval color gradient
  dC = (interval.endColor - interval.startColor) / interval.len;

  c = interval.startColor;
  foreach (span pixel in interval) {
     dstC[i++] = c;
     c += dC;
  }
}

+            prevIndex = find(tiledX, pos, fColorCount);
+        }
+
+        // Compute the color
+        float t = (fx - pos[prevIndex]) * posScale[prevIndex + 1];
+        Sk4f c = lerp(colors4[prevIndex], colors4[prevIndex + 1], t);
+        dstC[i] = round_from_255(c);
+
+        fx += dx;
+    }
+}
+