OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "Benchmark.h" | 8 #include "Benchmark.h" |
9 #include "SkCanvas.h" | 9 #include "SkCanvas.h" |
10 #include "SkColorFilterImageFilter.h" | 10 #include "SkColorFilterImageFilter.h" |
11 #include "SkColorMatrixFilter.h" | 11 #include "SkColorMatrixFilter.h" |
12 #include "SkLumaColorFilter.h" | |
13 #include "SkTableColorFilter.h" | |
14 | 12 |
15 #define FILTER_WIDTH_SMALL SkIntToScalar(32) | 13 #define FILTER_WIDTH_SMALL SkIntToScalar(32) |
16 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) | 14 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) |
17 #define FILTER_WIDTH_LARGE SkIntToScalar(256) | 15 #define FILTER_WIDTH_LARGE SkIntToScalar(256) |
18 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) | 16 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) |
19 | 17 |
| 18 static sk_sp<SkImageFilter> make_brightness(float amount, sk_sp<SkImageFilter> i
nput) { |
| 19 SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255)); |
| 20 SkScalar matrix[20] = { 1, 0, 0, 0, amount255, |
| 21 0, 1, 0, 0, amount255, |
| 22 0, 0, 1, 0, amount255, |
| 23 0, 0, 0, 1, 0 }; |
| 24 sk_sp<SkColorFilter> filter(SkColorFilter::MakeMatrixFilterRowMajor255(matri
x)); |
| 25 return SkColorFilterImageFilter::Make(std::move(filter), std::move(input)); |
| 26 } |
| 27 |
| 28 static sk_sp<SkImageFilter> make_grayscale(sk_sp<SkImageFilter> input) { |
| 29 SkScalar matrix[20]; |
| 30 memset(matrix, 0, 20 * sizeof(SkScalar)); |
| 31 matrix[0] = matrix[5] = matrix[10] = 0.2126f; |
| 32 matrix[1] = matrix[6] = matrix[11] = 0.7152f; |
| 33 matrix[2] = matrix[7] = matrix[12] = 0.0722f; |
| 34 matrix[18] = 1.0f; |
| 35 sk_sp<SkColorFilter> filter(SkColorFilter::MakeMatrixFilterRowMajor255(matri
x)); |
| 36 return SkColorFilterImageFilter::Make(std::move(filter), std::move(input)); |
| 37 } |
| 38 |
| 39 static sk_sp<SkImageFilter> make_mode_blue(sk_sp<SkImageFilter> input) { |
| 40 sk_sp<SkColorFilter> filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, |
| 41 SkXfermode::kSrcIn
_Mode)); |
| 42 return SkColorFilterImageFilter::Make(std::move(filter), std::move(input)); |
| 43 } |
| 44 |
20 class ColorFilterBaseBench : public Benchmark { | 45 class ColorFilterBaseBench : public Benchmark { |
21 | 46 |
22 public: | 47 public: |
23 ColorFilterBaseBench(bool small) : fIsSmall(small) {} | 48 ColorFilterBaseBench(bool small) : fIsSmall(small) {} |
24 | 49 |
25 protected: | 50 protected: |
26 SkRect getFilterRect() const { | 51 SkRect getFilterRect() const { |
27 return isSmall() ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMAL
L) : | 52 return this->isSmall() ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGH
T_SMALL) : |
28 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARG
E); | 53 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGH
T_LARGE); |
29 } | |
30 | |
31 static SkImageFilter* make_brightness(float amount, SkImageFilter* input = n
ullptr) { | |
32 SkScalar amount255 = SkScalarMul(amount, SkIntToScalar(255)); | |
33 SkScalar matrix[20] = { 1, 0, 0, 0, amount255, | |
34 0, 1, 0, 0, amount255, | |
35 0, 0, 1, 0, amount255, | |
36 0, 0, 0, 1, 0 }; | |
37 auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); | |
38 return SkColorFilterImageFilter::Create(filter.get(), input); | |
39 } | |
40 | |
41 static SkImageFilter* make_grayscale(SkImageFilter* input = nullptr) { | |
42 SkScalar matrix[20]; | |
43 memset(matrix, 0, 20 * sizeof(SkScalar)); | |
44 matrix[0] = matrix[5] = matrix[10] = 0.2126f; | |
45 matrix[1] = matrix[6] = matrix[11] = 0.7152f; | |
46 matrix[2] = matrix[7] = matrix[12] = 0.0722f; | |
47 matrix[18] = 1.0f; | |
48 auto filter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix)); | |
49 return SkColorFilterImageFilter::Create(filter.get(), input); | |
50 } | |
51 | |
52 static SkImageFilter* make_mode_blue(SkImageFilter* input = nullptr) { | |
53 auto filter(SkColorFilter::MakeModeFilter(SK_ColorBLUE, SkXfermode::kSrc
In_Mode)); | |
54 return SkColorFilterImageFilter::Create(filter.get(), input); | |
55 } | 54 } |
56 | 55 |
57 inline bool isSmall() const { return fIsSmall; } | 56 inline bool isSmall() const { return fIsSmall; } |
58 | 57 |
59 private: | 58 private: |
60 bool fIsSmall; | 59 bool fIsSmall; |
61 | 60 |
62 typedef Benchmark INHERITED; | 61 typedef Benchmark INHERITED; |
63 }; | 62 }; |
64 | 63 |
65 class ColorFilterDimBrightBench : public ColorFilterBaseBench { | 64 class ColorFilterDimBrightBench : public ColorFilterBaseBench { |
66 | 65 |
67 public: | 66 public: |
68 ColorFilterDimBrightBench(bool small) : INHERITED(small) { | 67 ColorFilterDimBrightBench(bool small) : INHERITED(small) { } |
69 } | |
70 | 68 |
71 protected: | 69 protected: |
72 const char* onGetName() override { | 70 const char* onGetName() override { |
73 return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bri
ght_large"; | 71 return this->isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_d
im_bright_large"; |
74 } | 72 } |
75 | 73 |
76 void onDraw(int loops, SkCanvas* canvas) override { | 74 void onDraw(int loops, SkCanvas* canvas) override { |
77 SkRect r = getFilterRect(); | 75 SkRect r = this->getFilterRect(); |
78 SkPaint paint; | 76 SkPaint paint; |
79 paint.setColor(SK_ColorRED); | 77 paint.setColor(SK_ColorRED); |
80 | 78 |
81 for (int i = 0; i < loops; i++) { | 79 for (int i = 0; i < loops; i++) { |
82 for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.4
f) { | 80 for (float brightness = -1.0f; brightness <= 1.0f; brightness += 0.4
f) { |
83 SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness)); | 81 sk_sp<SkImageFilter> dim(make_brightness(-brightness, nullptr)); |
84 SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, d
im)); | 82 paint.setImageFilter(make_brightness(brightness, std::move(dim))
); |
85 paint.setImageFilter(bright); | |
86 canvas->drawRect(r, paint); | 83 canvas->drawRect(r, paint); |
87 } | 84 } |
88 } | 85 } |
89 } | 86 } |
90 | 87 |
91 private: | 88 private: |
92 typedef ColorFilterBaseBench INHERITED; | 89 typedef ColorFilterBaseBench INHERITED; |
93 }; | 90 }; |
94 | 91 |
95 class ColorFilterBrightGrayBench : public ColorFilterBaseBench { | 92 class ColorFilterBrightGrayBench : public ColorFilterBaseBench { |
96 | 93 |
97 public: | 94 public: |
98 ColorFilterBrightGrayBench(bool small) : INHERITED(small) { | 95 ColorFilterBrightGrayBench(bool small) : INHERITED(small) { } |
99 } | |
100 | 96 |
101 protected: | 97 protected: |
102 const char* onGetName() override { | 98 const char* onGetName() override { |
103 return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright
_gray_large"; | 99 return this->isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_
bright_gray_large"; |
104 } | 100 } |
105 | 101 |
106 void onDraw(int loops, SkCanvas* canvas) override { | 102 void onDraw(int loops, SkCanvas* canvas) override { |
107 SkRect r = getFilterRect(); | 103 SkRect r = this->getFilterRect(); |
108 SkPaint paint; | 104 SkPaint paint; |
109 paint.setColor(SK_ColorRED); | 105 paint.setColor(SK_ColorRED); |
110 for (int i = 0; i < loops; i++) { | 106 for (int i = 0; i < loops; i++) { |
111 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f)); | 107 sk_sp<SkImageFilter> brightness(make_brightness(0.9f, nullptr)); |
112 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness)); | 108 paint.setImageFilter(make_grayscale(std::move(brightness))); |
113 paint.setImageFilter(grayscale); | |
114 canvas->drawRect(r, paint); | 109 canvas->drawRect(r, paint); |
115 } | 110 } |
116 } | 111 } |
117 | 112 |
118 private: | 113 private: |
119 typedef ColorFilterBaseBench INHERITED; | 114 typedef ColorFilterBaseBench INHERITED; |
120 }; | 115 }; |
121 | 116 |
122 class ColorFilterGrayBrightBench : public ColorFilterBaseBench { | 117 class ColorFilterGrayBrightBench : public ColorFilterBaseBench { |
123 | 118 |
124 public: | 119 public: |
125 ColorFilterGrayBrightBench(bool small) : INHERITED(small) { | 120 ColorFilterGrayBrightBench(bool small) : INHERITED(small) { } |
126 } | |
127 | 121 |
128 protected: | 122 protected: |
129 const char* onGetName() override { | 123 const char* onGetName() override { |
130 return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_b
right_large"; | 124 return this->isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_
gray_bright_large"; |
131 } | 125 } |
132 | 126 |
133 void onDraw(int loops, SkCanvas* canvas) override { | 127 void onDraw(int loops, SkCanvas* canvas) override { |
134 SkRect r = getFilterRect(); | 128 SkRect r = this->getFilterRect(); |
135 SkPaint paint; | 129 SkPaint paint; |
136 paint.setColor(SK_ColorRED); | 130 paint.setColor(SK_ColorRED); |
137 for (int i = 0; i < loops; i++) { | 131 for (int i = 0; i < loops; i++) { |
138 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); | 132 sk_sp<SkImageFilter> grayscale(make_grayscale(nullptr)); |
139 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, graysca
le)); | 133 paint.setImageFilter(make_brightness(0.9f, std::move(grayscale))); |
140 paint.setImageFilter(brightness); | |
141 canvas->drawRect(r, paint); | 134 canvas->drawRect(r, paint); |
142 } | 135 } |
143 } | 136 } |
144 | 137 |
145 private: | 138 private: |
146 typedef ColorFilterBaseBench INHERITED; | 139 typedef ColorFilterBaseBench INHERITED; |
147 }; | 140 }; |
148 | 141 |
149 class ColorFilterBlueBrightBench : public ColorFilterBaseBench { | 142 class ColorFilterBlueBrightBench : public ColorFilterBaseBench { |
150 | 143 |
151 public: | 144 public: |
152 ColorFilterBlueBrightBench(bool small) : INHERITED(small) { | 145 ColorFilterBlueBrightBench(bool small) : INHERITED(small) { } |
153 } | |
154 | 146 |
155 protected: | 147 protected: |
156 const char* onGetName() override { | 148 const char* onGetName() override { |
157 return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_b
right_large"; | 149 return this->isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_
blue_bright_large"; |
158 } | 150 } |
159 | 151 |
160 void onDraw(int loops, SkCanvas* canvas) override { | 152 void onDraw(int loops, SkCanvas* canvas) override { |
161 SkRect r = getFilterRect(); | 153 SkRect r = this->getFilterRect(); |
162 SkPaint paint; | 154 SkPaint paint; |
163 paint.setColor(SK_ColorRED); | 155 paint.setColor(SK_ColorRED); |
164 for (int i = 0; i < loops; i++) { | 156 for (int i = 0; i < loops; i++) { |
165 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); | 157 sk_sp<SkImageFilter> blue(make_mode_blue(nullptr)); |
166 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue)); | 158 paint.setImageFilter(make_brightness(1.0f, std::move(blue))); |
167 paint.setImageFilter(brightness); | |
168 canvas->drawRect(r, paint); | 159 canvas->drawRect(r, paint); |
169 } | 160 } |
170 } | 161 } |
171 | 162 |
172 private: | 163 private: |
173 typedef ColorFilterBaseBench INHERITED; | 164 typedef ColorFilterBaseBench INHERITED; |
174 }; | 165 }; |
175 | 166 |
176 class ColorFilterBrightBlueBench : public ColorFilterBaseBench { | 167 class ColorFilterBrightBlueBench : public ColorFilterBaseBench { |
177 | 168 |
178 public: | 169 public: |
179 ColorFilterBrightBlueBench(bool small) : INHERITED(small) { | 170 ColorFilterBrightBlueBench(bool small) : INHERITED(small) { } |
180 } | |
181 | 171 |
182 protected: | 172 protected: |
183 const char* onGetName() override { | 173 const char* onGetName() override { |
184 return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright
_blue_large"; | 174 return this->isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_
bright_blue_large"; |
185 } | 175 } |
186 | 176 |
187 void onDraw(int loops, SkCanvas* canvas) override { | 177 void onDraw(int loops, SkCanvas* canvas) override { |
188 SkRect r = getFilterRect(); | 178 SkRect r = this->getFilterRect(); |
189 SkPaint paint; | 179 SkPaint paint; |
190 paint.setColor(SK_ColorRED); | 180 paint.setColor(SK_ColorRED); |
191 for (int i = 0; i < loops; i++) { | 181 for (int i = 0; i < loops; i++) { |
192 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); | 182 sk_sp<SkImageFilter> brightness(make_brightness(1.0f, nullptr)); |
193 SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness)); | 183 paint.setImageFilter(make_mode_blue(std::move(brightness))); |
194 paint.setImageFilter(blue); | |
195 canvas->drawRect(r, paint); | 184 canvas->drawRect(r, paint); |
196 } | 185 } |
197 } | 186 } |
198 | 187 |
199 private: | 188 private: |
200 typedef ColorFilterBaseBench INHERITED; | 189 typedef ColorFilterBaseBench INHERITED; |
201 }; | 190 }; |
202 | 191 |
203 class ColorFilterBrightBench : public ColorFilterBaseBench { | 192 class ColorFilterBrightBench : public ColorFilterBaseBench { |
204 | 193 |
205 public: | 194 public: |
206 ColorFilterBrightBench(bool small) : INHERITED(small) { | 195 ColorFilterBrightBench(bool small) : INHERITED(small) { } |
207 } | |
208 | 196 |
209 protected: | 197 protected: |
210 const char* onGetName() override { | 198 const char* onGetName() override { |
211 return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_larg
e"; | 199 return this->isSmall() ? "colorfilter_bright_small" : "colorfilter_brigh
t_large"; |
212 } | 200 } |
213 | 201 |
214 void onDraw(int loops, SkCanvas* canvas) override { | 202 void onDraw(int loops, SkCanvas* canvas) override { |
215 SkRect r = getFilterRect(); | 203 SkRect r = this->getFilterRect(); |
216 SkPaint paint; | 204 SkPaint paint; |
217 paint.setColor(SK_ColorRED); | 205 paint.setColor(SK_ColorRED); |
218 for (int i = 0; i < loops; i++) { | 206 for (int i = 0; i < loops; i++) { |
219 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); | 207 paint.setImageFilter(make_brightness(1.0f, nullptr)); |
220 paint.setImageFilter(brightness); | |
221 canvas->drawRect(r, paint); | 208 canvas->drawRect(r, paint); |
222 } | 209 } |
223 } | 210 } |
224 | 211 |
225 private: | 212 private: |
226 typedef ColorFilterBaseBench INHERITED; | 213 typedef ColorFilterBaseBench INHERITED; |
227 }; | 214 }; |
228 | 215 |
229 class ColorFilterBlueBench : public ColorFilterBaseBench { | 216 class ColorFilterBlueBench : public ColorFilterBaseBench { |
230 | 217 |
231 public: | 218 public: |
232 ColorFilterBlueBench(bool small) : INHERITED(small) { | 219 ColorFilterBlueBench(bool small) : INHERITED(small) { } |
233 } | |
234 | 220 |
235 protected: | 221 protected: |
236 const char* onGetName() override { | 222 const char* onGetName() override { |
237 return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large"; | 223 return this->isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_la
rge"; |
238 } | 224 } |
239 | 225 |
240 void onDraw(int loops, SkCanvas* canvas) override { | 226 void onDraw(int loops, SkCanvas* canvas) override { |
241 SkRect r = getFilterRect(); | 227 SkRect r = this->getFilterRect(); |
242 SkPaint paint; | 228 SkPaint paint; |
243 paint.setColor(SK_ColorRED); | 229 paint.setColor(SK_ColorRED); |
244 for (int i = 0; i < loops; i++) { | 230 for (int i = 0; i < loops; i++) { |
245 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); | 231 paint.setImageFilter(make_mode_blue(nullptr)); |
246 paint.setImageFilter(blue); | |
247 canvas->drawRect(r, paint); | 232 canvas->drawRect(r, paint); |
248 } | 233 } |
249 } | 234 } |
250 | 235 |
251 private: | 236 private: |
252 typedef ColorFilterBaseBench INHERITED; | 237 typedef ColorFilterBaseBench INHERITED; |
253 }; | 238 }; |
254 | 239 |
255 class ColorFilterGrayBench : public ColorFilterBaseBench { | 240 class ColorFilterGrayBench : public ColorFilterBaseBench { |
256 | 241 |
257 public: | 242 public: |
258 ColorFilterGrayBench(bool small) : INHERITED(small) {} | 243 ColorFilterGrayBench(bool small) : INHERITED(small) { } |
259 | 244 |
260 protected: | 245 protected: |
261 const char* onGetName() override { | 246 const char* onGetName() override { |
262 return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large"; | 247 return this->isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_la
rge"; |
263 } | 248 } |
264 | 249 |
265 void onDraw(int loops, SkCanvas* canvas) override { | 250 void onDraw(int loops, SkCanvas* canvas) override { |
266 SkRect r = getFilterRect(); | 251 SkRect r = this->getFilterRect(); |
267 SkPaint paint; | 252 SkPaint paint; |
268 paint.setColor(SK_ColorRED); | 253 paint.setColor(SK_ColorRED); |
269 for (int i = 0; i < loops; i++) { | 254 for (int i = 0; i < loops; i++) { |
270 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); | 255 paint.setImageFilter(make_grayscale(nullptr)); |
271 paint.setImageFilter(grayscale); | |
272 canvas->drawRect(r, paint); | 256 canvas->drawRect(r, paint); |
273 } | 257 } |
274 } | 258 } |
275 | 259 |
276 private: | 260 private: |
277 typedef ColorFilterBaseBench INHERITED; | 261 typedef ColorFilterBaseBench INHERITED; |
278 }; | 262 }; |
279 | 263 |
280 /////////////////////////////////////////////////////////////////////////////// | 264 /////////////////////////////////////////////////////////////////////////////// |
281 | 265 |
282 DEF_BENCH( return new ColorFilterDimBrightBench(true); ) | 266 DEF_BENCH( return new ColorFilterDimBrightBench(true); ) |
283 DEF_BENCH( return new ColorFilterBrightGrayBench(true); ) | 267 DEF_BENCH( return new ColorFilterBrightGrayBench(true); ) |
284 DEF_BENCH( return new ColorFilterGrayBrightBench(true); ) | 268 DEF_BENCH( return new ColorFilterGrayBrightBench(true); ) |
285 DEF_BENCH( return new ColorFilterBlueBrightBench(true); ) | 269 DEF_BENCH( return new ColorFilterBlueBrightBench(true); ) |
286 DEF_BENCH( return new ColorFilterBrightBlueBench(true); ) | 270 DEF_BENCH( return new ColorFilterBrightBlueBench(true); ) |
287 DEF_BENCH( return new ColorFilterBrightBench(true); ) | 271 DEF_BENCH( return new ColorFilterBrightBench(true); ) |
288 DEF_BENCH( return new ColorFilterBlueBench(true); ) | 272 DEF_BENCH( return new ColorFilterBlueBench(true); ) |
289 DEF_BENCH( return new ColorFilterGrayBench(true); ) | 273 DEF_BENCH( return new ColorFilterGrayBench(true); ) |
290 | 274 |
291 DEF_BENCH( return new ColorFilterDimBrightBench(false); ) | 275 DEF_BENCH( return new ColorFilterDimBrightBench(false); ) |
292 DEF_BENCH( return new ColorFilterBrightGrayBench(false); ) | 276 DEF_BENCH( return new ColorFilterBrightGrayBench(false); ) |
293 DEF_BENCH( return new ColorFilterGrayBrightBench(false); ) | 277 DEF_BENCH( return new ColorFilterGrayBrightBench(false); ) |
294 DEF_BENCH( return new ColorFilterBlueBrightBench(false); ) | 278 DEF_BENCH( return new ColorFilterBlueBrightBench(false); ) |
295 DEF_BENCH( return new ColorFilterBrightBlueBench(false); ) | 279 DEF_BENCH( return new ColorFilterBrightBlueBench(false); ) |
296 DEF_BENCH( return new ColorFilterBrightBench(false); ) | 280 DEF_BENCH( return new ColorFilterBrightBench(false); ) |
297 DEF_BENCH( return new ColorFilterBlueBench(false); ) | 281 DEF_BENCH( return new ColorFilterBlueBench(false); ) |
298 DEF_BENCH( return new ColorFilterGrayBench(false); ) | 282 DEF_BENCH( return new ColorFilterGrayBench(false); ) |
OLD | NEW |