Added a few bench for some image filters

bench/MergeBench.cpp

Index: bench/MergeBench.cpp
===================================================================
--- bench/MergeBench.cpp	(revision 0)
+++ bench/MergeBench.cpp	(revision 0)
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2013 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 "SkCanvas.h"
+#include "SkColorFilter.h"
+#include "SkColorFilterImageFilter.h"
+#include "SkMergeImageFilter.h"
+#include "SkOffsetImageFilter.h"
+#include "SkTestImageFilters.h"
+
+#define FILTER_WIDTH    SkIntToScalar(150)
+#define FILTER_HEIGHT   SkIntToScalar(200)
+
+class MergeBench : public SkBenchmark {

[Stephen White, 2013/04/15 15:34:21]

This bench seems to test a lot more than just Merge.  Perhaps we should break
out the large-DAG tests into their own bench, and maybe use something a bit more
real-world, like a skia version of the example here: 
http://www.w3.org/TR/SVG/filters.html#AnExample.

+public:
+    MergeBench(void* param) : INHERITED(param) {
+    }
+
+protected:
+    virtual const char* onGetName() SK_OVERRIDE {
+        return "merge";
+    }
+
+    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        static SkImageFilter* (*gFilterProc[])() = {
+            mergeOffsetDown, mergeOffsetDownComposeColor, mergeOffsetBlurComposeColor
+        };
+
+        const SkRect bounds = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT);
+
+        const SkScalar dx = bounds.width() * 8 / 7;
+        const SkScalar dy = bounds.height() * 8 / 7;
+
+        canvas->translate(SkIntToScalar(8), SkIntToScalar(8));
+
+        for (size_t i = 0; i < SK_ARRAY_COUNT(gFilterProc); ++i) {

[Stephen White, 2013/04/15 15:34:21]

Again, should be separate bench test cases.

[sugoi1, 2013/04/19 18:09:42]

I only kept 1, only with bitmaps, to get a better bench of the merge filter
only.

+            int ix = i % 4;
+            int iy = i / 4;
+
+            SkAutoCanvasRestore acr(canvas, true);
+            canvas->translate(ix * dx, iy * dy);
+
+            SkPaint p;
+            p.setStyle(SkPaint::kStroke_Style);
+            canvas->drawRect(bounds, p);
+
+            SkPaint paint;
+            paint.setImageFilter(gFilterProc[i]())->unref();
+            canvas->saveLayer(&bounds, &paint);
+            draw(canvas);
+        }
+    }
+
+private:
+    static void draw(SkCanvas* canvas) {
+        SkPaint p;
+        p.setAntiAlias(true);
+        SkRect r = SkRect::MakeWH(FILTER_WIDTH, FILTER_HEIGHT);
+        r.inset(SK_Scalar1 * 12, SK_Scalar1 * 12);
+        p.setColor(SK_ColorRED);
+        canvas->drawOval(r, p);
+    }
+
+    static SkImageFilter* mergeOffsetDown() {
+        SkImageFilter* first = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
+        SkImageFilter* second = new SkDownSampleImageFilter(SK_Scalar1 / 5);
+        SkAutoUnref aur0(first);
+        SkAutoUnref aur1(second);
+        return new SkMergeImageFilter(first, second);

[Stephen White, 2013/04/15 15:34:21]

I think it'd be better to have something that isolates the performance of Merge
alone; perhaps using SkBitmapSource as inputs?

[sugoi1, 2013/04/19 18:09:42]

Removed.

+    }
+
+    static SkImageFilter* mergeOffsetDownComposeColor() {
+        SkImageFilter* outer = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
+        SkImageFilter* inner = new SkDownSampleImageFilter(SK_Scalar1 / 5);

[Stephen White, 2013/04/15 15:34:21]

I'd test SkDownSampleImageFilter separately in its own test case, and try to
isolate the performance of SkComposeImageFilter here (maybe also in its own
file, rather than MergeBench?)

[sugoi1, 2013/04/19 18:09:42]

Removed.

+        SkAutoUnref aur0(outer);
+        SkAutoUnref aur1(inner);
+        SkImageFilter* compose = new SkComposeImageFilter(outer, inner);
+        SkAutoUnref aur2(compose);
+
+        SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF,
+                                                            SkXfermode::kSrcIn_Mode);
+        SkAutoUnref aur3(cf);
+        SkImageFilter* blue = SkColorFilterImageFilter::Create(cf);
+        SkAutoUnref aur4(blue);
+
+        return new SkMergeImageFilter(compose, blue);
+    }
+
+    static SkImageFilter* mergeOffsetBlurComposeColor() {
+        SkImageFilter* outer = new SkOffsetImageFilter(SkIntToScalar(16), SkIntToScalar(16));
+        SkImageFilter* inner = new SkBlurImageFilter(8, 0);

[Stephen White, 2013/04/15 15:34:21]

Blur will probably dominate the performance time here, so we should probably use
something simpler (perhaps just SkBitmapSource) to isolate the performance of
SkComposeImageFilter (or eliminate this one in favour of a reduced version of
the one above).

[sugoi1, 2013/04/19 18:09:42]

Removed.

+        SkAutoUnref aur0(outer);
+        SkAutoUnref aur1(inner);
+        SkImageFilter* compose = new SkComposeImageFilter(outer, inner);
+        SkAutoUnref aur2(compose);
+
+        SkColorFilter* cf = SkColorFilter::CreateModeFilter(0x880000FF,
+                                                            SkXfermode::kSrcIn_Mode);
+        SkAutoUnref aur3(cf);
+        SkImageFilter* blue = SkColorFilterImageFilter::Create(cf);
+        SkAutoUnref aur4(blue);
+
+        return new SkMergeImageFilter(compose, blue);
+    }
+
+    typedef SkBenchmark INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+DEF_BENCH( return new MergeBench(p); )
+