Adding new bench tests for lighting and blur

bench/BlurBench.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkBenchmark.h"
+#include "SkBlurImageFilter.h"
+#include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
+#include "SkDevice.h"
 #include "SkPaint.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkString.h"
-#include "SkBlurMaskFilter.h"
 
 #define SMALL   SkIntToScalar(2)
 #define REAL    SkFloatToScalar(1.5f)
 #define BIG     SkIntToScalar(10)
 #define REALBIG SkFloatToScalar(100.5f)
 
 static const char* gStyleName[] = {
     "normal",
     "solid",
     "outer",
     "inner"
 };
 
-class BlurBench : public SkBenchmark {
+class BlurMaskBench : public SkBenchmark {

[Stephen White, 2013/04/24 17:35:56]

I think we should probably keep this as BlurBench, since the names in the graphs
will still be blur_foo.  Maybe the new one could be BlurImageFilterBench. 
Unless there's a lot of opportunity for code sharing in the benches, I'd suggest
we put the new one in a new file (say, BlurImageFilterBench.cpp).

     SkScalar    fRadius;
     SkBlurMaskFilter::BlurStyle fStyle;
     uint32_t                    fFlags;
     SkString    fName;
 
 public:
-    BlurBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) : INHERITED(param) {
+    BlurMaskBench(void* param, SkScalar rad, SkBlurMaskFilter::BlurStyle bs, uint32_t flags = 0) : INHERITED(param) {
         fRadius = rad;
         fStyle = bs;
         fFlags = flags;
         const char* name = rad > 0 ? gStyleName[bs] : "none";
         const char* quality = flags & SkBlurMaskFilter::kHighQuality_BlurFlag ? "high_quality" : "low_quality";
         if (SkScalarFraction(rad) != 0) {
             fName.printf("blur_%.2f_%s_%s", SkScalarToFloat(rad), name, quality);
         } else {
             fName.printf("blur_%d_%s_%s", SkScalarRound(rad), name, quality);
         }
@@ skipping 21 matching lines @@
                 paint.setMaskFilter(mf)->unref();
             }
             canvas->drawOval(r, paint);
         }
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kInner_BlurStyle);)
+#define FILTER_WIDTH_SMALL  32
+#define FILTER_HEIGHT_SMALL 32
+#define FILTER_WIDTH_LARGE  256
+#define FILTER_HEIGHT_LARGE 256
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kInner_BlurStyle);)
+class BlurBench : public SkBenchmark {
+public:
+    BlurBench(void* param, float sigmaX, float sigmaY,  bool small) :

[Stephen White, 2013/04/24 17:35:56]

For symmetry, we should probably make these parameters SkScalars, and #define
the filter widths with SkFloatToScalar, as BlurBench does.

+        INHERITED(param), fIsSmall(small), fInitialized(false),
+        fSigmaX(SkFloatToScalar(sigmaX)), fSigmaY(SkFloatToScalar(sigmaY)) {
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kInner_BlurStyle);)
+        if (fIsSmall) {
+            fName.printf("blur_small_%.2f_%.2f", sigmaX, sigmaY);

[Stephen White, 2013/04/24 17:35:56]

If we rename the class to BlurImageFilterBench, this should be
blur_image_filter_small, so it's clear in the graphing output which filter is
being tested.

+        } else {
+            fName.printf("blur_large_%.2f_%.2f", sigmaX, sigmaY);
+        }
+    }
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kSolid_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kOuter_BlurStyle);)
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kInner_BlurStyle);)
+protected:
+    virtual const char* onGetName() SK_OVERRIDE {
+        return fName.c_str();
+    }
 
-DEF_BENCH(return new BlurBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+    virtual void onPreDraw() SK_OVERRIDE {
+        if (!fInitialized) {
+            make_checkerboard();
+            fInitialized = true;
+        }
+    }
 
-DEF_BENCH(return new BlurBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        SkPaint paint;
+        paint.setImageFilter(
+            new SkBlurImageFilter(fSigmaX, fSigmaY))->unref();
+        canvas->drawBitmap(fCheckerboard, 0, 0, &paint);
+    }
 
-DEF_BENCH(return new BlurBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+private:
+    void make_checkerboard() {
+        const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
+        const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
+        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
+        fCheckerboard.allocPixels();
+        SkDevice device(fCheckerboard);
+        SkCanvas canvas(&device);
+        canvas.clear(0x00000000);
+        SkPaint darkPaint;
+        darkPaint.setColor(0xFF804020);
+        SkPaint lightPaint;
+        lightPaint.setColor(0xFF244484);
+        for (int y = 0; y < h; y += 16) {
+            for (int x = 0; x < w; x += 16) {
+                canvas.save();
+                canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
+                canvas.drawRect(SkRect::MakeXYWH(0, 0, 8, 8), darkPaint);
+                canvas.drawRect(SkRect::MakeXYWH(8, 0, 8, 8), lightPaint);
+                canvas.drawRect(SkRect::MakeXYWH(0, 8, 8, 8), lightPaint);
+                canvas.drawRect(SkRect::MakeXYWH(8, 8, 8, 8), darkPaint);
+                canvas.restore();
+            }
+        }
+    }
 
-DEF_BENCH(return new BlurBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+    SkString fName;
+    bool fIsSmall;
+    bool fInitialized;
+    SkBitmap fCheckerboard;
+    SkScalar fSigmaX, fSigmaY;
+    typedef SkBenchmark INHERITED;
+};
 
-DEF_BENCH(return new BlurBench(p, 0, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, SMALL, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, SMALL, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, SMALL, SkBlurMaskFilter::kInner_BlurStyle);)
+
+DEF_BENCH(return new BlurMaskBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, BIG, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, BIG, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, BIG, SkBlurMaskFilter::kInner_BlurStyle);)
+
+DEF_BENCH(return new BlurMaskBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REALBIG, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REALBIG, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REALBIG, SkBlurMaskFilter::kInner_BlurStyle);)
+
+DEF_BENCH(return new BlurMaskBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REAL, SkBlurMaskFilter::kSolid_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REAL, SkBlurMaskFilter::kOuter_BlurStyle);)
+DEF_BENCH(return new BlurMaskBench(p, REAL, SkBlurMaskFilter::kInner_BlurStyle);)
+
+DEF_BENCH(return new BlurMaskBench(p, SMALL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+
+DEF_BENCH(return new BlurMaskBench(p, BIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+
+DEF_BENCH(return new BlurMaskBench(p, REALBIG, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+
+DEF_BENCH(return new BlurMaskBench(p, REAL, SkBlurMaskFilter::kNormal_BlurStyle, SkBlurMaskFilter::kHighQuality_BlurFlag);)
+
+DEF_BENCH(return new BlurMaskBench(p, 0, SkBlurMaskFilter::kNormal_BlurStyle);)
+
+DEF_BENCH(return new BlurBench(p, 1.0f, 1.0f, true);)
+DEF_BENCH(return new BlurBench(p, 1.0f, 1.0f, false);)
+DEF_BENCH(return new BlurBench(p, 10.0f, 10.0f, true);)
+DEF_BENCH(return new BlurBench(p, 10.0f, 10.0f, false);)
+