1 /*
2 * Copyright 2011 The LibYuv Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "../unit_test/unit_test.h"
12
13 #include <stdlib.h> // For getenv()
14
15 #include <cstring>
16
17 #include "gflags/gflags.h"
18
19 // Change this to 1000 for benchmarking.
20 // TODO(fbarchard): Add command line parsing to pass this as option.
21 #define BENCHMARK_ITERATIONS 1
22
23 unsigned int fastrand_seed = 0xfb;
24
25 DEFINE_int32(libyuv_width, 0, "width of test image.");
26 DEFINE_int32(libyuv_height, 0, "height of test image.");
27 DEFINE_int32(libyuv_repeat, 0, "number of times to repeat test.");
28 DEFINE_int32(libyuv_flags, 0, "cpu flags for reference code. 1 = C, -1 = SIMD");
29 DEFINE_int32(libyuv_cpu_info,
30 0,
31 "cpu flags for benchmark code. 1 = C, -1 = SIMD");
32
33 // For quicker unittests, default is 128 x 72. But when benchmarking,
34 // default to 720p. Allow size to specify.
35 // Set flags to -1 for benchmarking to avoid slower C code.
36
LibYUVConvertTest()37 LibYUVConvertTest::LibYUVConvertTest()
38 : benchmark_iterations_(BENCHMARK_ITERATIONS),
39 benchmark_width_(128),
40 benchmark_height_(72),
41 disable_cpu_flags_(1),
42 benchmark_cpu_info_(-1) {
43 const char* repeat = getenv("LIBYUV_REPEAT");
44 if (repeat) {
45 benchmark_iterations_ = atoi(repeat); // NOLINT
46 }
47 if (FLAGS_libyuv_repeat) {
48 benchmark_iterations_ = FLAGS_libyuv_repeat;
49 }
50 if (benchmark_iterations_ > 1) {
51 benchmark_width_ = 1280;
52 benchmark_height_ = 720;
53 }
54 const char* width = getenv("LIBYUV_WIDTH");
55 if (width) {
56 benchmark_width_ = atoi(width); // NOLINT
57 }
58 if (FLAGS_libyuv_width) {
59 benchmark_width_ = FLAGS_libyuv_width;
60 }
61 const char* height = getenv("LIBYUV_HEIGHT");
62 if (height) {
63 benchmark_height_ = atoi(height); // NOLINT
64 }
65 if (FLAGS_libyuv_height) {
66 benchmark_height_ = FLAGS_libyuv_height;
67 }
68 const char* cpu_flags = getenv("LIBYUV_FLAGS");
69 if (cpu_flags) {
70 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
71 }
72 if (FLAGS_libyuv_flags) {
73 disable_cpu_flags_ = FLAGS_libyuv_flags;
74 }
75 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
76 if (cpu_info) {
77 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
78 }
79 if (FLAGS_libyuv_cpu_info) {
80 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
81 }
82 benchmark_pixels_div256_ =
83 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
84 static_cast<double>(Abs(benchmark_height_)) *
85 static_cast<double>(benchmark_iterations_) +
86 255.0) /
87 256.0);
88 benchmark_pixels_div1280_ =
89 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
90 static_cast<double>(Abs(benchmark_height_)) *
91 static_cast<double>(benchmark_iterations_) +
92 1279.0) /
93 1280.0);
94 }
95
LibYUVColorTest()96 LibYUVColorTest::LibYUVColorTest()
97 : benchmark_iterations_(BENCHMARK_ITERATIONS),
98 benchmark_width_(128),
99 benchmark_height_(72),
100 disable_cpu_flags_(1),
101 benchmark_cpu_info_(-1) {
102 const char* repeat = getenv("LIBYUV_REPEAT");
103 if (repeat) {
104 benchmark_iterations_ = atoi(repeat); // NOLINT
105 }
106 if (FLAGS_libyuv_repeat) {
107 benchmark_iterations_ = FLAGS_libyuv_repeat;
108 }
109 if (benchmark_iterations_ > 1) {
110 benchmark_width_ = 1280;
111 benchmark_height_ = 720;
112 }
113 const char* width = getenv("LIBYUV_WIDTH");
114 if (width) {
115 benchmark_width_ = atoi(width); // NOLINT
116 }
117 if (FLAGS_libyuv_width) {
118 benchmark_width_ = FLAGS_libyuv_width;
119 }
120 const char* height = getenv("LIBYUV_HEIGHT");
121 if (height) {
122 benchmark_height_ = atoi(height); // NOLINT
123 }
124 if (FLAGS_libyuv_height) {
125 benchmark_height_ = FLAGS_libyuv_height;
126 }
127 const char* cpu_flags = getenv("LIBYUV_FLAGS");
128 if (cpu_flags) {
129 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
130 }
131 if (FLAGS_libyuv_flags) {
132 disable_cpu_flags_ = FLAGS_libyuv_flags;
133 }
134 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
135 if (cpu_info) {
136 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
137 }
138 if (FLAGS_libyuv_cpu_info) {
139 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
140 }
141 benchmark_pixels_div256_ =
142 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
143 static_cast<double>(Abs(benchmark_height_)) *
144 static_cast<double>(benchmark_iterations_) +
145 255.0) /
146 256.0);
147 benchmark_pixels_div1280_ =
148 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
149 static_cast<double>(Abs(benchmark_height_)) *
150 static_cast<double>(benchmark_iterations_) +
151 1279.0) /
152 1280.0);
153 }
154
LibYUVScaleTest()155 LibYUVScaleTest::LibYUVScaleTest()
156 : benchmark_iterations_(BENCHMARK_ITERATIONS),
157 benchmark_width_(128),
158 benchmark_height_(72),
159 disable_cpu_flags_(1),
160 benchmark_cpu_info_(-1) {
161 const char* repeat = getenv("LIBYUV_REPEAT");
162 if (repeat) {
163 benchmark_iterations_ = atoi(repeat); // NOLINT
164 }
165 if (FLAGS_libyuv_repeat) {
166 benchmark_iterations_ = FLAGS_libyuv_repeat;
167 }
168 if (benchmark_iterations_ > 1) {
169 benchmark_width_ = 1280;
170 benchmark_height_ = 720;
171 }
172 const char* width = getenv("LIBYUV_WIDTH");
173 if (width) {
174 benchmark_width_ = atoi(width); // NOLINT
175 }
176 if (FLAGS_libyuv_width) {
177 benchmark_width_ = FLAGS_libyuv_width;
178 }
179 const char* height = getenv("LIBYUV_HEIGHT");
180 if (height) {
181 benchmark_height_ = atoi(height); // NOLINT
182 }
183 if (FLAGS_libyuv_height) {
184 benchmark_height_ = FLAGS_libyuv_height;
185 }
186 const char* cpu_flags = getenv("LIBYUV_FLAGS");
187 if (cpu_flags) {
188 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
189 }
190 if (FLAGS_libyuv_flags) {
191 disable_cpu_flags_ = FLAGS_libyuv_flags;
192 }
193 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
194 if (cpu_info) {
195 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
196 }
197 if (FLAGS_libyuv_cpu_info) {
198 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
199 }
200 benchmark_pixels_div256_ =
201 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
202 static_cast<double>(Abs(benchmark_height_)) *
203 static_cast<double>(benchmark_iterations_) +
204 255.0) /
205 256.0);
206 benchmark_pixels_div1280_ =
207 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
208 static_cast<double>(Abs(benchmark_height_)) *
209 static_cast<double>(benchmark_iterations_) +
210 1279.0) /
211 1280.0);
212 }
213
LibYUVRotateTest()214 LibYUVRotateTest::LibYUVRotateTest()
215 : benchmark_iterations_(BENCHMARK_ITERATIONS),
216 benchmark_width_(128),
217 benchmark_height_(72),
218 disable_cpu_flags_(1),
219 benchmark_cpu_info_(-1) {
220 const char* repeat = getenv("LIBYUV_REPEAT");
221 if (repeat) {
222 benchmark_iterations_ = atoi(repeat); // NOLINT
223 }
224 if (FLAGS_libyuv_repeat) {
225 benchmark_iterations_ = FLAGS_libyuv_repeat;
226 }
227 if (benchmark_iterations_ > 1) {
228 benchmark_width_ = 1280;
229 benchmark_height_ = 720;
230 }
231 const char* width = getenv("LIBYUV_WIDTH");
232 if (width) {
233 benchmark_width_ = atoi(width); // NOLINT
234 }
235 if (FLAGS_libyuv_width) {
236 benchmark_width_ = FLAGS_libyuv_width;
237 }
238 const char* height = getenv("LIBYUV_HEIGHT");
239 if (height) {
240 benchmark_height_ = atoi(height); // NOLINT
241 }
242 if (FLAGS_libyuv_height) {
243 benchmark_height_ = FLAGS_libyuv_height;
244 }
245 const char* cpu_flags = getenv("LIBYUV_FLAGS");
246 if (cpu_flags) {
247 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
248 }
249 if (FLAGS_libyuv_flags) {
250 disable_cpu_flags_ = FLAGS_libyuv_flags;
251 }
252 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
253 if (cpu_info) {
254 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
255 }
256 if (FLAGS_libyuv_cpu_info) {
257 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
258 }
259 benchmark_pixels_div256_ =
260 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
261 static_cast<double>(Abs(benchmark_height_)) *
262 static_cast<double>(benchmark_iterations_) +
263 255.0) /
264 256.0);
265 benchmark_pixels_div1280_ =
266 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
267 static_cast<double>(Abs(benchmark_height_)) *
268 static_cast<double>(benchmark_iterations_) +
269 1279.0) /
270 1280.0);
271 }
272
LibYUVPlanarTest()273 LibYUVPlanarTest::LibYUVPlanarTest()
274 : benchmark_iterations_(BENCHMARK_ITERATIONS),
275 benchmark_width_(128),
276 benchmark_height_(72),
277 disable_cpu_flags_(1),
278 benchmark_cpu_info_(-1) {
279 const char* repeat = getenv("LIBYUV_REPEAT");
280 if (repeat) {
281 benchmark_iterations_ = atoi(repeat); // NOLINT
282 }
283 if (FLAGS_libyuv_repeat) {
284 benchmark_iterations_ = FLAGS_libyuv_repeat;
285 }
286 if (benchmark_iterations_ > 1) {
287 benchmark_width_ = 1280;
288 benchmark_height_ = 720;
289 }
290 const char* width = getenv("LIBYUV_WIDTH");
291 if (width) {
292 benchmark_width_ = atoi(width); // NOLINT
293 }
294 if (FLAGS_libyuv_width) {
295 benchmark_width_ = FLAGS_libyuv_width;
296 }
297 const char* height = getenv("LIBYUV_HEIGHT");
298 if (height) {
299 benchmark_height_ = atoi(height); // NOLINT
300 }
301 if (FLAGS_libyuv_height) {
302 benchmark_height_ = FLAGS_libyuv_height;
303 }
304 const char* cpu_flags = getenv("LIBYUV_FLAGS");
305 if (cpu_flags) {
306 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
307 }
308 if (FLAGS_libyuv_flags) {
309 disable_cpu_flags_ = FLAGS_libyuv_flags;
310 }
311 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
312 if (cpu_info) {
313 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
314 }
315 if (FLAGS_libyuv_cpu_info) {
316 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
317 }
318 benchmark_pixels_div256_ =
319 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
320 static_cast<double>(Abs(benchmark_height_)) *
321 static_cast<double>(benchmark_iterations_) +
322 255.0) /
323 256.0);
324 benchmark_pixels_div1280_ =
325 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
326 static_cast<double>(Abs(benchmark_height_)) *
327 static_cast<double>(benchmark_iterations_) +
328 1279.0) /
329 1280.0);
330 }
331
LibYUVBaseTest()332 LibYUVBaseTest::LibYUVBaseTest()
333 : benchmark_iterations_(BENCHMARK_ITERATIONS),
334 benchmark_width_(128),
335 benchmark_height_(72),
336 disable_cpu_flags_(1),
337 benchmark_cpu_info_(-1) {
338 const char* repeat = getenv("LIBYUV_REPEAT");
339 if (repeat) {
340 benchmark_iterations_ = atoi(repeat); // NOLINT
341 }
342 if (FLAGS_libyuv_repeat) {
343 benchmark_iterations_ = FLAGS_libyuv_repeat;
344 }
345 if (benchmark_iterations_ > 1) {
346 benchmark_width_ = 1280;
347 benchmark_height_ = 720;
348 }
349 const char* width = getenv("LIBYUV_WIDTH");
350 if (width) {
351 benchmark_width_ = atoi(width); // NOLINT
352 }
353 if (FLAGS_libyuv_width) {
354 benchmark_width_ = FLAGS_libyuv_width;
355 }
356 const char* height = getenv("LIBYUV_HEIGHT");
357 if (height) {
358 benchmark_height_ = atoi(height); // NOLINT
359 }
360 if (FLAGS_libyuv_height) {
361 benchmark_height_ = FLAGS_libyuv_height;
362 }
363 const char* cpu_flags = getenv("LIBYUV_FLAGS");
364 if (cpu_flags) {
365 disable_cpu_flags_ = atoi(cpu_flags); // NOLINT
366 }
367 if (FLAGS_libyuv_flags) {
368 disable_cpu_flags_ = FLAGS_libyuv_flags;
369 }
370 const char* cpu_info = getenv("LIBYUV_CPU_INFO");
371 if (cpu_info) {
372 benchmark_cpu_info_ = atoi(cpu_flags); // NOLINT
373 }
374 if (FLAGS_libyuv_cpu_info) {
375 benchmark_cpu_info_ = FLAGS_libyuv_cpu_info;
376 }
377 benchmark_pixels_div256_ =
378 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
379 static_cast<double>(Abs(benchmark_height_)) *
380 static_cast<double>(benchmark_iterations_) +
381 255.0) /
382 256.0);
383 benchmark_pixels_div1280_ =
384 static_cast<int>((static_cast<double>(Abs(benchmark_width_)) *
385 static_cast<double>(Abs(benchmark_height_)) *
386 static_cast<double>(benchmark_iterations_) +
387 1279.0) /
388 1280.0);
389 }
390
main(int argc,char ** argv)391 int main(int argc, char** argv) {
392 ::testing::InitGoogleTest(&argc, argv);
393 // AllowCommandLineParsing allows us to ignore flags passed on to us by
394 // Chromium build bots without having to explicitly disable them.
395 google::AllowCommandLineReparsing();
396 google::ParseCommandLineFlags(&argc, &argv, true);
397 return RUN_ALL_TESTS();
398 }
399