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 "SkColorPriv.h"
12 #include "SkGradientShader.h"
13 #include "SkLinearGradient.h"
14 #include "SkPaint.h"
15 #include "SkShader.h"
16 #include "SkString.h"
17
18 struct GradData {
19 int fCount;
20 const SkColor* fColors;
21 const SkScalar* fPos;
22 const char* fName;
23 };
24
25 static const SkColor gColors[] = {
26 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
27 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
28 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
29 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
30 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
31 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
32 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
33 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
34 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK,
35 SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE, SK_ColorBLACK, // 10 lines, 50 colors
36 };
37
38 static const SkColor gShallowColors[] = { 0xFF555555, 0xFF444444 };
39
40 // We have several special-cases depending on the number (and spacing) of colors, so
41 // try to exercise those here.
42 static const GradData gGradData[] = {
43 { 2, gColors, nullptr, "" },
44 { 50, gColors, nullptr, "_hicolor" }, // many color gradient
45 { 3, gColors, nullptr, "_3color" },
46 { 2, gShallowColors, nullptr, "_shallow" },
47 };
48
49 /// Ignores scale
MakeLinear(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)50 static SkShader* MakeLinear(const SkPoint pts[2], const GradData& data,
51 SkShader::TileMode tm, float scale, bool force4f) {
52 const uint32_t flags = force4f ? SkLinearGradient::kForce4fContext_PrivateFlag : 0;
53 return SkGradientShader::CreateLinear(pts, data.fColors, data.fPos,
54 data.fCount, tm, flags, nullptr);
55 }
56
MakeRadial(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)57 static SkShader* MakeRadial(const SkPoint pts[2], const GradData& data,
58 SkShader::TileMode tm, float scale, bool force4f) {
59 SkPoint center;
60 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
61 SkScalarAve(pts[0].fY, pts[1].fY));
62 return SkGradientShader::CreateRadial(center, center.fX * scale,
63 data.fColors,
64 data.fPos, data.fCount, tm);
65 }
66
67 /// Ignores scale
MakeSweep(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)68 static SkShader* MakeSweep(const SkPoint pts[2], const GradData& data,
69 SkShader::TileMode tm, float scale, bool force4f) {
70 SkPoint center;
71 center.set(SkScalarAve(pts[0].fX, pts[1].fX),
72 SkScalarAve(pts[0].fY, pts[1].fY));
73 return SkGradientShader::CreateSweep(center.fX, center.fY, data.fColors,
74 data.fPos, data.fCount);
75 }
76
77 /// Ignores scale
MakeConical(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)78 static SkShader* MakeConical(const SkPoint pts[2], const GradData& data,
79 SkShader::TileMode tm, float scale, bool force4f) {
80 SkPoint center0, center1;
81 center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
82 SkScalarAve(pts[0].fY, pts[1].fY));
83 center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
84 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
85 return SkGradientShader::CreateTwoPointConical(center1, (pts[1].fX - pts[0].fX) / 7,
86 center0, (pts[1].fX - pts[0].fX) / 2,
87 data.fColors, data.fPos, data.fCount, tm);
88 }
89
90 /// Ignores scale
MakeConicalZeroRad(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)91 static SkShader* MakeConicalZeroRad(const SkPoint pts[2], const GradData& data,
92 SkShader::TileMode tm, float scale, bool force4f) {
93 SkPoint center0, center1;
94 center0.set(SkScalarAve(pts[0].fX, pts[1].fX),
95 SkScalarAve(pts[0].fY, pts[1].fY));
96 center1.set(SkScalarInterp(pts[0].fX, pts[1].fX, SkIntToScalar(3)/5),
97 SkScalarInterp(pts[0].fY, pts[1].fY, SkIntToScalar(1)/4));
98 return SkGradientShader::CreateTwoPointConical(center1, 0.0,
99 center0, (pts[1].fX - pts[0].fX) / 2,
100 data.fColors, data.fPos, data.fCount, tm);
101 }
102
103 /// Ignores scale
MakeConicalOutside(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)104 static SkShader* MakeConicalOutside(const SkPoint pts[2], const GradData& data,
105 SkShader::TileMode tm, float scale, bool force4f) {
106 SkPoint center0, center1;
107 SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
108 SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
109 center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
110 center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
111 return SkGradientShader::CreateTwoPointConical(center0, radius0,
112 center1, radius1,
113 data.fColors, data.fPos,
114 data.fCount, tm);
115 }
116
117 /// Ignores scale
MakeConicalOutsideZeroRad(const SkPoint pts[2],const GradData & data,SkShader::TileMode tm,float scale,bool force4f)118 static SkShader* MakeConicalOutsideZeroRad(const SkPoint pts[2], const GradData& data,
119 SkShader::TileMode tm, float scale, bool force4f) {
120 SkPoint center0, center1;
121 SkScalar radius0 = (pts[1].fX - pts[0].fX) / 10;
122 SkScalar radius1 = (pts[1].fX - pts[0].fX) / 3;
123 center0.set(pts[0].fX + radius0, pts[0].fY + radius0);
124 center1.set(pts[1].fX - radius1, pts[1].fY - radius1);
125 return SkGradientShader::CreateTwoPointConical(center0, 0.0,
126 center1, radius1,
127 data.fColors, data.fPos,
128 data.fCount, tm);
129 }
130
131 typedef SkShader* (*GradMaker)(const SkPoint pts[2], const GradData& data,
132 SkShader::TileMode tm, float scale, bool force4f);
133
134 static const struct {
135 GradMaker fMaker;
136 const char* fName;
137 } gGrads[] = {
138 { MakeLinear, "linear" },
139 { MakeRadial, "radial1" },
140 { MakeSweep, "sweep" },
141 { MakeConical, "conical" },
142 { MakeConicalZeroRad, "conicalZero" },
143 { MakeConicalOutside, "conicalOut" },
144 { MakeConicalOutsideZeroRad, "conicalOutZero" },
145 };
146
147 enum GradType { // these must match the order in gGrads
148 kLinear_GradType,
149 kRadial_GradType,
150 kSweep_GradType,
151 kConical_GradType,
152 kConicalZero_GradType,
153 kConicalOut_GradType,
154 kConicalOutZero_GradType
155 };
156
157 enum GeomType {
158 kRect_GeomType,
159 kOval_GeomType
160 };
161
tilemodename(SkShader::TileMode tm)162 static const char* tilemodename(SkShader::TileMode tm) {
163 switch (tm) {
164 case SkShader::kClamp_TileMode:
165 return "clamp";
166 case SkShader::kRepeat_TileMode:
167 return "repeat";
168 case SkShader::kMirror_TileMode:
169 return "mirror";
170 default:
171 SkDEBUGFAIL("unknown tilemode");
172 return "error";
173 }
174 }
175
geomtypename(GeomType gt)176 static const char* geomtypename(GeomType gt) {
177 switch (gt) {
178 case kRect_GeomType:
179 return "rectangle";
180 case kOval_GeomType:
181 return "oval";
182 default:
183 SkDEBUGFAIL("unknown geometry type");
184 return "error";
185 }
186 }
187
188 ///////////////////////////////////////////////////////////////////////////////
189
190 class GradientBench : public Benchmark {
191 public:
GradientBench(GradType gradType,GradData data=gGradData[0],SkShader::TileMode tm=SkShader::kClamp_TileMode,GeomType geomType=kRect_GeomType,float scale=1.0f,bool force4f=false)192 GradientBench(GradType gradType,
193 GradData data = gGradData[0],
194 SkShader::TileMode tm = SkShader::kClamp_TileMode,
195 GeomType geomType = kRect_GeomType,
196 float scale = 1.0f,
197 bool force4f = false)
198 : fGeomType(geomType) {
199
200 fName.printf("gradient_%s_%s", gGrads[gradType].fName,
201 tilemodename(tm));
202 if (geomType != kRect_GeomType) {
203 fName.appendf("_%s", geomtypename(geomType));
204 }
205
206 if (scale != 1.f) {
207 fName.appendf("_scale_%g", scale);
208 }
209
210 fName.append(data.fName);
211
212 if (force4f) {
213 fName.append("_4f");
214 }
215
216 SkAutoTUnref<SkShader> shader(MakeShader(gradType, data, tm, scale, force4f));
217 this->setupPaint(&fPaint);
218 fPaint.setShader(shader);
219 }
220
GradientBench(GradType gradType,GradData data,bool dither,bool force4f=false)221 GradientBench(GradType gradType, GradData data, bool dither, bool force4f = false)
222 : fGeomType(kRect_GeomType) {
223
224 const char *tmname = tilemodename(SkShader::kClamp_TileMode);
225 fName.printf("gradient_%s_%s", gGrads[gradType].fName, tmname);
226 fName.append(data.fName);
227
228 if (dither) {
229 fName.appendf("_dither");
230 }
231
232 SkAutoTUnref<SkShader> shader(
233 MakeShader(gradType, data, SkShader::kClamp_TileMode, 1.0f, force4f));
234 this->setupPaint(&fPaint);
235 fPaint.setShader(shader);
236 fPaint.setDither(dither);
237 }
238
239 protected:
onGetName()240 const char* onGetName() override {
241 return fName.c_str();
242 }
243
onGetSize()244 SkIPoint onGetSize() override {
245 return SkIPoint::Make(kSize, kSize);
246 }
247
onDraw(int loops,SkCanvas * canvas)248 void onDraw(int loops, SkCanvas* canvas) override {
249 const SkRect r = SkRect::MakeIWH(kSize, kSize);
250
251 for (int i = 0; i < loops; i++) {
252 switch (fGeomType) {
253 case kRect_GeomType:
254 canvas->drawRect(r, fPaint);
255 break;
256 case kOval_GeomType:
257 canvas->drawOval(r, fPaint);
258 break;
259 }
260 }
261 }
262
263 private:
264 typedef Benchmark INHERITED;
265
MakeShader(GradType gradType,GradData data,SkShader::TileMode tm,float scale,bool force4f)266 SkShader* MakeShader(GradType gradType, GradData data,
267 SkShader::TileMode tm, float scale, bool force4f) {
268 const SkPoint pts[2] = {
269 { 0, 0 },
270 { SkIntToScalar(kSize), SkIntToScalar(kSize) }
271 };
272
273 return gGrads[gradType].fMaker(pts, data, tm, scale, force4f);
274 }
275
276 static const int kSize = 400;
277
278 SkString fName;
279 SkPaint fPaint;
280 const GeomType fGeomType;
281 };
282
283 // 4f
284 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kClamp_TileMode,
285 kRect_GeomType, 1, true); )
286 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kClamp_TileMode,
287 kRect_GeomType, 1, true); )
288 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kClamp_TileMode,
289 kRect_GeomType, 1, true); )
290 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kRepeat_TileMode,
291 kRect_GeomType, 1, true); )
292 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kRepeat_TileMode,
293 kRect_GeomType, 1, true); )
294 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kRepeat_TileMode,
295 kRect_GeomType, 1, true); )
296 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode,
297 kRect_GeomType, 1, true); )
298 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kMirror_TileMode,
299 kRect_GeomType, 1, true); )
300 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kMirror_TileMode,
301 kRect_GeomType, 1, true); )
302
303 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0]); )
304 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1]); )
305 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2]); )
306 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kRepeat_TileMode); )
307 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kRepeat_TileMode); )
308 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kRepeat_TileMode); )
309 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[0], SkShader::kMirror_TileMode); )
310 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[1], SkShader::kMirror_TileMode); )
311 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[2], SkShader::kMirror_TileMode); )
312
313 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0]); )
314 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[1]); )
315 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[2]); )
316 // Draw a radial gradient of radius 1/2 on a rectangle; half the lines should
317 // be completely pinned, the other half should pe partially pinned
318 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kRect_GeomType, 0.5f); )
319
320 // Draw a radial gradient on a circle of equal size; all the lines should
321 // hit the unpinned fast path (so long as GradientBench.W == H)
322 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kClamp_TileMode, kOval_GeomType); )
323
324 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kMirror_TileMode); )
325 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[0], SkShader::kRepeat_TileMode); )
326 DEF_BENCH( return new GradientBench(kSweep_GradType); )
327 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[1]); )
328 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[2]); )
329 DEF_BENCH( return new GradientBench(kConical_GradType); )
330 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[1]); )
331 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[2]); )
332 DEF_BENCH( return new GradientBench(kConicalZero_GradType); )
333 DEF_BENCH( return new GradientBench(kConicalZero_GradType, gGradData[1]); )
334 DEF_BENCH( return new GradientBench(kConicalZero_GradType, gGradData[2]); )
335 DEF_BENCH( return new GradientBench(kConicalOut_GradType); )
336 DEF_BENCH( return new GradientBench(kConicalOut_GradType, gGradData[1]); )
337 DEF_BENCH( return new GradientBench(kConicalOut_GradType, gGradData[2]); )
338 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType); )
339 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType, gGradData[1]); )
340 DEF_BENCH( return new GradientBench(kConicalOutZero_GradType, gGradData[2]); )
341
342 // Dithering
343 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[3], true); )
344 DEF_BENCH( return new GradientBench(kLinear_GradType, gGradData[3], false); )
345 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[3], true); )
346 DEF_BENCH( return new GradientBench(kRadial_GradType, gGradData[3], false); )
347 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[3], true); )
348 DEF_BENCH( return new GradientBench(kSweep_GradType, gGradData[3], false); )
349 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[3], true); )
350 DEF_BENCH( return new GradientBench(kConical_GradType, gGradData[3], false); )
351
352 ///////////////////////////////////////////////////////////////////////////////
353
354 class Gradient2Bench : public Benchmark {
355 SkString fName;
356 bool fHasAlpha;
357
358 public:
Gradient2Bench(bool hasAlpha)359 Gradient2Bench(bool hasAlpha) {
360 fName.printf("gradient_create_%s", hasAlpha ? "alpha" : "opaque");
361 fHasAlpha = hasAlpha;
362 }
363
364 protected:
onGetName()365 virtual const char* onGetName() {
366 return fName.c_str();
367 }
368
onDraw(int loops,SkCanvas * canvas)369 virtual void onDraw(int loops, SkCanvas* canvas) {
370 SkPaint paint;
371 this->setupPaint(&paint);
372
373 const SkRect r = { 0, 0, SkIntToScalar(4), SkIntToScalar(4) };
374 const SkPoint pts[] = {
375 { 0, 0 },
376 { SkIntToScalar(100), SkIntToScalar(100) },
377 };
378
379 for (int i = 0; i < loops; i++) {
380 const int gray = i % 256;
381 const int alpha = fHasAlpha ? gray : 0xFF;
382 SkColor colors[] = {
383 SK_ColorBLACK,
384 SkColorSetARGB(alpha, gray, gray, gray),
385 SK_ColorWHITE };
386 SkShader* s = SkGradientShader::CreateLinear(pts, colors, nullptr,
387 SK_ARRAY_COUNT(colors),
388 SkShader::kClamp_TileMode);
389 paint.setShader(s)->unref();
390 canvas->drawRect(r, paint);
391 }
392 }
393
394 private:
395 typedef Benchmark INHERITED;
396 };
397
398 DEF_BENCH( return new Gradient2Bench(false); )
399 DEF_BENCH( return new Gradient2Bench(true); )
400