Use float rather than SkFixed for gradient TileProcs.

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 "math.h"
+
 #include "Sk4fLinearGradient.h"
 #include "SkLinearGradient.h"
 
 // define to test the 4f gradient path
 // #define FORCE_4F_CONTEXT
 
 static const float kInv255Float = 1.0f / 255;
 
-static inline int repeat_8bits(int x) {
-    return x & 0xFF;
+static inline int repeat_8bits(float x) {
+    float ignore;
+    const float frac = modff(x, &ignore);
+    return (int)(frac * 256) & 0xFF;
 }
 
 // Visual Studio 2010 (MSC_VER=1600) optimizes bit-shift code incorrectly.
 // See http://code.google.com/p/skia/issues/detail?id=472
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
 #pragma optimize("", off)
 #endif
 
-static inline int mirror_8bits(int x) {
-    if (x & 256) {
-        x = ~x;
+static inline int mirror_8bits(float x) {
+    const float x_mod_2 = fmod(x, 2.0f);
+    int x_9bits = (int)(x_mod_2 * 256);
+    if (x_9bits & 0x100) {
+        x_9bits = ~x_9bits;
     }
-    return x & 255;
+    return x_9bits & 0xFF;
 }
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1600)
 #pragma optimize("", on)
 #endif
 
 static SkMatrix pts_to_unit_matrix(const SkPoint pts[2]) {
     SkVector    vec = pts[1] - pts[0];
     SkScalar    mag = vec.length();
     SkScalar    inv = mag ? SkScalarInvert(mag) : 0;
@@ skipping 139 matching lines @@
     do {                            \
     unsigned fi = SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache32Shift; \
     SkASSERT(fi <= 0xFF);           \
     fx += dx;                       \
     *dstC++ = cache[toggle + fi];   \
     toggle = next_dither_toggle(toggle); \
     } while (0)
 
 namespace {
 
-typedef void (*LinearShadeProc)(TileProc proc, SkGradFixed dx, SkGradFixed fx,
+typedef void (*LinearShadeProc)(TileProc proc, float dx, float fx,
                                 SkPMColor* dstC, const SkPMColor* cache,
                                 int toggle, int count);
 
 // Linear interpolation (lerp) is unnecessary if there are no sharp
 // discontinuities in the gradient - which must be true if there are
 // only 2 colors - but it's cheap.
-void shadeSpan_linear_vertical_lerp(TileProc proc, SkGradFixed dx, SkGradFixed fx,
+void shadeSpan_linear_vertical_lerp(TileProc proc, float dx, float fx,
                                     SkPMColor* SK_RESTRICT dstC,
                                     const SkPMColor* SK_RESTRICT cache,
                                     int toggle, int count) {
     // We're a vertical gradient, so no change in a span.
     // If colors change sharply across the gradient, dithering is
     // insufficient (it subsamples the color space) and we need to lerp.
-    unsigned fullIndex = proc(SkGradFixedToFixed(fx));
+    unsigned fullIndex = proc(fx);
     unsigned fi = fullIndex >> SkGradientShaderBase::kCache32Shift;
     unsigned remainder = fullIndex & ((1 << SkGradientShaderBase::kCache32Shift) - 1);
 
     int index0 = fi + toggle;
     int index1 = index0;
     if (fi < SkGradientShaderBase::kCache32Count - 1) {
         index1 += 1;
     }
     SkPMColor lerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
     index0 ^= SkGradientShaderBase::kDitherStride32;
     index1 ^= SkGradientShaderBase::kDitherStride32;
     SkPMColor dlerp = SkFastFourByteInterp(cache[index1], cache[index0], remainder);
     sk_memset32_dither(dstC, lerp, dlerp, count);
 }
 
-void shadeSpan_linear_clamp(TileProc proc, SkGradFixed dx, SkGradFixed fx,
+void shadeSpan_linear_clamp(TileProc proc, float float_dx, float float_fx,
                             SkPMColor* SK_RESTRICT dstC,
                             const SkPMColor* SK_RESTRICT cache,
                             int toggle, int count) {
     SkClampRange range;
-    range.init(fx, dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
+    range.init(float_fx, float_dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
     range.validate(count);
 
     if ((count = range.fCount0) > 0) {
         sk_memset32_dither(dstC,
             cache[toggle + range.fV0],
             cache[next_dither_toggle(toggle) + range.fV0],
             count);
         dstC += count;
     }
     if ((count = range.fCount1) > 0) {
         int unroll = count >> 3;
-        fx = range.fFx1;
+        SkGradFixed fx = range.fFx1;
+        const SkGradFixed dx = SkFloatToGradFixed(float_dx);
         for (int i = 0; i < unroll; i++) {
             NO_CHECK_ITER;  NO_CHECK_ITER;
             NO_CHECK_ITER;  NO_CHECK_ITER;
             NO_CHECK_ITER;  NO_CHECK_ITER;
             NO_CHECK_ITER;  NO_CHECK_ITER;
         }
         if ((count &= 7) > 0) {
             do {
                 NO_CHECK_ITER;
             } while (--count != 0);
         }
     }
     if ((count = range.fCount2) > 0) {
         sk_memset32_dither(dstC,
             cache[toggle + range.fV1],
             cache[next_dither_toggle(toggle) + range.fV1],
             count);
     }
 }
 
-void shadeSpan_linear_mirror(TileProc proc, SkGradFixed dx, SkGradFixed fx,
+void shadeSpan_linear_mirror(TileProc proc, float dx, float fx,
                              SkPMColor* SK_RESTRICT dstC,
                              const SkPMColor* SK_RESTRICT cache,
                              int toggle, int count) {
     do {
-        unsigned fi = mirror_8bits(SkGradFixedToFixed(fx) >> 8);
+        unsigned fi = mirror_8bits(fx);
         SkASSERT(fi <= 0xFF);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle(toggle);
     } while (--count != 0);
 }
 
-void shadeSpan_linear_repeat(TileProc proc, SkGradFixed dx, SkGradFixed fx,
+void shadeSpan_linear_repeat(TileProc proc, float dx, float fx,
         SkPMColor* SK_RESTRICT dstC,
         const SkPMColor* SK_RESTRICT cache,
         int toggle, int count) {
     do {
-        unsigned fi = repeat_8bits(SkGradFixedToFixed(fx) >> 8);
+        unsigned fi = repeat_8bits(fx);
         SkASSERT(fi <= 0xFF);
         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,
@@ skipping 13 matching lines @@
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = linearGradient.fTileProc;
     const SkPMColor* SK_RESTRICT cache = fCache->getCache32();
     int                 toggle = init_dither_toggle(x, y);
 
     if (fDstToIndexClass != kPerspective_MatrixClass) {
         dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
                              SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-        SkGradFixed dx, fx = SkScalarToGradFixed(srcPt.fX);
+        float dx, fx = SkScalarToFloat(srcPt.fX);
 
         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
             const auto step = fDstToIndex.fixedStepInX(SkIntToScalar(y));
-            // todo: do we need a real/high-precision value for dx here?
-            dx = SkScalarToGradFixed(step.fX);
+            dx = SkScalarToFloat(step.fX);
         } else {
             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
-            dx = SkScalarToGradFixed(fDstToIndex.getScaleX());
+            dx = SkScalarToFloat(fDstToIndex.getScaleX());
         }
 
         LinearShadeProc shadeProc = shadeSpan_linear_repeat;
-        if (0 == dx) {
+        if (SkScalarNearlyZero(dx)) {
             shadeProc = shadeSpan_linear_vertical_lerp;
         } else if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
             shadeProc = shadeSpan_linear_clamp;
         } else if (SkShader::kMirror_TileMode == linearGradient.fTileMode) {
             shadeProc = shadeSpan_linear_mirror;
         } else {
             SkASSERT(SkShader::kRepeat_TileMode == linearGradient.fTileMode);
         }
         (*shadeProc)(proc, dx, fx, dstC, cache, toggle, count);
     } else {
         SkScalar    dstX = SkIntToScalar(x);
         SkScalar    dstY = SkIntToScalar(y);
         do {
             dstProc(fDstToIndex, dstX, dstY, &srcPt);
-            unsigned fi = proc(SkScalarToFixed(srcPt.fX));
+            unsigned fi = proc(SkScalarToFloat(srcPt.fX));
             SkASSERT(fi <= 0xFFFF);
             *dstC++ = cache[toggle + (fi >> kCache32Shift)];
             toggle = next_dither_toggle(toggle);
             dstX += SK_Scalar1;
         } while (--count != 0);
     }
 }
 
 SkShader::GradientType SkLinearGradient::asAGradient(GradientInfo* info) const {
     if (info) {
@@ skipping 414 matching lines @@
             this->shade4_dx_clamp<false, true>(dstC, count, fx, dx, invDx, dither);
         }
     } else {
         if (fApplyAlphaAfterInterp) {
             this->shade4_dx_clamp<true, false>(dstC, count, fx, dx, invDx, dither);
         } else {
             this->shade4_dx_clamp<false, false>(dstC, count, fx, dx, invDx, dither);
         }
     }
 }