use Sk4f to increase radial gradient precision but same or better speed

src/effects/gradients/SkRadialGradient.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 "SkRadialGradient.h"
 #include "SkRadialGradient_Table.h"
+#include "SkNx.h"
 
 #define kSQRT_TABLE_BITS    11
 #define kSQRT_TABLE_SIZE    (1 << kSQRT_TABLE_BITS)
 
 SK_COMPILE_ASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE, SqrtTableSizesMatch);
 
 #if 0
 
 #include <stdio.h>
 
@@ skipping 242 matching lines @@
 
 void SkRadialGradient::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writePoint(fCenter);
     buffer.writeScalar(fRadius);
 }
 
 namespace {
 
 inline bool radial_completely_pinned(int fx, int dx, int fy, int dy) {
-    // fast, overly-conservative test: checks unit square instead
-    // of unit circle
-    bool xClamped = (fx >= SK_FixedHalf && dx >= 0) ||
-                    (fx <= -SK_FixedHalf && dx <= 0);
-    bool yClamped = (fy >= SK_FixedHalf && dy >= 0) ||
-                    (fy <= -SK_FixedHalf && dy <= 0);
-
+    // fast, overly-conservative test: checks unit square instead of unit circle
+    bool xClamped = (fx >= SK_FixedHalf && dx >= 0) || (fx <= -SK_FixedHalf && dx <= 0);
+    bool yClamped = (fy >= SK_FixedHalf && dy >= 0) || (fy <= -SK_FixedHalf && dy <= 0);
     return xClamped || yClamped;
 }
 
+inline bool radial_completely_pinned(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy) {
+    // fast, overly-conservative test: checks unit square instead of unit circle
+    bool xClamped = (fx >= 1 && dx >= 0) || (fx <= -1 && dx <= 0);
+    bool yClamped = (fy >= 1 && dy >= 0) || (fy <= -1 && dy <= 0);
+    return xClamped || yClamped;
+}
+
 // Return true if (fx * fy) is always inside the unit circle
 // SkPin32 is expensive, but so are all the SkFixedMul in this test,
 // so it shouldn't be run if count is small.
 inline bool no_need_for_radial_pin(int fx, int dx,
                                           int fy, int dy, int count) {
     SkASSERT(count > 0);
     if (SkAbs32(fx) > 0x7FFF || SkAbs32(fy) > 0x7FFF) {
         return false;
     }
     if (fx*fx + fy*fy > 0x7FFF*0x7FFF) {
@@ skipping 73 matching lines @@
                 *dstC++ = cache[toggle + (sqrt_table[fi] >>
                     SkGradientShaderBase::kSqrt32Shift)];
                 toggle = next_dither_toggle(toggle);
                 fx += dx;
                 fy += dy;
             } while (--count != 0);
         }
     }
 }
 
