speed up 2-point-radial gradients by 9x, using float instead of fixed

git-svn-id: http://skia.googlecode.com/svn/trunk@1118 2bbb7eff-a529-9590-31e7-b0007b416f81

bench/GradientBench.cpp

@@ -0,0 +1,151 @@
+#include "SkBenchmark.h"
+#include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkColorPriv.h"
+#include "SkGradientShader.h"
+#include "SkPaint.h"
+#include "SkShader.h"
+#include "SkString.h"
+#include "SkUnitMapper.h"
+
+struct GradData {
+    int             fCount;
+    const SkColor*  fColors;
+    const SkScalar* fPos;
+};
+
+static const SkColor gColors[] = {
+    SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK
+};
+static const SkScalar gPos0[] = { 0, SK_Scalar1 };
+static const SkScalar gPos1[] = { SK_Scalar1/4, SK_Scalar1*3/4 };
+static const SkScalar gPos2[] = {
+    0, SK_Scalar1/8, SK_Scalar1/2, SK_Scalar1*7/8, SK_Scalar1
+};
+
+static const GradData gGradData[] = {
+    { 2, gColors, NULL },
+    { 2, gColors, gPos0 },
+    { 2, gColors, gPos1 },
+    { 5, gColors, NULL },
+    { 5, gColors, gPos2 }
+};
+
+static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
+                            SkShader::TileMode tm, SkUnitMapper* mapper) {
+    return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
+                                          data.fCount, tm, mapper);
+}
+
+static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
+                            SkShader::TileMode tm, SkUnitMapper* mapper) {
+    SkPoint center;
+    center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+               SkScalarAve(pts[0].fY, pts[1].fY));
+    return SkGradientShader::CreateRadial(center, center.fX, data.fColors,
+                                          data.fPos, data.fCount, tm, mapper);
+}
+
+static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
+                           SkShader::TileMode tm, SkUnitMapper* mapper) {
+    SkPoint center;
+    center.set(SkScalarAve(pts[0].fX, pts[1].fX),
+               SkScalarAve(pts[0].fY, pts[1].fY));
+    return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
+                                         data.fPos, data.fCount, mapper);
+}
+
+static SkShader* Make2Radial(const SkPoint pts[2], const GradData& data,
+                             SkShader::TileMode tm, SkUnitMapper* mapper) {
+    SkPoint center0, center1;
+    center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
+                SkScalarAve(pts[0].fY, pts[1].fY));
+    center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
+                SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
+    return SkGradientShader::CreateTwoPointRadial(
+                                                  center1, (pts[1].fX - pts[0].fX) / 7,
+                                                  center0, (pts[1].fX - pts[0].fX) / 2,
+                                                  data.fColors, data.fPos, data.fCount, tm, mapper);
+}
+
+typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
+                               SkShader::TileMode tm, SkUnitMapper* mapper);
+
+static const struct {
+    GradMaker   fMaker;
+    const char* fName;
+    int         fRepeat;
+} gGrads[] = {
+    { MakeLinear,   "linear",  15 },
+    { MakeRadial,   "radial",  10 },
+    { MakeSweep,    "sweep",    1 },
+    { Make2Radial,  "radial2",  5 },
+};
+
+enum GradType { // these must match the order in gGrads
+    kLinear_GradType,
+    kRadial_GradType,
+    kSweep_GradType,
+    kRadial2_GradType
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+class GradientBench : public SkBenchmark {
+    SkString fName;
+    SkShader* fShader;
+    int      fCount;
+    enum {
+        W   = 400,
+        H   = 400,
+        N   = 1
+    };
+public:
+    GradientBench(void* param, GradType gt) : INHERITED(param) {
+        fName.printf("gradient_%s", gGrads[gt].fName);
+
+        const SkPoint pts[2] = {
+            { 0, 0 },
+            { SkIntToScalar(W), SkIntToScalar(H) }
+        };
+        
+        fCount = N * gGrads[gt].fRepeat;
+        fShader = gGrads[gt].fMaker(pts, gGradData[0],
+                                    SkShader::kClamp_TileMode, NULL);
+    }
+
+    virtual ~GradientBench() {
+        fShader->unref();
+    }
+
+protected:
+    virtual const char* onGetName() {
+        return fName.c_str();
+    }
+
+    virtual void onDraw(SkCanvas* canvas) {
+        SkPaint paint;
+        this->setupPaint(&paint);
+
+        paint.setShader(fShader);
+
+        SkRect r = { 0, 0, SkIntToScalar(W), SkIntToScalar(H) };
+        for (int i = 0; i < fCount; i++) {
+            canvas->drawRect(r, paint);
+        }
+    }
+
+private:
+    typedef SkBenchmark INHERITED;
+};
+
+static SkBenchmark* Fact0(void* p) { return new GradientBench(p, kLinear_GradType); }
+static SkBenchmark* Fact1(void* p) { return new GradientBench(p, kRadial_GradType); }
+static SkBenchmark* Fact2(void* p) { return new GradientBench(p, kSweep_GradType); }
+static SkBenchmark* Fact3(void* p) { return new GradientBench(p, kRadial2_GradType); }
+
+static BenchRegistry gReg0(Fact0);
+static BenchRegistry gReg1(Fact1);
+static BenchRegistry gReg2(Fact2);
+static BenchRegistry gReg3(Fact3);
+

src/effects/SkGradientShader.cpp

@@ -1361,18 +1361,22 @@ private:
 
 */
 
-static inline SkFixed two_point_radial(SkFixed b, SkFixed fx, SkFixed fy, SkFixed sr2d2, SkFixed foura, SkFixed oneOverTwoA, bool posRoot) {
+static inline SkFixed two_point_radial(SkScalar b, SkScalar fx, SkScalar fy,
-    SkFixed c = SkFixedSquare(fx) + SkFixedSquare(fy) - sr2d2;
+                                       SkScalar sr2d2, SkScalar foura,
-    SkFixed discrim = SkFixedSquare(b) - SkFixedMul(foura, c);
+                                       SkScalar oneOverTwoA, bool posRoot) {
+    SkScalar c = SkScalarSquare(fx) + SkScalarSquare(fy) - sr2d2;
+    SkScalar discrim = SkScalarSquare(b) - SkScalarMul(foura, c);
     if (discrim < 0) {
         discrim = -discrim;
     }
-    SkFixed rootDiscrim = SkFixedSqrt(discrim);
+    SkScalar rootDiscrim = SkScalarSqrt(discrim);
+    SkScalar result;
     if (posRoot) {
-        return SkFixedMul(-b + rootDiscrim, oneOverTwoA);
+        result = SkScalarMul(-b + rootDiscrim, oneOverTwoA);
     } else {
-        return SkFixedMul(-b - rootDiscrim, oneOverTwoA);
+        result = SkScalarMul(-b - rootDiscrim, oneOverTwoA);
     }
+    return SkScalarToFixed(result);
 }
 
 class Two_Point_Radial_Gradient : public Gradient_Shader {
@@ -1447,39 +1451,38 @@ public:
         SkMatrix::MapXYProc dstProc = fDstToIndexProc;
         TileProc            proc = fTileProc;
         const SkPMColor*    cache = this->getCache32();
-        SkFixed diffx = SkScalarToFixed(fDiff.fX);
+
-        SkFixed diffy = SkScalarToFixed(fDiff.fY);
+        SkScalar foura = fA * 4;
-        SkFixed foura = SkScalarToFixed(SkScalarMul(fA, 4));
-        SkFixed startRadius = SkScalarToFixed(fStartRadius);
-        SkFixed sr2D2 = SkScalarToFixed(fSr2D2);
-        SkFixed oneOverTwoA = SkScalarToFixed(fOneOverTwoA);
         bool posRoot = fDiffRadius < 0;
         if (fDstToIndexClass != kPerspective_MatrixClass)
         {
             SkPoint srcPt;
             dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
                                  SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-            SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
+            SkScalar dx, fx = srcPt.fX;
-            SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
+            SkScalar dy, fy = srcPt.fY;
 
             if (fDstToIndexClass == kFixedStepInX_MatrixClass)
             {
-                (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &dx, &dy);
+                SkFixed fixedX, fixedY;
+                (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
+                dx = SkFixedToScalar(fixedX);
+                dy = SkFixedToScalar(fixedY);
             }
             else
             {
                 SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
-                dx = SkScalarToFixed(fDstToIndex.getScaleX());
+                dx = fDstToIndex.getScaleX();
-                dy = SkScalarToFixed(fDstToIndex.getSkewY());
+                dy = fDstToIndex.getSkewY();
             }
-            SkFixed b = (SkFixedMul(diffx, fx) +
+            SkScalar b = (SkScalarMul(fDiff.fX, fx) +
-                         SkFixedMul(diffy, fy) - startRadius) << 1;
+                         SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
-            SkFixed db = (SkFixedMul(diffx, dx) +
+            SkScalar db = (SkScalarMul(fDiff.fX, dx) +
-                          SkFixedMul(diffy, dy)) << 1;
+                          SkScalarMul(fDiff.fY, dy)) * 2;
             if (proc == clamp_tileproc)
             {
                 for (; count > 0; --count) {
-                    SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot);
+                    SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
                     SkFixed index = SkClampMax(t, 0xFFFF);
                     SkASSERT(index <= 0xFFFF);
                     *dstC++ = cache[index >> (16 - kCache32Bits)];
@@ -1491,7 +1494,7 @@ public:
             else if (proc == mirror_tileproc)
             {
                 for (; count > 0; --count) {
-                    SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot);
+                    SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
                     SkFixed index = mirror_tileproc(t);
                     SkASSERT(index <= 0xFFFF);
                     *dstC++ = cache[index >> (16 - kCache32Bits)];
@@ -1504,7 +1507,7 @@ public:
             {
                 SkASSERT(proc == repeat_tileproc);
                 for (; count > 0; --count) {
-                    SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot);
+                    SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
                     SkFixed index = repeat_tileproc(t);
                     SkASSERT(index <= 0xFFFF);
                     *dstC++ = cache[index >> (16 - kCache32Bits)];
@@ -1521,11 +1524,11 @@ public:
             for (; count > 0; --count) {
                 SkPoint             srcPt;
                 dstProc(fDstToIndex, dstX, dstY, &srcPt);
-                SkFixed fx = SkScalarToFixed(srcPt.fX);
+                SkScalar fx = srcPt.fX;
-                SkFixed fy = SkScalarToFixed(srcPt.fY);
+                SkScalar fy = srcPt.fY;
-                SkFixed b = (SkFixedMul(diffx, fx) +
+                SkScalar b = (SkScalarMul(fDiff.fX, fx) +
-                             SkFixedMul(diffy, fy) - startRadius) << 1;
+                             SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
-                SkFixed t = two_point_radial(b, fx, fy, sr2D2, foura, oneOverTwoA, posRoot);
+                SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
                 SkFixed index = proc(t);
                 SkASSERT(index <= 0xFFFF);
                 *dstC++ = cache[index >> (16 - kCache32Bits)];