improve precision of gradients

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 86 matching lines @@
             // 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;
         }
     }
 }
 
 #define NO_CHECK_ITER               \
     do {                            \
-    unsigned fi = fx >> SkGradientShaderBase::kCache32Shift; \
+    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, SkFixed dx, SkFixed fx,
+typedef void (*LinearShadeProc)(TileProc proc, SkGradFixed dx, SkGradFixed 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, SkFixed dx, SkFixed fx,
+void shadeSpan_linear_vertical_lerp(TileProc proc, SkGradFixed dx, SkGradFixed 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(fx);
+    unsigned fullIndex = proc(SkGradFixedToFixed(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, SkFixed dx, SkFixed fx,
+void shadeSpan_linear_clamp(TileProc proc, SkGradFixed dx, SkGradFixed 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);
 
     if ((count = range.fCount0) > 0) {
         sk_memset32_dither(dstC,
             cache[toggle + range.fV0],
             cache[next_dither_toggle(toggle) + range.fV0],
@@ skipping 16 matching lines @@
         }
     }
     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, SkFixed dx, SkFixed fx,
+void shadeSpan_linear_mirror(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                              SkPMColor* SK_RESTRICT dstC,
                              const SkPMColor* SK_RESTRICT cache,
                              int toggle, int count) {
     do {
-        unsigned fi = mirror_8bits(fx >> 8);
+        unsigned fi = mirror_8bits(SkGradFixedToFixed(fx) >> 8);
         SkASSERT(fi <= 0xFF);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle(toggle);
     } while (--count != 0);
 }
 
-void shadeSpan_linear_repeat(TileProc proc, SkFixed dx, SkFixed fx,
+void shadeSpan_linear_repeat(TileProc proc, SkGradFixed dx, SkGradFixed fx,
         SkPMColor* SK_RESTRICT dstC,
         const SkPMColor* SK_RESTRICT cache,
         int toggle, int count) {
     do {
-        unsigned fi = repeat_8bits(fx >> 8);
+        unsigned fi = repeat_8bits(SkGradFixedToFixed(fx) >> 8);
         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,
                                                         int count) {
     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);
 
     if (fDstToIndexClass != kPerspective_MatrixClass) {
         dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
                              SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-        SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
+        SkGradFixed dx, fx = SkScalarToGradFixed(srcPt.fX);
 
         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
             SkFixed dxStorage[1];
             (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), dxStorage, NULL);
-            dx = dxStorage[0];
+            // todo: do we need a real/high-precision value for dx here?
+            dx = SkFixedToGradFixed(dxStorage[0]);
         } else {
             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
-            dx = SkScalarToFixed(fDstToIndex.getScaleX());
+            dx = SkScalarToGradFixed(fDstToIndex.getScaleX());
         }
 
         LinearShadeProc shadeProc = shadeSpan_linear_repeat;
         if (0 == 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 {
@@ skipping 49 matching lines @@
 
     sk_memset32((uint32_t*)dst, (value << 16) | other, count >> 1);
 
     if (count & 1) {
         dst[count - 1] = value;
     }
 }
 
 #define NO_CHECK_ITER_16                \
     do {                                \
-    unsigned fi = fx >> SkGradientShaderBase::kCache16Shift;  \
+    unsigned fi = SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache16Shift;  \
     SkASSERT(fi < SkGradientShaderBase::kCache16Count);       \
     fx += dx;                           \
     *dstC++ = cache[toggle + fi];       \
     toggle = next_dither_toggle16(toggle);            \
     } while (0)
 
 namespace {
 
-typedef void (*LinearShade16Proc)(TileProc proc, SkFixed dx, SkFixed fx,
+typedef void (*LinearShade16Proc)(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                                   uint16_t* dstC, const uint16_t* cache,
                                   int toggle, int count);
 
-void shadeSpan16_linear_vertical(TileProc proc, SkFixed dx, SkFixed fx,
+void shadeSpan16_linear_vertical(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                                  uint16_t* SK_RESTRICT dstC,
                                  const uint16_t* SK_RESTRICT cache,
                                  int toggle, int count) {
     // we're a vertical gradient, so no change in a span
-    unsigned fi = proc(fx) >> SkGradientShaderBase::kCache16Shift;
+    unsigned fi = proc(SkGradFixedToFixed(fx)) >> SkGradientShaderBase::kCache16Shift;
     SkASSERT(fi < SkGradientShaderBase::kCache16Count);
     dither_memset16(dstC, cache[toggle + fi],
         cache[next_dither_toggle16(toggle) + fi], count);
 }
 
-void shadeSpan16_linear_clamp(TileProc proc, SkFixed dx, SkFixed fx,
+void shadeSpan16_linear_clamp(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                               uint16_t* SK_RESTRICT dstC,
                               const uint16_t* SK_RESTRICT cache,
                               int toggle, int count) {
     SkClampRange range;
     range.init(fx, dx, count, 0, SkGradientShaderBase::kCache32Count - 1);
 
     if ((count = range.fCount0) > 0) {
         dither_memset16(dstC,
             cache[toggle + range.fV0],
             cache[next_dither_toggle16(toggle) + range.fV0],
@@ skipping 16 matching lines @@
         }
     }
     if ((count = range.fCount2) > 0) {
         dither_memset16(dstC,
             cache[toggle + range.fV1],
             cache[next_dither_toggle16(toggle) + range.fV1],
             count);
     }
 }
 
-void shadeSpan16_linear_mirror(TileProc proc, SkFixed dx, SkFixed fx,
+void shadeSpan16_linear_mirror(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                                uint16_t* SK_RESTRICT dstC,
                                const uint16_t* SK_RESTRICT cache,
                                int toggle, int count) {
     do {
-        unsigned fi = mirror_bits(fx >> SkGradientShaderBase::kCache16Shift,
+        unsigned fi = mirror_bits(SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache16Shift,
                                         SkGradientShaderBase::kCache16Bits);
         SkASSERT(fi < SkGradientShaderBase::kCache16Count);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle16(toggle);
     } while (--count != 0);
 }
 
-void shadeSpan16_linear_repeat(TileProc proc, SkFixed dx, SkFixed fx,
+void shadeSpan16_linear_repeat(TileProc proc, SkGradFixed dx, SkGradFixed fx,
                                uint16_t* SK_RESTRICT dstC,
                                const uint16_t* SK_RESTRICT cache,
                                int toggle, int count) {
     do {
-        unsigned fi = repeat_bits(fx >> SkGradientShaderBase::kCache16Shift,
+        unsigned fi = repeat_bits(SkGradFixedToFixed(fx) >> SkGradientShaderBase::kCache16Shift,
                                   SkGradientShaderBase::kCache16Bits);
         SkASSERT(fi < SkGradientShaderBase::kCache16Count);
         fx += dx;
         *dstC++ = cache[toggle + fi];
         toggle = next_dither_toggle16(toggle);
     } while (--count != 0);
 }
 }
 
 static bool fixed_nearly_zero(SkFixed x) {
     return SkAbs32(x) < (SK_Fixed1 >> 12);
 }
 
 void SkLinearGradient::LinearGradientContext::shadeSpan16(int x, int y,
                                                           uint16_t* SK_RESTRICT dstC, int count) {
     SkASSERT(count > 0);
 
     const SkLinearGradient& linearGradient = static_cast<const SkLinearGradient&>(fShader);
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = linearGradient.fTileProc;
     const uint16_t* SK_RESTRICT cache = fCache->getCache16();
     int                 toggle = init_dither_toggle16(x, y);
 
     if (fDstToIndexClass != kPerspective_MatrixClass) {
         dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
                              SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-        SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
+        SkGradFixed dx, fx = SkScalarToGradFixed(srcPt.fX);
 
         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
             SkFixed dxStorage[1];
             (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), dxStorage, NULL);
-            dx = dxStorage[0];
+            // todo: do we need a real/high-precision value for dx here?
+            dx = SkFixedToGradFixed(dxStorage[0]);
         } else {
             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
-            dx = SkScalarToFixed(fDstToIndex.getScaleX());
+            dx = SkScalarToGradFixed(fDstToIndex.getScaleX());
         }
 
         LinearShade16Proc shadeProc = shadeSpan16_linear_repeat;
-        if (fixed_nearly_zero(dx)) {
+        if (fixed_nearly_zero(SkGradFixedToFixed(dx))) {
             shadeProc = shadeSpan16_linear_vertical;
         } else if (SkShader::kClamp_TileMode == linearGradient.fTileMode) {
             shadeProc = shadeSpan16_linear_clamp;
         } else if (SkShader::kMirror_TileMode == linearGradient.fTileMode) {
             shadeProc = shadeSpan16_linear_mirror;
         } else {
             SkASSERT(SkShader::kRepeat_TileMode == linearGradient.fTileMode);
         }
         (*shadeProc)(proc, dx, fx, dstC, cache, toggle, count);
     } else {
@@ skipping 166 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