Push sigma-based blur interface into our GMs/benches/tests/samplecode

bench/BlurRectBench.cpp

Index: bench/BlurRectBench.cpp
===================================================================
--- bench/BlurRectBench.cpp	(revision 11004)
+++ bench/BlurRectBench.cpp	(working copy)
@@ -13,23 +13,25 @@
 #include "SkString.h"
 #include "SkBlurMask.h"
 
-#define SMALL   SkIntToScalar(2)
-#define REAL    SkFloatToScalar(1.5f)
-#define BIG     SkIntToScalar(10)
-#define REALBIG SkFloatToScalar(30.5f)
+#define SMALL   SkFloatToScalar(1.6547f)
+#define REAL    SkFloatToScalar(1.366025f)
+static const SkScalar kMedium = SkFloatToScalar(3.38675f);
+#define BIG     SkFloatToScalar(6.2735f)
+static const SkScalar kMedBig = SkFloatToScalar(12.047f);
+#define REALBIG SkFloatToScalar(18.109175f)
 
 class BlurRectBench: public SkBenchmark {
     int         fLoopCount;
-    SkScalar    fRadius;
+    SkScalar    fSigma;
     SkString    fName;
 
 public:
-    BlurRectBench(void *param, SkScalar rad) : INHERITED(param) {
-        fRadius = rad;
+    BlurRectBench(void *param, SkScalar sigma) : INHERITED(param) {
+        fSigma = sigma;
 
-        if (fRadius > SkIntToScalar(25)) {
+        if (fSigma > SkIntToScalar(15)) {
             fLoopCount = 100;
-        } else if (fRadius > SkIntToScalar(5)) {
+        } else if (fSigma > SkIntToScalar(3)) {
             fLoopCount = 1000;
         } else {
             fLoopCount = 10000;
@@ -41,8 +43,8 @@
         return fName.c_str();
     }
 
-    SkScalar radius() const {
-        return fRadius;
+    SkScalar sigma() const {
+        return fSigma;
     }
 
     void setName(const SkString& name) {
@@ -55,8 +57,7 @@
 
         paint.setAntiAlias(true);
 
-        SkScalar pad = fRadius*3/2 + SK_Scalar1;
-        SkRect r = SkRect::MakeWH(2 * pad + SK_Scalar1, 2 * pad + SK_Scalar1);
+        SkRect r = SkRect::MakeWH(3.0f * fSigma, 3.0f * fSigma);
 
         preBenchSetup(r);
 
@@ -74,21 +75,16 @@
 
 class BlurRectDirectBench: public BlurRectBench {
  public:
-    BlurRectDirectBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectDirectBench(void *param, SkScalar sigma, const char* suffix) 
+        : INHERITED(param, sigma) {
         SkString name;
-
-        if (SkScalarFraction(rad) != 0) {
-            name.printf("blurrect_direct_%.2f", SkScalarToFloat(rad));
-        } else {
-            name.printf("blurrect_direct_%d", SkScalarRoundToInt(rad));
-        }
-
-        setName(name);
+        name.printf("blurrect_direct_%s", suffix);
+        this->setName(name);
     }
 protected:
     virtual void makeBlurryRect(const SkRect& r) SK_OVERRIDE {
         SkMask mask;
-        SkBlurMask::BlurRect(&mask, r, this->radius(), SkBlurMask::kNormal_Style);
+        SkBlurMask::BlurRect(this->sigma(), &mask, r, SkBlurMask::kNormal_Style);
         SkMask::FreeImage(mask.fImage);
     }
 private:
@@ -98,7 +94,7 @@
 class BlurRectSeparableBench: public BlurRectBench {
 
 public:
-    BlurRectSeparableBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectSeparableBench(void *param, SkScalar sigma) : INHERITED(param, sigma) {
         fSrcMask.fImage = NULL;
     }
 
@@ -125,14 +121,11 @@
 
 class BlurRectBoxFilterBench: public BlurRectSeparableBench {
 public:
-    BlurRectBoxFilterBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectBoxFilterBench(void *param, SkScalar sigma, const char* suffix) 
+        : INHERITED(param, sigma) {
         SkString name;
-        if (SkScalarFraction(rad) != 0) {
-            name.printf("blurrect_boxfilter_%.2f", SkScalarToFloat(rad));
-        } else {
-            name.printf("blurrect_boxfilter_%d", SkScalarRoundToInt(rad));
-        }
-        setName(name);
+        name.printf("blurrect_boxfilter_%s", suffix);
+        this->setName(name);
     }
 
 protected:
@@ -140,9 +133,9 @@
     virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
-        SkBlurMask::Blur(&mask, fSrcMask, this->radius(),
-                         SkBlurMask::kNormal_Style,
-                         SkBlurMask::kHigh_Quality);
+        SkBlurMask::BoxBlur(&mask, fSrcMask, this->sigma(),
+                            SkBlurMask::kNormal_Style,
+                            SkBlurMask::kHigh_Quality);
         SkMask::FreeImage(mask.fImage);
     }
 private:
@@ -151,14 +144,11 @@
 
 class BlurRectGaussianBench: public BlurRectSeparableBench {
 public:
-    BlurRectGaussianBench(void *param, SkScalar rad) : INHERITED(param, rad) {
+    BlurRectGaussianBench(void *param, SkScalar sigma, const char* suffix) 
+        : INHERITED(param, sigma) {
         SkString name;
-        if (SkScalarFraction(rad) != 0) {
-            name.printf("blurrect_gaussian_%.2f", SkScalarToFloat(rad));
-        } else {
-            name.printf("blurrect_gaussian_%d", SkScalarRoundToInt(rad));
-        }
-        setName(name);
+        name.printf("blurrect_gaussian_%s", suffix);
+        this->setName(name);
     }
 
 protected:
@@ -166,7 +156,7 @@
     virtual void makeBlurryRect(const SkRect&) SK_OVERRIDE {
         SkMask mask;
         mask.fImage = NULL;
-        SkBlurMask::BlurGroundTruth(&mask, fSrcMask, this->radius(),
+        SkBlurMask::BlurGroundTruth(this->sigma(), &mask, fSrcMask,
                                     SkBlurMask::kNormal_Style);
         SkMask::FreeImage(mask.fImage);
     }
@@ -174,24 +164,24 @@
     typedef BlurRectSeparableBench INHERITED;
 };
 
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SMALL);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, BIG);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, REAL);)
-DEF_BENCH(return new BlurRectGaussianBench(p, SMALL);)
-DEF_BENCH(return new BlurRectGaussianBench(p, BIG);)
-DEF_BENCH(return new BlurRectGaussianBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectGaussianBench(p, REAL);)
-DEF_BENCH(return new BlurRectDirectBench(p, SMALL);)
-DEF_BENCH(return new BlurRectDirectBench(p, BIG);)
-DEF_BENCH(return new BlurRectDirectBench(p, REALBIG);)
-DEF_BENCH(return new BlurRectDirectBench(p, REAL);)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, SMALL, "2");)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, BIG, "10");)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, REALBIG, "30.50");)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, REAL, "1.50");)
+DEF_BENCH(return new BlurRectGaussianBench(p, SMALL, "2");)
+DEF_BENCH(return new BlurRectGaussianBench(p, BIG, "10");)
+DEF_BENCH(return new BlurRectGaussianBench(p, REALBIG, "30.50");)
+DEF_BENCH(return new BlurRectGaussianBench(p, REAL, "1.50");)
+DEF_BENCH(return new BlurRectDirectBench(p, SMALL, "2");)
+DEF_BENCH(return new BlurRectDirectBench(p, BIG, "10");)
+DEF_BENCH(return new BlurRectDirectBench(p, REALBIG, "30.50");)
+DEF_BENCH(return new BlurRectDirectBench(p, REAL, "1.50");)
 
-DEF_BENCH(return new BlurRectDirectBench(p, SkIntToScalar(5));)
-DEF_BENCH(return new BlurRectDirectBench(p, SkIntToScalar(20));)
+DEF_BENCH(return new BlurRectDirectBench(p, kMedium, "5");)
+DEF_BENCH(return new BlurRectDirectBench(p, kMedBig, "20");)
 
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SkIntToScalar(5));)
-DEF_BENCH(return new BlurRectBoxFilterBench(p, SkIntToScalar(20));)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedium, "5");)
+DEF_BENCH(return new BlurRectBoxFilterBench(p, kMedBig, "20");)
 
 #if 0
 // disable Gaussian benchmarks; the algorithm works well enough