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 #include "SkBenchmark.h" | 7 #include "SkBenchmark.h" |
8 #include "SkCanvas.h" | 8 #include "SkCanvas.h" |
9 #include "SkColorFilterImageFilter.h" | 9 #include "SkColorFilterImageFilter.h" |
10 #include "SkColorMatrixFilter.h" | 10 #include "SkColorMatrixFilter.h" |
11 #include "SkTableColorFilter.h" | 11 #include "SkTableColorFilter.h" |
12 | 12 |
13 #define FILTER_WIDTH_SMALL SkIntToScalar(32) | 13 #define FILTER_WIDTH_SMALL SkIntToScalar(32) |
14 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) | 14 #define FILTER_HEIGHT_SMALL SkIntToScalar(32) |
15 #define FILTER_WIDTH_LARGE SkIntToScalar(256) | 15 #define FILTER_WIDTH_LARGE SkIntToScalar(256) |
16 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) | 16 #define FILTER_HEIGHT_LARGE SkIntToScalar(256) |
17 | 17 |
18 class ColorFilterBaseBench : public SkBenchmark { | 18 class ColorFilterBaseBench : public SkBenchmark { |
19 | 19 |
20 public: | 20 public: |
21 ColorFilterBaseBench(void* param, bool small) : INHERITED(param), fIsSmall(s
mall) { | 21 ColorFilterBaseBench(bool small) : fIsSmall(small) { } |
22 } | |
23 | 22 |
24 protected: | 23 protected: |
25 SkRect getFilterRect() const { | 24 SkRect getFilterRect() const { |
26 return isSmall() ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMAL
L) : | 25 return isSmall() ? SkRect::MakeWH(FILTER_WIDTH_SMALL, FILTER_HEIGHT_SMAL
L) : |
27 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARG
E); | 26 SkRect::MakeWH(FILTER_WIDTH_LARGE, FILTER_HEIGHT_LARG
E); |
28 } | 27 } |
29 | 28 |
30 static SkImageFilter* make_brightness(float amount, SkImageFilter* input = N
ULL) { | 29 static SkImageFilter* make_brightness(float amount, SkImageFilter* input = N
ULL) { |
31 SkScalar amount255 = SkScalarMul(SkFloatToScalar(amount), SkIntToScalar(
255)); | 30 SkScalar amount255 = SkScalarMul(SkFloatToScalar(amount), SkIntToScalar(
255)); |
32 SkScalar matrix[20] = { 1, 0, 0, 0, amount255, | 31 SkScalar matrix[20] = { 1, 0, 0, 0, amount255, |
(...skipping 24 matching lines...) Expand all Loading... |
57 inline bool isSmall() const { return fIsSmall; } | 56 inline bool isSmall() const { return fIsSmall; } |
58 private: | 57 private: |
59 bool fIsSmall; | 58 bool fIsSmall; |
60 | 59 |
61 typedef SkBenchmark INHERITED; | 60 typedef SkBenchmark INHERITED; |
62 }; | 61 }; |
63 | 62 |
64 class ColorFilterDimBrightBench : public ColorFilterBaseBench { | 63 class ColorFilterDimBrightBench : public ColorFilterBaseBench { |
65 | 64 |
66 public: | 65 public: |
67 ColorFilterDimBrightBench(void* param, bool small) : INHERITED(param, small)
{ | 66 ColorFilterDimBrightBench(bool small) : INHERITED(small) { |
68 } | 67 } |
69 | 68 |
70 protected: | 69 protected: |
71 virtual const char* onGetName() SK_OVERRIDE { | 70 virtual const char* onGetName() SK_OVERRIDE { |
72 return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bri
ght_large"; | 71 return isSmall() ? "colorfilter_dim_bright_small" : "colorfilter_dim_bri
ght_large"; |
73 } | 72 } |
74 | 73 |
75 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 74 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
76 SkRect r = getFilterRect(); | 75 SkRect r = getFilterRect(); |
77 SkPaint paint; | 76 SkPaint paint; |
78 paint.setColor(SK_ColorRED); | 77 paint.setColor(SK_ColorRED); |
79 | 78 |
80 for (int i = 0; i < this->getLoops(); i++) { | 79 for (int i = 0; i < this->getLoops(); i++) { |
81 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) { |
82 SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness)); | 81 SkAutoTUnref<SkImageFilter> dim(make_brightness(-brightness)); |
83 SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, d
im)); | 82 SkAutoTUnref<SkImageFilter> bright(make_brightness(brightness, d
im)); |
84 paint.setImageFilter(bright); | 83 paint.setImageFilter(bright); |
85 canvas->drawRect(r, paint); | 84 canvas->drawRect(r, paint); |
86 } | 85 } |
87 } | 86 } |
88 } | 87 } |
89 | 88 |
90 private: | 89 private: |
91 typedef ColorFilterBaseBench INHERITED; | 90 typedef ColorFilterBaseBench INHERITED; |
92 }; | 91 }; |
93 | 92 |
94 class ColorFilterBrightGrayBench : public ColorFilterBaseBench { | 93 class ColorFilterBrightGrayBench : public ColorFilterBaseBench { |
95 | 94 |
96 public: | 95 public: |
97 ColorFilterBrightGrayBench(void* param, bool small) : INHERITED(param, small
) { | 96 ColorFilterBrightGrayBench(bool small) : INHERITED(small) { |
98 } | 97 } |
99 | 98 |
100 protected: | 99 protected: |
101 virtual const char* onGetName() SK_OVERRIDE { | 100 virtual const char* onGetName() SK_OVERRIDE { |
102 return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright
_gray_large"; | 101 return isSmall() ? "colorfilter_bright_gray_small" : "colorfilter_bright
_gray_large"; |
103 } | 102 } |
104 | 103 |
105 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 104 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
106 SkRect r = getFilterRect(); | 105 SkRect r = getFilterRect(); |
107 SkPaint paint; | 106 SkPaint paint; |
108 paint.setColor(SK_ColorRED); | 107 paint.setColor(SK_ColorRED); |
109 for (int i = 0; i < this->getLoops(); i++) { | 108 for (int i = 0; i < this->getLoops(); i++) { |
110 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f)); | 109 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f)); |
111 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness)); | 110 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale(brightness)); |
112 paint.setImageFilter(grayscale); | 111 paint.setImageFilter(grayscale); |
113 canvas->drawRect(r, paint); | 112 canvas->drawRect(r, paint); |
114 } | 113 } |
115 } | 114 } |
116 | 115 |
117 private: | 116 private: |
118 typedef ColorFilterBaseBench INHERITED; | 117 typedef ColorFilterBaseBench INHERITED; |
119 }; | 118 }; |
120 | 119 |
121 class ColorFilterGrayBrightBench : public ColorFilterBaseBench { | 120 class ColorFilterGrayBrightBench : public ColorFilterBaseBench { |
122 | 121 |
123 public: | 122 public: |
124 ColorFilterGrayBrightBench(void* param, bool small) : INHERITED(param, small
) { | 123 ColorFilterGrayBrightBench(bool small) : INHERITED(small) { |
125 } | 124 } |
126 | 125 |
127 protected: | 126 protected: |
128 virtual const char* onGetName() SK_OVERRIDE { | 127 virtual const char* onGetName() SK_OVERRIDE { |
129 return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_b
right_large"; | 128 return isSmall() ? "colorfilter_gray_bright_small" : "colorfilter_gray_b
right_large"; |
130 } | 129 } |
131 | 130 |
132 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 131 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
133 SkRect r = getFilterRect(); | 132 SkRect r = getFilterRect(); |
134 SkPaint paint; | 133 SkPaint paint; |
135 paint.setColor(SK_ColorRED); | 134 paint.setColor(SK_ColorRED); |
136 for (int i = 0; i < this->getLoops(); i++) { | 135 for (int i = 0; i < this->getLoops(); i++) { |
137 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); | 136 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); |
138 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, graysca
le)); | 137 SkAutoTUnref<SkImageFilter> brightness(make_brightness(0.9f, graysca
le)); |
139 paint.setImageFilter(brightness); | 138 paint.setImageFilter(brightness); |
140 canvas->drawRect(r, paint); | 139 canvas->drawRect(r, paint); |
141 } | 140 } |
142 } | 141 } |
143 | 142 |
144 private: | 143 private: |
145 typedef ColorFilterBaseBench INHERITED; | 144 typedef ColorFilterBaseBench INHERITED; |
146 }; | 145 }; |
147 | 146 |
148 class ColorFilterBlueBrightBench : public ColorFilterBaseBench { | 147 class ColorFilterBlueBrightBench : public ColorFilterBaseBench { |
149 | 148 |
150 public: | 149 public: |
151 ColorFilterBlueBrightBench(void* param, bool small) : INHERITED(param, small
) { | 150 ColorFilterBlueBrightBench(bool small) : INHERITED(small) { |
152 } | 151 } |
153 | 152 |
154 protected: | 153 protected: |
155 virtual const char* onGetName() SK_OVERRIDE { | 154 virtual const char* onGetName() SK_OVERRIDE { |
156 return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_b
right_large"; | 155 return isSmall() ? "colorfilter_blue_bright_small" : "colorfilter_blue_b
right_large"; |
157 } | 156 } |
158 | 157 |
159 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 158 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
160 SkRect r = getFilterRect(); | 159 SkRect r = getFilterRect(); |
161 SkPaint paint; | 160 SkPaint paint; |
162 paint.setColor(SK_ColorRED); | 161 paint.setColor(SK_ColorRED); |
163 for (int i = 0; i < this->getLoops(); i++) { | 162 for (int i = 0; i < this->getLoops(); i++) { |
164 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); | 163 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); |
165 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue)); | 164 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f, blue)); |
166 paint.setImageFilter(brightness); | 165 paint.setImageFilter(brightness); |
167 canvas->drawRect(r, paint); | 166 canvas->drawRect(r, paint); |
168 } | 167 } |
169 } | 168 } |
170 | 169 |
171 private: | 170 private: |
172 typedef ColorFilterBaseBench INHERITED; | 171 typedef ColorFilterBaseBench INHERITED; |
173 }; | 172 }; |
174 | 173 |
175 class ColorFilterBrightBlueBench : public ColorFilterBaseBench { | 174 class ColorFilterBrightBlueBench : public ColorFilterBaseBench { |
176 | 175 |
177 public: | 176 public: |
178 ColorFilterBrightBlueBench(void* param, bool small) : INHERITED(param, small
) { | 177 ColorFilterBrightBlueBench(bool small) : INHERITED(small) { |
179 } | 178 } |
180 | 179 |
181 protected: | 180 protected: |
182 virtual const char* onGetName() SK_OVERRIDE { | 181 virtual const char* onGetName() SK_OVERRIDE { |
183 return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright
_blue_large"; | 182 return isSmall() ? "colorfilter_bright_blue_small" : "colorfilter_bright
_blue_large"; |
184 } | 183 } |
185 | 184 |
186 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 185 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
187 SkRect r = getFilterRect(); | 186 SkRect r = getFilterRect(); |
188 SkPaint paint; | 187 SkPaint paint; |
189 paint.setColor(SK_ColorRED); | 188 paint.setColor(SK_ColorRED); |
190 for (int i = 0; i < this->getLoops(); i++) { | 189 for (int i = 0; i < this->getLoops(); i++) { |
191 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); | 190 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); |
192 SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness)); | 191 SkAutoTUnref<SkImageFilter> blue(make_mode_blue(brightness)); |
193 paint.setImageFilter(blue); | 192 paint.setImageFilter(blue); |
194 canvas->drawRect(r, paint); | 193 canvas->drawRect(r, paint); |
195 } | 194 } |
196 } | 195 } |
197 | 196 |
198 private: | 197 private: |
199 typedef ColorFilterBaseBench INHERITED; | 198 typedef ColorFilterBaseBench INHERITED; |
200 }; | 199 }; |
201 | 200 |
202 class ColorFilterBrightBench : public ColorFilterBaseBench { | 201 class ColorFilterBrightBench : public ColorFilterBaseBench { |
203 | 202 |
204 public: | 203 public: |
205 ColorFilterBrightBench(void* param, bool small) : INHERITED(param, small) { | 204 ColorFilterBrightBench(bool small) : INHERITED(small) { |
206 } | 205 } |
207 | 206 |
208 protected: | 207 protected: |
209 virtual const char* onGetName() SK_OVERRIDE { | 208 virtual const char* onGetName() SK_OVERRIDE { |
210 return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_larg
e"; | 209 return isSmall() ? "colorfilter_bright_small" : "colorfilter_bright_larg
e"; |
211 } | 210 } |
212 | 211 |
213 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 212 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
214 SkRect r = getFilterRect(); | 213 SkRect r = getFilterRect(); |
215 SkPaint paint; | 214 SkPaint paint; |
216 paint.setColor(SK_ColorRED); | 215 paint.setColor(SK_ColorRED); |
217 for (int i = 0; i < this->getLoops(); i++) { | 216 for (int i = 0; i < this->getLoops(); i++) { |
218 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); | 217 SkAutoTUnref<SkImageFilter> brightness(make_brightness(1.0f)); |
219 paint.setImageFilter(brightness); | 218 paint.setImageFilter(brightness); |
220 canvas->drawRect(r, paint); | 219 canvas->drawRect(r, paint); |
221 } | 220 } |
222 } | 221 } |
223 | 222 |
224 private: | 223 private: |
225 typedef ColorFilterBaseBench INHERITED; | 224 typedef ColorFilterBaseBench INHERITED; |
226 }; | 225 }; |
227 | 226 |
228 class ColorFilterBlueBench : public ColorFilterBaseBench { | 227 class ColorFilterBlueBench : public ColorFilterBaseBench { |
229 | 228 |
230 public: | 229 public: |
231 ColorFilterBlueBench(void* param, bool small) : INHERITED(param, small) { | 230 ColorFilterBlueBench(bool small) : INHERITED(small) { |
232 } | 231 } |
233 | 232 |
234 protected: | 233 protected: |
235 virtual const char* onGetName() SK_OVERRIDE { | 234 virtual const char* onGetName() SK_OVERRIDE { |
236 return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large"; | 235 return isSmall() ? "colorfilter_blue_small" : "colorfilter_blue_large"; |
237 } | 236 } |
238 | 237 |
239 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 238 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
240 SkRect r = getFilterRect(); | 239 SkRect r = getFilterRect(); |
241 SkPaint paint; | 240 SkPaint paint; |
242 paint.setColor(SK_ColorRED); | 241 paint.setColor(SK_ColorRED); |
243 for (int i = 0; i < this->getLoops(); i++) { | 242 for (int i = 0; i < this->getLoops(); i++) { |
244 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); | 243 SkAutoTUnref<SkImageFilter> blue(make_mode_blue()); |
245 paint.setImageFilter(blue); | 244 paint.setImageFilter(blue); |
246 canvas->drawRect(r, paint); | 245 canvas->drawRect(r, paint); |
247 } | 246 } |
248 } | 247 } |
249 | 248 |
250 private: | 249 private: |
251 typedef ColorFilterBaseBench INHERITED; | 250 typedef ColorFilterBaseBench INHERITED; |
252 }; | 251 }; |
253 | 252 |
254 class ColorFilterGrayBench : public ColorFilterBaseBench { | 253 class ColorFilterGrayBench : public ColorFilterBaseBench { |
255 | 254 |
256 public: | 255 public: |
257 ColorFilterGrayBench(void* param, bool small) : INHERITED(param, small) { | 256 ColorFilterGrayBench(bool small) : INHERITED(small) { |
258 } | 257 } |
259 | 258 |
260 protected: | 259 protected: |
261 virtual const char* onGetName() SK_OVERRIDE { | 260 virtual const char* onGetName() SK_OVERRIDE { |
262 return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large"; | 261 return isSmall() ? "colorfilter_gray_small" : "colorfilter_gray_large"; |
263 } | 262 } |
264 | 263 |
265 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 264 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
266 SkRect r = getFilterRect(); | 265 SkRect r = getFilterRect(); |
267 SkPaint paint; | 266 SkPaint paint; |
268 paint.setColor(SK_ColorRED); | 267 paint.setColor(SK_ColorRED); |
269 for (int i = 0; i < this->getLoops(); i++) { | 268 for (int i = 0; i < this->getLoops(); i++) { |
270 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); | 269 SkAutoTUnref<SkImageFilter> grayscale(make_grayscale()); |
271 paint.setImageFilter(grayscale); | 270 paint.setImageFilter(grayscale); |
272 canvas->drawRect(r, paint); | 271 canvas->drawRect(r, paint); |
273 } | 272 } |
274 } | 273 } |
275 | 274 |
276 private: | 275 private: |
277 typedef ColorFilterBaseBench INHERITED; | 276 typedef ColorFilterBaseBench INHERITED; |
278 }; | 277 }; |
279 | 278 |
280 class TableColorFilterBench : public ColorFilterBaseBench { | 279 class TableColorFilterBench : public ColorFilterBaseBench { |
281 | 280 |
282 public: | 281 public: |
283 TableColorFilterBench(void* param, bool small) : INHERITED(param, small) { | 282 TableColorFilterBench(bool small) : INHERITED(small) { |
284 } | 283 } |
285 | 284 |
286 protected: | 285 protected: |
287 virtual const char* onGetName() SK_OVERRIDE { | 286 virtual const char* onGetName() SK_OVERRIDE { |
288 return isSmall() ? "table_colorfilter_small" : "table_colorfilter_large"
; | 287 return isSmall() ? "table_colorfilter_small" : "table_colorfilter_large"
; |
289 } | 288 } |
290 | 289 |
291 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { | 290 virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { |
292 SkRect r = getFilterRect(); | 291 SkRect r = getFilterRect(); |
293 SkPaint paint; | 292 SkPaint paint; |
(...skipping 16 matching lines...) Expand all Loading... |
310 static SkColorFilter* make_table_filter() { | 309 static SkColorFilter* make_table_filter() { |
311 uint8_t table[256]; fill_table_data(table); | 310 uint8_t table[256]; fill_table_data(table); |
312 return SkTableColorFilter::Create(table); | 311 return SkTableColorFilter::Create(table); |
313 } | 312 } |
314 | 313 |
315 typedef ColorFilterBaseBench INHERITED; | 314 typedef ColorFilterBaseBench INHERITED; |
316 }; | 315 }; |
317 | 316 |
318 /////////////////////////////////////////////////////////////////////////////// | 317 /////////////////////////////////////////////////////////////////////////////// |
319 | 318 |
320 DEF_BENCH( return new ColorFilterDimBrightBench(p, true); ) | 319 DEF_BENCH( return new ColorFilterDimBrightBench(true); ) |
321 DEF_BENCH( return new ColorFilterBrightGrayBench(p, true); ) | 320 DEF_BENCH( return new ColorFilterBrightGrayBench(true); ) |
322 DEF_BENCH( return new ColorFilterGrayBrightBench(p, true); ) | 321 DEF_BENCH( return new ColorFilterGrayBrightBench(true); ) |
323 DEF_BENCH( return new ColorFilterBlueBrightBench(p, true); ) | 322 DEF_BENCH( return new ColorFilterBlueBrightBench(true); ) |
324 DEF_BENCH( return new ColorFilterBrightBlueBench(p, true); ) | 323 DEF_BENCH( return new ColorFilterBrightBlueBench(true); ) |
325 DEF_BENCH( return new ColorFilterBrightBench(p, true); ) | 324 DEF_BENCH( return new ColorFilterBrightBench(true); ) |
326 DEF_BENCH( return new ColorFilterBlueBench(p, true); ) | 325 DEF_BENCH( return new ColorFilterBlueBench(true); ) |
327 DEF_BENCH( return new ColorFilterGrayBench(p, true); ) | 326 DEF_BENCH( return new ColorFilterGrayBench(true); ) |
328 DEF_BENCH( return new TableColorFilterBench(p, true); ) | 327 DEF_BENCH( return new TableColorFilterBench(true); ) |
329 | 328 |
330 DEF_BENCH( return new ColorFilterDimBrightBench(p, false); ) | 329 DEF_BENCH( return new ColorFilterDimBrightBench(false); ) |
331 DEF_BENCH( return new ColorFilterBrightGrayBench(p, false); ) | 330 DEF_BENCH( return new ColorFilterBrightGrayBench(false); ) |
332 DEF_BENCH( return new ColorFilterGrayBrightBench(p, false); ) | 331 DEF_BENCH( return new ColorFilterGrayBrightBench(false); ) |
333 DEF_BENCH( return new ColorFilterBlueBrightBench(p, false); ) | 332 DEF_BENCH( return new ColorFilterBlueBrightBench(false); ) |
334 DEF_BENCH( return new ColorFilterBrightBlueBench(p, false); ) | 333 DEF_BENCH( return new ColorFilterBrightBlueBench(false); ) |
335 DEF_BENCH( return new ColorFilterBrightBench(p, false); ) | 334 DEF_BENCH( return new ColorFilterBrightBench(false); ) |
336 DEF_BENCH( return new ColorFilterBlueBench(p, false); ) | 335 DEF_BENCH( return new ColorFilterBlueBench(false); ) |
337 DEF_BENCH( return new ColorFilterGrayBench(p, false); ) | 336 DEF_BENCH( return new ColorFilterGrayBench(false); ) |
338 DEF_BENCH( return new TableColorFilterBench(p, false); ) | 337 DEF_BENCH( return new TableColorFilterBench(false); ) |
OLD | NEW |