/* * 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 "bench/Benchmark.h" #include "include/core/SkBitmap.h" #include "include/core/SkCanvas.h" #include "include/core/SkPaint.h" #include "include/core/SkPath.h" #include "include/core/SkString.h" #include "include/core/SkStrokeRec.h" #include "include/effects/SkDashPathEffect.h" #include "include/private/SkTDArray.h" #include "include/utils/SkRandom.h" /* * Cases to consider: * * 1. antialiasing on/off (esp. width <= 1) * 2. strokewidth == 0, 1, 2 * 3. hline, vline, diagonal, rect, oval * 4. dots [1,1] ([N,N] where N=strokeWidth?) or arbitrary (e.g. [2,1] or [1,2,3,2]) */ static void path_hline(SkPath* path) { path->moveTo(SkIntToScalar(10), SkIntToScalar(10)); path->lineTo(SkIntToScalar(600), SkIntToScalar(10)); } class DashBench : public Benchmark { protected: SkString fName; SkTDArray<SkScalar> fIntervals; int fWidth; SkPoint fPts[2]; bool fDoClip; public: DashBench(const SkScalar intervals[], int count, int width, bool doClip = false) { fIntervals.append(count, intervals); for (int i = 0; i < count; ++i) { fIntervals[i] *= width; } fWidth = width; fName.printf("dash_%d_%s", width, doClip ? "clipped" : "noclip"); fDoClip = doClip; fPts[0].set(SkIntToScalar(10), SkIntToScalar(10)); fPts[1].set(SkIntToScalar(600), SkIntToScalar(10)); } virtual void makePath(SkPath* path) { path_hline(path); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; this->setupPaint(&paint); paint.setStyle(SkPaint::kStroke_Style); paint.setStrokeWidth(SkIntToScalar(fWidth)); paint.setAntiAlias(false); SkPath path; this->makePath(&path); paint.setPathEffect(SkDashPathEffect::Make(fIntervals.begin(), fIntervals.count(), 0)); if (fDoClip) { SkRect r = path.getBounds(); r.inset(-SkIntToScalar(20), -SkIntToScalar(20)); // now move it so we don't intersect r.offset(0, r.height() * 3 / 2); canvas->clipRect(r); } this->handlePath(canvas, path, paint, loops); } virtual void handlePath(SkCanvas* canvas, const SkPath& path, const SkPaint& paint, int N) { for (int i = 0; i < N; ++i) { // canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, paint); canvas->drawPath(path, paint); } } private: typedef Benchmark INHERITED; }; class RectDashBench : public DashBench { public: RectDashBench(const SkScalar intervals[], int count, int width) : INHERITED(intervals, count, width) { fName.append("_rect"); } protected: virtual void handlePath(SkCanvas* canvas, const SkPath& path, const SkPaint& paint, int N) override { SkPoint pts[2]; if (!path.isLine(pts) || pts[0].fY != pts[1].fY) { this->INHERITED::handlePath(canvas, path, paint, N); } else { SkRect rect; rect.fLeft = pts[0].fX; rect.fTop = pts[0].fY - paint.getStrokeWidth() / 2; rect.fRight = rect.fLeft + SkIntToScalar(fWidth); rect.fBottom = rect.fTop + paint.getStrokeWidth(); SkPaint p(paint); p.setStyle(SkPaint::kFill_Style); p.setPathEffect(nullptr); int count = SkScalarRoundToInt((pts[1].fX - pts[0].fX) / (2*fWidth)); SkScalar dx = SkIntToScalar(2 * fWidth); for (int i = 0; i < N*10; ++i) { SkRect r = rect; for (int j = 0; j < count; ++j) { canvas->drawRect(r, p); r.offset(dx, 0); } } } } private: typedef DashBench INHERITED; }; static void make_unit_star(SkPath* path, int n) { SkScalar rad = -SK_ScalarPI / 2; const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n; path->moveTo(0, -SK_Scalar1); for (int i = 1; i < n; i++) { rad += drad; path->lineTo(SkScalarCos(rad), SkScalarSin(rad)); } path->close(); } static void make_poly(SkPath* path) { make_unit_star(path, 9); const SkMatrix matrix = SkMatrix::MakeScale(SkIntToScalar(100), SkIntToScalar(100)); path->transform(matrix); } static void make_quad(SkPath* path) { SkScalar x0 = SkIntToScalar(10); SkScalar y0 = SkIntToScalar(10); path->moveTo(x0, y0); path->quadTo(x0, y0 + 400 * SK_Scalar1, x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1); } static void make_cubic(SkPath* path) { SkScalar x0 = SkIntToScalar(10); SkScalar y0 = SkIntToScalar(10); path->moveTo(x0, y0); path->cubicTo(x0, y0 + 400 * SK_Scalar1, x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1, x0 + 600 * SK_Scalar1, y0); } class MakeDashBench : public Benchmark { SkString fName; SkPath fPath; sk_sp<SkPathEffect> fPE; public: MakeDashBench(void (*proc)(SkPath*), const char name[]) { fName.printf("makedash_%s", name); proc(&fPath); SkScalar vals[] = { SkIntToScalar(4), SkIntToScalar(4) }; fPE = SkDashPathEffect::Make(vals, 2, 0); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas*) override { SkPath dst; for (int i = 0; i < loops; ++i) { SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle); fPE->filterPath(&dst, fPath, &rec, nullptr); dst.rewind(); } } private: typedef Benchmark INHERITED; }; /* * We try to special case square dashes (intervals are equal to strokewidth). */ class DashLineBench : public Benchmark { SkString fName; SkScalar fStrokeWidth; bool fIsRound; sk_sp<SkPathEffect> fPE; public: DashLineBench(SkScalar width, bool isRound) { fName.printf("dashline_%g_%s", SkScalarToFloat(width), isRound ? "circle" : "square"); fStrokeWidth = width; fIsRound = isRound; SkScalar vals[] = { SK_Scalar1, SK_Scalar1 }; fPE = SkDashPathEffect::Make(vals, 2, 0); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas* canvas) override { SkPaint paint; this->setupPaint(&paint); paint.setStrokeWidth(fStrokeWidth); paint.setStrokeCap(fIsRound ? SkPaint::kRound_Cap : SkPaint::kSquare_Cap); paint.setPathEffect(fPE); for (int i = 0; i < loops; ++i) { canvas->drawLine(10 * SK_Scalar1, 10 * SK_Scalar1, 640 * SK_Scalar1, 10 * SK_Scalar1, paint); } } private: typedef Benchmark INHERITED; }; class DrawPointsDashingBench : public Benchmark { SkString fName; int fStrokeWidth; bool fDoAA; sk_sp<SkPathEffect> fPathEffect; public: DrawPointsDashingBench(int dashLength, int strokeWidth, bool doAA) { fName.printf("drawpointsdash_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw"); fStrokeWidth = strokeWidth; fDoAA = doAA; SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) }; fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas* canvas) override { SkPaint p; this->setupPaint(&p); p.setColor(SK_ColorBLACK); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(SkIntToScalar(fStrokeWidth)); p.setPathEffect(fPathEffect); p.setAntiAlias(fDoAA); SkPoint pts[2] = { { SkIntToScalar(10), 0 }, { SkIntToScalar(640), 0 } }; for (int i = 0; i < loops; ++i) { pts[0].fY = pts[1].fY = SkIntToScalar(i % 480); canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p); } } private: typedef Benchmark INHERITED; }; // Want to test how we handle dashing when 99% of the dash is clipped out class GiantDashBench : public Benchmark { SkString fName; SkScalar fStrokeWidth; SkPoint fPts[2]; sk_sp<SkPathEffect> fPathEffect; public: enum LineType { kHori_LineType, kVert_LineType, kDiag_LineType, kLineTypeCount }; static const char* LineTypeName(LineType lt) { static const char* gNames[] = { "hori", "vert", "diag" }; static_assert(kLineTypeCount == SK_ARRAY_COUNT(gNames), "names_wrong_size"); return gNames[lt]; } GiantDashBench(LineType lt, SkScalar width) { fName.printf("giantdashline_%s_%g", LineTypeName(lt), width); fStrokeWidth = width; // deliberately pick intervals that won't be caught by asPoints(), so // we can test the filterPath code-path. const SkScalar intervals[] = { 20, 10, 10, 10 }; fPathEffect = SkDashPathEffect::Make(intervals, SK_ARRAY_COUNT(intervals), 0); SkScalar cx = 640 / 2; // center X SkScalar cy = 480 / 2; // center Y SkMatrix matrix; switch (lt) { case kHori_LineType: matrix.setIdentity(); break; case kVert_LineType: matrix.setRotate(90, cx, cy); break; case kDiag_LineType: matrix.setRotate(45, cx, cy); break; case kLineTypeCount: // Not a real enum value. break; } const SkScalar overshoot = 100*1000; const SkPoint pts[2] = { { -overshoot, cy }, { 640 + overshoot, cy } }; matrix.mapPoints(fPts, pts, 2); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas* canvas) override { SkPaint p; this->setupPaint(&p); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(fStrokeWidth); p.setPathEffect(fPathEffect); for (int i = 0; i < loops; i++) { canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, p); } } private: typedef Benchmark INHERITED; }; // Want to test how we draw a dashed grid (like what is used in spreadsheets) of many // small dashed lines switching back and forth between horizontal and vertical class DashGridBench : public Benchmark { SkString fName; int fStrokeWidth; bool fDoAA; sk_sp<SkPathEffect> fPathEffect; public: DashGridBench(int dashLength, int strokeWidth, bool doAA) { fName.printf("dashgrid_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw"); fStrokeWidth = strokeWidth; fDoAA = doAA; SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) }; fPathEffect = SkDashPathEffect::Make(vals, 2, SK_Scalar1); } protected: const char* onGetName() override { return fName.c_str(); } void onDraw(int loops, SkCanvas* canvas) override { SkPaint p; this->setupPaint(&p); p.setColor(SK_ColorBLACK); p.setStyle(SkPaint::kStroke_Style); p.setStrokeWidth(SkIntToScalar(fStrokeWidth)); p.setPathEffect(fPathEffect); p.setAntiAlias(fDoAA); SkPoint pts[4] = { { SkIntToScalar(0), 20.5f }, { SkIntToScalar(20), 20.5f }, { 20.5f, SkIntToScalar(0) }, { 20.5f, SkIntToScalar(20) } }; for (int i = 0; i < loops; ++i) { for (int j = 0; j < 10; ++j) { for (int k = 0; k < 10; ++k) { // Horizontal line SkPoint horPts[2]; horPts[0].fX = pts[0].fX + k * 22.f; horPts[0].fY = pts[0].fY + j * 22.f; horPts[1].fX = pts[1].fX + k * 22.f; horPts[1].fY = pts[1].fY + j * 22.f; canvas->drawPoints(SkCanvas::kLines_PointMode, 2, horPts, p); // Vertical line SkPoint vertPts[2]; vertPts[0].fX = pts[2].fX + k * 22.f; vertPts[0].fY = pts[2].fY + j * 22.f; vertPts[1].fX = pts[3].fX + k * 22.f; vertPts[1].fY = pts[3].fY + j * 22.f; canvas->drawPoints(SkCanvas::kLines_PointMode, 2, vertPts, p); } } } } private: typedef Benchmark INHERITED; }; /////////////////////////////////////////////////////////////////////////////// static const SkScalar gDots[] = { SK_Scalar1, SK_Scalar1 }; #define PARAM(array) array, SK_ARRAY_COUNT(array) DEF_BENCH( return new DashBench(PARAM(gDots), 0); ) DEF_BENCH( return new DashBench(PARAM(gDots), 1); ) DEF_BENCH( return new DashBench(PARAM(gDots), 1, true); ) DEF_BENCH( return new DashBench(PARAM(gDots), 4); ) DEF_BENCH( return new MakeDashBench(make_poly, "poly"); ) DEF_BENCH( return new MakeDashBench(make_quad, "quad"); ) DEF_BENCH( return new MakeDashBench(make_cubic, "cubic"); ) DEF_BENCH( return new DashLineBench(0, false); ) DEF_BENCH( return new DashLineBench(SK_Scalar1, false); ) DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, false); ) DEF_BENCH( return new DashLineBench(0, true); ) DEF_BENCH( return new DashLineBench(SK_Scalar1, true); ) DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, true); ) DEF_BENCH( return new DrawPointsDashingBench(1, 1, false); ) DEF_BENCH( return new DrawPointsDashingBench(1, 1, true); ) DEF_BENCH( return new DrawPointsDashingBench(3, 1, false); ) DEF_BENCH( return new DrawPointsDashingBench(3, 1, true); ) DEF_BENCH( return new DrawPointsDashingBench(5, 5, false); ) DEF_BENCH( return new DrawPointsDashingBench(5, 5, true); ) /* Disable the GiantDashBench for Android devices until we can better control * the memory usage. (https://code.google.com/p/skia/issues/detail?id=1430) */ #ifndef SK_BUILD_FOR_ANDROID DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 0); ) DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 0); ) DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 0); ) // pass 2 to explicitly avoid any 1-is-the-same-as-hairline special casing // hori_2 is just too slow to enable at the moment DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 2); ) DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 2); ) DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 2); ) DEF_BENCH( return new DashGridBench(1, 1, true); ) DEF_BENCH( return new DashGridBench(1, 1, false); ) DEF_BENCH( return new DashGridBench(3, 1, true); ) DEF_BENCH( return new DashGridBench(3, 1, false); ) #endif