+// TODO: can we get away with 0th approximatino of inverse-sqrt (i.e. faster than rsqrt)?
+//       seems like ~10bits is more than enough for our use, since we want a byte-index
+static inline Sk4f fast_sqrt(const Sk4f& R) {
+    return R * R.rsqrt();
+}
+
+static inline Sk4f sum_squares(const Sk4f& a, const Sk4f& b) {
+    return a * a + b * b;
+}
+
+void shadeSpan_radial_clamp2(SkScalar sfx, SkScalar sdx, SkScalar sfy, SkScalar sdy,
+                             SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
+                             int count, int toggle) {
+    if (radial_completely_pinned(sfx, sdx, sfy, sdy)) {
+        unsigned fi = SkGradientShaderBase::kCache32Count - 1;
+        sk_memset32_dither(dstC,
+                           cache[toggle + fi],
+                           cache[next_dither_toggle(toggle) + fi],
+                           count);
+    } else {
+        const Sk4f max(255);
+        const float scale = 255;
+        sfx *= scale;
+        sfy *= scale;
+        sdx *= scale;
+        sdy *= scale;
+        const Sk4f fx4(sfx, sfx + sdx, sfx + 2*sdx, sfx + 3*sdx);
+        const Sk4f fy4(sfy, sfy + sdy, sfy + 2*sdy, sfy + 3*sdy);
+        const Sk4f dx4(sdx * 4);
+        const Sk4f dy4(sdy * 4);
+
+        Sk4f tmpxy = fx4 * dx4 + fy4 * dy4;
+        Sk4f tmpdxdy = sum_squares(dx4, dy4);
+        Sk4f R = sum_squares(fx4, fy4);
+        Sk4f dR = tmpxy + tmpxy + tmpdxdy;
+        const Sk4f ddR = tmpdxdy + tmpdxdy;
+
+        for (int i = 0; i < (count >> 2); ++i) {
+            Sk4f dist = Sk4f::Min(fast_sqrt(R), max);
+            R += dR;
+            dR += ddR;
+
+            unsigned fi0 = (unsigned)dist.kth<0>(); SkASSERT(fi0 < 256);
+            unsigned fi1 = (unsigned)dist.kth<1>(); SkASSERT(fi1 < 256);
+            unsigned fi2 = (unsigned)dist.kth<2>(); SkASSERT(fi2 < 256);
+            unsigned fi3 = (unsigned)dist.kth<3>(); SkASSERT(fi3 < 256);
+            *dstC++ = cache[toggle + fi0]; toggle = next_dither_toggle(toggle);
+            *dstC++ = cache[toggle + fi1]; toggle = next_dither_toggle(toggle);
+            *dstC++ = cache[toggle + fi2]; toggle = next_dither_toggle(toggle);
+            *dstC++ = cache[toggle + fi3]; toggle = next_dither_toggle(toggle);
+        }
+        count &= 3;
+        if (count) {
+            Sk4f dist = Sk4f::Min(fast_sqrt(R), max);
+            unsigned fi[3];
+            fi[0] = (unsigned)dist.kth<0>();
+            fi[1] = (unsigned)dist.kth<1>();
+            fi[2] = (unsigned)dist.kth<2>();
+            SkASSERT(count <= 3);
+            for (int i = 0; i < count; ++i) {
+                SkASSERT(fi[i] < 256);
+                *dstC++ = cache[toggle + fi[i]]; toggle = next_dither_toggle(toggle);
+            }
+        }
+    }
+}
+
 // Unrolling this loop doesn't seem to help (when float); we're stalling to
 // get the results of the sqrt (?), and don't have enough extra registers to
 // have many in flight.
 template <SkFixed (*TileProc)(SkFixed)>
 void shadeSpan_radial(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
                       SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
                       int count, int toggle) {
     do {
         const SkFixed dist = SkFloatToFixed(sk_float_sqrt(fx*fx + fy*fy));
         const unsigned fi = TileProc(dist);
@@ skipping 14 matching lines @@
 void shadeSpan_radial_repeat(SkScalar fx, SkScalar dx, SkScalar fy, SkScalar dy,
                              SkPMColor* SK_RESTRICT dstC, const SkPMColor* SK_RESTRICT cache,
                              int count, int toggle) {
     shadeSpan_radial<repeat_tileproc_nonstatic>(fx, dx, fy, dy, dstC, cache, count, toggle);
 }
 
 }  // namespace
 
 void SkRadialGradient::RadialGradientContext::shadeSpan(int x, int y,
                                                         SkPMColor* SK_RESTRICT dstC, int count) {
+#ifdef SK_SUPPORT_LEGACY_RADIAL_GRADIENT_SQRT
+    const bool use_new_proc = false;
+#else
+    const bool use_new_proc = true;
+#endif
     SkASSERT(count > 0);
 
     const SkRadialGradient& radialGradient = static_cast<const SkRadialGradient&>(fShader);
 
     SkPoint             srcPt;
     SkMatrix::MapXYProc dstProc = fDstToIndexProc;
     TileProc            proc = radialGradient.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);
         SkScalar sdx = fDstToIndex.getScaleX();
         SkScalar sdy = fDstToIndex.getSkewY();
 
         if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
             SkFixed storage[2];
             (void)fDstToIndex.fixedStepInX(SkIntToScalar(y),
                                            &storage[0], &storage[1]);
             sdx = SkFixedToScalar(storage[0]);
             sdy = SkFixedToScalar(storage[1]);
         } else {
             SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
         }
 
         RadialShadeProc shadeProc = shadeSpan_radial_repeat;
         if (SkShader::kClamp_TileMode == radialGradient.fTileMode) {
-            shadeProc = shadeSpan_radial_clamp;
+            shadeProc = use_new_proc ? shadeSpan_radial_clamp2 : shadeSpan_radial_clamp;
         } else if (SkShader::kMirror_TileMode == radialGradient.fTileMode) {
             shadeProc = shadeSpan_radial_mirror;
         } else {
             SkASSERT(SkShader::kRepeat_TileMode == radialGradient.fTileMode);
         }
         (*shadeProc)(srcPt.fX, sdx, srcPt.fY, sdy, dstC, cache, count, toggle);
     } else {    // perspective case
         SkScalar dstX = SkIntToScalar(x);
         SkScalar dstY = SkIntToScalar(y);
         do {
@@ skipping 166 matching lines @@
     str->appendScalar(fCenter.fY);
     str->append(") radius: ");
     str->appendScalar(fRadius);
     str->append(" ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif