• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 /*
3  * Copyright 2011 Google Inc.
4  *
5  * Use of this source code is governed by a BSD-style license that can be
6  * found in the LICENSE file.
7  */
8 #include "Benchmark.h"
9 #include "SkBitmap.h"
10 #include "SkCanvas.h"
11 #include "SkDashPathEffect.h"
12 #include "SkPaint.h"
13 #include "SkPath.h"
14 #include "SkRandom.h"
15 #include "SkString.h"
16 #include "SkStrokeRec.h"
17 #include "SkTDArray.h"
18 
19 
20 /*
21  *  Cases to consider:
22  *
23  *  1. antialiasing on/off (esp. width <= 1)
24  *  2. strokewidth == 0, 1, 2
25  *  3. hline, vline, diagonal, rect, oval
26  *  4. dots [1,1] ([N,N] where N=strokeWidth?) or arbitrary (e.g. [2,1] or [1,2,3,2])
27  */
path_hline(SkPath * path)28 static void path_hline(SkPath* path) {
29     path->moveTo(SkIntToScalar(10), SkIntToScalar(10));
30     path->lineTo(SkIntToScalar(600), SkIntToScalar(10));
31 }
32 
33 class DashBench : public Benchmark {
34 protected:
35     SkString            fName;
36     SkTDArray<SkScalar> fIntervals;
37     int                 fWidth;
38     SkPoint             fPts[2];
39     bool                fDoClip;
40 
41 public:
DashBench(const SkScalar intervals[],int count,int width,bool doClip=false)42     DashBench(const SkScalar intervals[], int count, int width,
43               bool doClip = false)  {
44         fIntervals.append(count, intervals);
45         for (int i = 0; i < count; ++i) {
46             fIntervals[i] *= width;
47         }
48         fWidth = width;
49         fName.printf("dash_%d_%s", width, doClip ? "clipped" : "noclip");
50         fDoClip = doClip;
51 
52         fPts[0].set(SkIntToScalar(10), SkIntToScalar(10));
53         fPts[1].set(SkIntToScalar(600), SkIntToScalar(10));
54     }
55 
makePath(SkPath * path)56     virtual void makePath(SkPath* path) {
57         path_hline(path);
58     }
59 
60 protected:
onGetName()61     const char* onGetName() override {
62         return fName.c_str();
63     }
64 
onDraw(int loops,SkCanvas * canvas)65     void onDraw(int loops, SkCanvas* canvas) override {
66         SkPaint paint;
67         this->setupPaint(&paint);
68         paint.setStyle(SkPaint::kStroke_Style);
69         paint.setStrokeWidth(SkIntToScalar(fWidth));
70         paint.setAntiAlias(false);
71 
72         SkPath path;
73         this->makePath(&path);
74 
75         paint.setPathEffect(SkDashPathEffect::Create(fIntervals.begin(),
76                                                      fIntervals.count(), 0))->unref();
77 
78         if (fDoClip) {
79             SkRect r = path.getBounds();
80             r.inset(-SkIntToScalar(20), -SkIntToScalar(20));
81             // now move it so we don't intersect
82             r.offset(0, r.height() * 3 / 2);
83             canvas->clipRect(r);
84         }
85 
86         this->handlePath(canvas, path, paint, loops);
87     }
88 
handlePath(SkCanvas * canvas,const SkPath & path,const SkPaint & paint,int N)89     virtual void handlePath(SkCanvas* canvas, const SkPath& path,
90                             const SkPaint& paint, int N) {
91         for (int i = 0; i < N; ++i) {
92 //            canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, paint);
93             canvas->drawPath(path, paint);
94         }
95     }
96 
97 private:
98     typedef Benchmark INHERITED;
99 };
100 
101 class RectDashBench : public DashBench {
102 public:
RectDashBench(const SkScalar intervals[],int count,int width)103     RectDashBench(const SkScalar intervals[], int count, int width)
104     : INHERITED(intervals, count, width) {
105         fName.append("_rect");
106     }
107 
108 protected:
handlePath(SkCanvas * canvas,const SkPath & path,const SkPaint & paint,int N)109     virtual void handlePath(SkCanvas* canvas, const SkPath& path,
110                             const SkPaint& paint, int N) override {
111         SkPoint pts[2];
112         if (!path.isLine(pts) || pts[0].fY != pts[1].fY) {
113             this->INHERITED::handlePath(canvas, path, paint, N);
114         } else {
115             SkRect rect;
116             rect.fLeft = pts[0].fX;
117             rect.fTop = pts[0].fY - paint.getStrokeWidth() / 2;
118             rect.fRight = rect.fLeft + SkIntToScalar(fWidth);
119             rect.fBottom = rect.fTop + paint.getStrokeWidth();
120 
121             SkPaint p(paint);
122             p.setStyle(SkPaint::kFill_Style);
123             p.setPathEffect(nullptr);
124 
125             int count = SkScalarRoundToInt((pts[1].fX - pts[0].fX) / (2*fWidth));
126             SkScalar dx = SkIntToScalar(2 * fWidth);
127 
128             for (int i = 0; i < N*10; ++i) {
129                 SkRect r = rect;
130                 for (int j = 0; j < count; ++j) {
131                     canvas->drawRect(r, p);
132                     r.offset(dx, 0);
133                 }
134             }
135         }
136     }
137 
138 private:
139     typedef DashBench INHERITED;
140 };
141 
make_unit_star(SkPath * path,int n)142 static void make_unit_star(SkPath* path, int n) {
143     SkScalar rad = -SK_ScalarPI / 2;
144     const SkScalar drad = (n >> 1) * SK_ScalarPI * 2 / n;
145 
146     path->moveTo(0, -SK_Scalar1);
147     for (int i = 1; i < n; i++) {
148         rad += drad;
149         SkScalar cosV, sinV = SkScalarSinCos(rad, &cosV);
150         path->lineTo(cosV, sinV);
151     }
152     path->close();
153 }
154 
make_poly(SkPath * path)155 static void make_poly(SkPath* path) {
156     make_unit_star(path, 9);
157     const SkMatrix matrix = SkMatrix::MakeScale(SkIntToScalar(100), SkIntToScalar(100));
158     path->transform(matrix);
159 }
160 
make_quad(SkPath * path)161 static void make_quad(SkPath* path) {
162     SkScalar x0 = SkIntToScalar(10);
163     SkScalar y0 = SkIntToScalar(10);
164     path->moveTo(x0, y0);
165     path->quadTo(x0,                    y0 + 400 * SK_Scalar1,
166                  x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1);
167 }
168 
make_cubic(SkPath * path)169 static void make_cubic(SkPath* path) {
170     SkScalar x0 = SkIntToScalar(10);
171     SkScalar y0 = SkIntToScalar(10);
172     path->moveTo(x0, y0);
173     path->cubicTo(x0,                    y0 + 400 * SK_Scalar1,
174                   x0 + 600 * SK_Scalar1, y0 + 400 * SK_Scalar1,
175                   x0 + 600 * SK_Scalar1, y0);
176 }
177 
178 class MakeDashBench : public Benchmark {
179     SkString fName;
180     SkPath   fPath;
181     SkAutoTUnref<SkPathEffect> fPE;
182 
183 public:
MakeDashBench(void (* proc)(SkPath *),const char name[])184     MakeDashBench(void (*proc)(SkPath*), const char name[])  {
185         fName.printf("makedash_%s", name);
186         proc(&fPath);
187 
188         SkScalar vals[] = { SkIntToScalar(4), SkIntToScalar(4) };
189         fPE.reset(SkDashPathEffect::Create(vals, 2, 0));
190     }
191 
192 protected:
onGetName()193     const char* onGetName() override {
194         return fName.c_str();
195     }
196 
onDraw(int loops,SkCanvas *)197     void onDraw(int loops, SkCanvas*) override {
198         SkPath dst;
199         for (int i = 0; i < loops; ++i) {
200             SkStrokeRec rec(SkStrokeRec::kHairline_InitStyle);
201 
202             fPE->filterPath(&dst, fPath, &rec, nullptr);
203             dst.rewind();
204         }
205     }
206 
207 private:
208     typedef Benchmark INHERITED;
209 };
210 
211 /*
212  *  We try to special case square dashes (intervals are equal to strokewidth).
213  */
214 class DashLineBench : public Benchmark {
215     SkString fName;
216     SkScalar fStrokeWidth;
217     bool     fIsRound;
218     SkAutoTUnref<SkPathEffect> fPE;
219 
220 public:
DashLineBench(SkScalar width,bool isRound)221     DashLineBench(SkScalar width, bool isRound)  {
222         fName.printf("dashline_%g_%s", SkScalarToFloat(width), isRound ? "circle" : "square");
223         fStrokeWidth = width;
224         fIsRound = isRound;
225 
226         SkScalar vals[] = { SK_Scalar1, SK_Scalar1 };
227         fPE.reset(SkDashPathEffect::Create(vals, 2, 0));
228     }
229 
230 protected:
onGetName()231     const char* onGetName() override {
232         return fName.c_str();
233     }
234 
onDraw(int loops,SkCanvas * canvas)235     void onDraw(int loops, SkCanvas* canvas) override {
236         SkPaint paint;
237         this->setupPaint(&paint);
238         paint.setStrokeWidth(fStrokeWidth);
239         paint.setStrokeCap(fIsRound ? SkPaint::kRound_Cap : SkPaint::kSquare_Cap);
240         paint.setPathEffect(fPE);
241         for (int i = 0; i < loops; ++i) {
242             canvas->drawLine(10 * SK_Scalar1, 10 * SK_Scalar1,
243                              640 * SK_Scalar1, 10 * SK_Scalar1, paint);
244         }
245     }
246 
247 private:
248     typedef Benchmark INHERITED;
249 };
250 
251 class DrawPointsDashingBench : public Benchmark {
252     SkString fName;
253     int      fStrokeWidth;
254     bool     fDoAA;
255 
256     SkAutoTUnref<SkPathEffect> fPathEffect;
257 
258 public:
DrawPointsDashingBench(int dashLength,int strokeWidth,bool doAA)259     DrawPointsDashingBench(int dashLength, int strokeWidth, bool doAA)
260          {
261         fName.printf("drawpointsdash_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
262         fStrokeWidth = strokeWidth;
263         fDoAA = doAA;
264 
265         SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) };
266         fPathEffect.reset(SkDashPathEffect::Create(vals, 2, SK_Scalar1));
267     }
268 
269 protected:
onGetName()270     const char* onGetName() override {
271         return fName.c_str();
272     }
273 
onDraw(int loops,SkCanvas * canvas)274     void onDraw(int loops, SkCanvas* canvas) override {
275         SkPaint p;
276         this->setupPaint(&p);
277         p.setColor(SK_ColorBLACK);
278         p.setStyle(SkPaint::kStroke_Style);
279         p.setStrokeWidth(SkIntToScalar(fStrokeWidth));
280         p.setPathEffect(fPathEffect);
281         p.setAntiAlias(fDoAA);
282 
283         SkPoint pts[2] = {
284             { SkIntToScalar(10), 0 },
285             { SkIntToScalar(640), 0 }
286         };
287 
288         for (int i = 0; i < loops; ++i) {
289             pts[0].fY = pts[1].fY = SkIntToScalar(i % 480);
290             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, pts, p);
291         }
292     }
293 
294 private:
295     typedef Benchmark INHERITED;
296 };
297 
298 // Want to test how we handle dashing when 99% of the dash is clipped out
299 class GiantDashBench : public Benchmark {
300     SkString fName;
301     SkScalar fStrokeWidth;
302     SkPoint  fPts[2];
303     SkAutoTUnref<SkPathEffect> fPathEffect;
304 
305 public:
306     enum LineType {
307         kHori_LineType,
308         kVert_LineType,
309         kDiag_LineType,
310         kLineTypeCount
311     };
312 
LineTypeName(LineType lt)313     static const char* LineTypeName(LineType lt) {
314         static const char* gNames[] = { "hori", "vert", "diag" };
315         static_assert(kLineTypeCount == SK_ARRAY_COUNT(gNames), "names_wrong_size");
316         return gNames[lt];
317     }
318 
GiantDashBench(LineType lt,SkScalar width)319     GiantDashBench(LineType lt, SkScalar width)  {
320         fName.printf("giantdashline_%s_%g", LineTypeName(lt), width);
321         fStrokeWidth = width;
322 
323         // deliberately pick intervals that won't be caught by asPoints(), so
324         // we can test the filterPath code-path.
325         const SkScalar intervals[] = { 20, 10, 10, 10 };
326         fPathEffect.reset(SkDashPathEffect::Create(intervals,
327                                                    SK_ARRAY_COUNT(intervals), 0));
328 
329         SkScalar cx = 640 / 2;  // center X
330         SkScalar cy = 480 / 2;  // center Y
331         SkMatrix matrix;
332 
333         switch (lt) {
334             case kHori_LineType:
335                 matrix.setIdentity();
336                 break;
337             case kVert_LineType:
338                 matrix.setRotate(90, cx, cy);
339                 break;
340             case kDiag_LineType:
341                 matrix.setRotate(45, cx, cy);
342                 break;
343             case kLineTypeCount:
344                 // Not a real enum value.
345                 break;
346         }
347 
348         const SkScalar overshoot = 100*1000;
349         const SkPoint pts[2] = {
350             { -overshoot, cy }, { 640 + overshoot, cy }
351         };
352         matrix.mapPoints(fPts, pts, 2);
353     }
354 
355 protected:
onGetName()356     const char* onGetName() override {
357         return fName.c_str();
358     }
359 
onDraw(int loops,SkCanvas * canvas)360     void onDraw(int loops, SkCanvas* canvas) override {
361         SkPaint p;
362         this->setupPaint(&p);
363         p.setStyle(SkPaint::kStroke_Style);
364         p.setStrokeWidth(fStrokeWidth);
365         p.setPathEffect(fPathEffect);
366 
367         for (int i = 0; i < loops; i++) {
368             canvas->drawPoints(SkCanvas::kLines_PointMode, 2, fPts, p);
369         }
370     }
371 
372 private:
373     typedef Benchmark INHERITED;
374 };
375 
376 // Want to test how we draw a dashed grid (like what is used in spreadsheets) of many
377 // small dashed lines switching back and forth between horizontal and vertical
378 class DashGridBench : public Benchmark {
379     SkString fName;
380     int      fStrokeWidth;
381     bool     fDoAA;
382 
383     SkAutoTUnref<SkPathEffect> fPathEffect;
384 
385 public:
DashGridBench(int dashLength,int strokeWidth,bool doAA)386     DashGridBench(int dashLength, int strokeWidth, bool doAA) {
387         fName.printf("dashgrid_%d_%d%s", dashLength, strokeWidth, doAA ? "_aa" : "_bw");
388         fStrokeWidth = strokeWidth;
389         fDoAA = doAA;
390 
391         SkScalar vals[] = { SkIntToScalar(dashLength), SkIntToScalar(dashLength) };
392         fPathEffect.reset(SkDashPathEffect::Create(vals, 2, SK_Scalar1));
393     }
394 
395 protected:
onGetName()396     const char* onGetName() override {
397         return fName.c_str();
398     }
399 
onDraw(int loops,SkCanvas * canvas)400     void onDraw(int loops, SkCanvas* canvas) override {
401         SkPaint p;
402         this->setupPaint(&p);
403         p.setColor(SK_ColorBLACK);
404         p.setStyle(SkPaint::kStroke_Style);
405         p.setStrokeWidth(SkIntToScalar(fStrokeWidth));
406         p.setPathEffect(fPathEffect);
407         p.setAntiAlias(fDoAA);
408 
409         SkPoint pts[4] = {
410             { SkIntToScalar(0), 20.5f },
411             { SkIntToScalar(20), 20.5f },
412             { 20.5f, SkIntToScalar(0) },
413             { 20.5f, SkIntToScalar(20) }
414         };
415 
416         for (int i = 0; i < loops; ++i) {
417             for (int j = 0; j < 10; ++j) {
418                 for (int k = 0; k < 10; ++k) {
419                     // Horizontal line
420                     SkPoint horPts[2];
421                     horPts[0].fX = pts[0].fX + k * 22.f;
422                     horPts[0].fY = pts[0].fY + j * 22.f;
423                     horPts[1].fX = pts[1].fX + k * 22.f;
424                     horPts[1].fY = pts[1].fY + j * 22.f;
425                     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, horPts, p);
426 
427                     // Vertical line
428                     SkPoint vertPts[2];
429                     vertPts[0].fX = pts[2].fX + k * 22.f;
430                     vertPts[0].fY = pts[2].fY + j * 22.f;
431                     vertPts[1].fX = pts[3].fX + k * 22.f;
432                     vertPts[1].fY = pts[3].fY + j * 22.f;
433                     canvas->drawPoints(SkCanvas::kLines_PointMode, 2, vertPts, p);
434                 }
435             }
436         }
437     }
438 
439 private:
440     typedef Benchmark INHERITED;
441 };
442 
443 ///////////////////////////////////////////////////////////////////////////////
444 
445 static const SkScalar gDots[] = { SK_Scalar1, SK_Scalar1 };
446 
447 #define PARAM(array)    array, SK_ARRAY_COUNT(array)
448 
449 DEF_BENCH( return new DashBench(PARAM(gDots), 0); )
450 DEF_BENCH( return new DashBench(PARAM(gDots), 1); )
451 DEF_BENCH( return new DashBench(PARAM(gDots), 1, true); )
452 DEF_BENCH( return new DashBench(PARAM(gDots), 4); )
453 DEF_BENCH( return new MakeDashBench(make_poly, "poly"); )
454 DEF_BENCH( return new MakeDashBench(make_quad, "quad"); )
455 DEF_BENCH( return new MakeDashBench(make_cubic, "cubic"); )
456 DEF_BENCH( return new DashLineBench(0, false); )
457 DEF_BENCH( return new DashLineBench(SK_Scalar1, false); )
458 DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, false); )
459 DEF_BENCH( return new DashLineBench(0, true); )
460 DEF_BENCH( return new DashLineBench(SK_Scalar1, true); )
461 DEF_BENCH( return new DashLineBench(2 * SK_Scalar1, true); )
462 
463 DEF_BENCH( return new DrawPointsDashingBench(1, 1, false); )
464 DEF_BENCH( return new DrawPointsDashingBench(1, 1, true); )
465 DEF_BENCH( return new DrawPointsDashingBench(3, 1, false); )
466 DEF_BENCH( return new DrawPointsDashingBench(3, 1, true); )
467 DEF_BENCH( return new DrawPointsDashingBench(5, 5, false); )
468 DEF_BENCH( return new DrawPointsDashingBench(5, 5, true); )
469 
470 /* Disable the GiantDashBench for Android devices until we can better control
471  * the memory usage. (https://code.google.com/p/skia/issues/detail?id=1430)
472  */
473 #ifndef SK_BUILD_FOR_ANDROID
474 DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 0); )
475 DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 0); )
476 DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 0); )
477 
478 // pass 2 to explicitly avoid any 1-is-the-same-as-hairline special casing
479 
480 // hori_2 is just too slow to enable at the moment
481 DEF_BENCH( return new GiantDashBench(GiantDashBench::kHori_LineType, 2); )
482 DEF_BENCH( return new GiantDashBench(GiantDashBench::kVert_LineType, 2); )
483 DEF_BENCH( return new GiantDashBench(GiantDashBench::kDiag_LineType, 2); )
484 
485 DEF_BENCH( return new DashGridBench(1, 1, true); )
486 DEF_BENCH( return new DashGridBench(1, 1, false); )
487 DEF_BENCH( return new DashGridBench(3, 1, true); )
488 DEF_BENCH( return new DashGridBench(3, 1, false); )
489 #endif
490