tests/checkasm/checkasm.h

   1 /*
   2  * Assembly testing and benchmarking tool
   3  * Copyright (c) 2015 Henrik Gramner
   4  * Copyright (c) 2008 Loren Merritt
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  */
  22
  23 #ifndef TESTS_CHECKASM_CHECKASM_H
  24 #define TESTS_CHECKASM_CHECKASM_H
  25
  26 #include <stdint.h>
  27 #include "config.h"
  28
  29 #if CONFIG_LINUX_PERF
  30 #include <unistd.h> // read(3)
  31 #include <sys/ioctl.h>
  32 #include <asm/unistd.h>
  33 #include <linux/perf_event.h>
  34 #elif CONFIG_MACOS_KPERF
  35 #include "libavutil/macos_kperf.h"
  36 #endif
  37
  38 #include "libavutil/avstring.h"
  39 #include "libavutil/cpu.h"
  40 #include "libavutil/emms.h"
  41 #include "libavutil/internal.h"
  42 #include "libavutil/lfg.h"
  43 #include "libavutil/timer.h"
  44
  45 #ifdef _WIN32
  46 #include <windows.h>
  47 #if ARCH_X86_32
  48 #include <setjmp.h>
  49 typedef jmp_buf checkasm_context;
  50 #define checkasm_save_context() checkasm_handle_signal(setjmp(checkasm_context_buf))
  51 #define checkasm_load_context(s) longjmp(checkasm_context_buf, s)
  52 #elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
  53 /* setjmp/longjmp on Windows on architectures using SEH (all except x86_32)
  54  * will try to use SEH to unwind the stack, which doesn't work for assembly
  55  * functions without unwind information. */
  56 typedef struct { CONTEXT c; int status; } checkasm_context;
  57 #define checkasm_save_context() \
  58     (checkasm_context_buf.status = 0, \
  59      RtlCaptureContext(&checkasm_context_buf.c), \
  60      checkasm_handle_signal(checkasm_context_buf.status))
  61 #define checkasm_load_context(s) \
  62     (checkasm_context_buf.status = s, \
  63      RtlRestoreContext(&checkasm_context_buf.c, NULL))
  64 #else
  65 #define checkasm_context void*
  66 #define checkasm_save_context() 0
  67 #define checkasm_load_context() do {} while (0)
  68 #endif
  69 #elif defined(_WASI_EMULATED_SIGNAL)
  70 #define checkasm_context void*
  71 #define checkasm_save_context() 0
  72 #define checkasm_load_context() do {} while (0)
  73 #else
  74 #include <setjmp.h>
  75 typedef sigjmp_buf checkasm_context;
  76 #define checkasm_save_context() checkasm_handle_signal(sigsetjmp(checkasm_context_buf, 1))
  77 #define checkasm_load_context(s) siglongjmp(checkasm_context_buf, s)
  78 #endif
  79
  80 void checkasm_check_aacencdsp(void);
  81 void checkasm_check_aacpsdsp(void);
  82 void checkasm_check_ac3dsp(void);
  83 void checkasm_check_aes(void);
  84 void checkasm_check_afir(void);
  85 void checkasm_check_alacdsp(void);
  86 void checkasm_check_apv_dsp(void);
  87 void checkasm_check_audiodsp(void);
  88 void checkasm_check_av_tx(void);
  89 void checkasm_check_blackdetect(void);
  90 void checkasm_check_blend(void);
  91 void checkasm_check_blockdsp(void);
  92 void checkasm_check_bswapdsp(void);
  93 void checkasm_check_cavsdsp(void);
  94 void checkasm_check_colordetect(void);
  95 void checkasm_check_colorspace(void);
  96 void checkasm_check_dcadsp(void);
  97 void checkasm_check_diracdsp(void);
  98 void checkasm_check_exrdsp(void);
  99 void checkasm_check_fdctdsp(void);
 100 void checkasm_check_fixed_dsp(void);
 101 void checkasm_check_flacdsp(void);
 102 void checkasm_check_float_dsp(void);
 103 void checkasm_check_fmtconvert(void);
 104 void checkasm_check_g722dsp(void);
 105 void checkasm_check_h263dsp(void);
 106 void checkasm_check_h264chroma(void);
 107 void checkasm_check_h264dsp(void);
 108 void checkasm_check_h264pred(void);
 109 void checkasm_check_h264qpel(void);
 110 void checkasm_check_hevc_add_res(void);
 111 void checkasm_check_hevc_deblock(void);
 112 void checkasm_check_hevc_idct(void);
 113 void checkasm_check_hevc_pel(void);
 114 void checkasm_check_hevc_sao(void);
 115 void checkasm_check_hpeldsp(void);
 116 void checkasm_check_huffyuvdsp(void);
 117 void checkasm_check_idctdsp(void);
 118 void checkasm_check_idet(void);
 119 void checkasm_check_jpeg2000dsp(void);
 120 void checkasm_check_llauddsp(void);
 121 void checkasm_check_lls(void);
 122 void checkasm_check_llviddsp(void);
 123 void checkasm_check_llviddspenc(void);
 124 void checkasm_check_lpc(void);
 125 void checkasm_check_motion(void);
 126 void checkasm_check_mpegvideoencdsp(void);
 127 void checkasm_check_nlmeans(void);
 128 void checkasm_check_opusdsp(void);
 129 void checkasm_check_pixblockdsp(void);
 130 void checkasm_check_qpeldsp(void);
 131 void checkasm_check_sbrdsp(void);
 132 void checkasm_check_rv34dsp(void);
 133 void checkasm_check_rv40dsp(void);
 134 void checkasm_check_scene_sad(void);
 135 void checkasm_check_svq1enc(void);
 136 void checkasm_check_synth_filter(void);
 137 void checkasm_check_sw_gbrp(void);
 138 void checkasm_check_sw_range_convert(void);
 139 void checkasm_check_sw_rgb(void);
 140 void checkasm_check_sw_scale(void);
 141 void checkasm_check_sw_yuv2rgb(void);
 142 void checkasm_check_sw_yuv2yuv(void);
 143 void checkasm_check_sw_ops(void);
 144 void checkasm_check_takdsp(void);
 145 void checkasm_check_utvideodsp(void);
 146 void checkasm_check_v210dec(void);
 147 void checkasm_check_v210enc(void);
 148 void checkasm_check_vc1dsp(void);
 149 void checkasm_check_vf_bwdif(void);
 150 void checkasm_check_vf_eq(void);
 151 void checkasm_check_vf_fspp(void);
 152 void checkasm_check_vf_gblur(void);
 153 void checkasm_check_vf_hflip(void);
 154 void checkasm_check_vf_threshold(void);
 155 void checkasm_check_vf_sobel(void);
 156 void checkasm_check_vp3dsp(void);
 157 void checkasm_check_vp6dsp(void);
 158 void checkasm_check_vp8dsp(void);
 159 void checkasm_check_vp9dsp(void);
 160 void checkasm_check_videodsp(void);
 161 void checkasm_check_vorbisdsp(void);
 162 void checkasm_check_vvc_alf(void);
 163 void checkasm_check_vvc_mc(void);
 164 void checkasm_check_vvc_sao(void);
 165
 166 struct CheckasmPerf;
 167
 168 void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
 169 int checkasm_bench_func(void);
 170 int checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
 171 struct CheckasmPerf *checkasm_get_perf_context(void);
 172 void checkasm_report(const char *name, ...) av_printf_format(1, 2);
 173 void checkasm_set_signal_handler_state(int enabled);
 174 int checkasm_handle_signal(int s);
 175 extern checkasm_context checkasm_context_buf;
 176
 177 /* float compare utilities */
 178 int float_near_ulp(float a, float b, unsigned max_ulp);
 179 int float_near_abs_eps(float a, float b, float eps);
 180 int float_near_abs_eps_ulp(float a, float b, float eps, unsigned max_ulp);
 181 int float_near_ulp_array(const float *a, const float *b, unsigned max_ulp,
 182                          unsigned len);
 183 int float_near_abs_eps_array(const float *a, const float *b, float eps,
 184                              unsigned len);
 185 int float_near_abs_eps_array_ulp(const float *a, const float *b, float eps,
 186                                  unsigned max_ulp, unsigned len);
 187 int double_near_abs_eps(double a, double b, double eps);
 188 int double_near_abs_eps_array(const double *a, const double *b, double eps,
 189                               unsigned len);
 190
 191 extern AVLFG checkasm_lfg;
 192 #define rnd() av_lfg_get(&checkasm_lfg)
 193
 194 av_unused static void *func_ref, *func_new;
 195
 196 extern uint64_t bench_runs;
 197
 198 /* Decide whether or not the specified function needs to be tested */
 199 #define check_func(func, ...) (checkasm_save_context(), func_ref = checkasm_check_func((func_new = func), __VA_ARGS__))
 200
 201 /* Declare the function prototype. The first argument is the return value, the remaining
 202  * arguments are the function parameters. Naming parameters is optional. */
 203 #define declare_func(ret, ...) declare_new(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
 204 #define declare_func_float(ret, ...) declare_new_float(ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
 205 #define declare_func_emms(cpu_flags, ret, ...) declare_new_emms(cpu_flags, ret, __VA_ARGS__) typedef ret func_type(__VA_ARGS__)
 206
 207 /* Indicate that the current test has failed */
 208 #define fail() checkasm_fail_func("%s:%d", av_basename(__FILE__), __LINE__)
 209
 210 /* Print the test outcome */
 211 #define report checkasm_report
 212
 213 /* Call the reference function */
 214 #define call_ref(...)\
 215     (checkasm_set_signal_handler_state(1),\
 216      ((func_type *)func_ref)(__VA_ARGS__));\
 217     checkasm_set_signal_handler_state(0)
 218
 219 #if ARCH_X86 && HAVE_X86ASM
 220 /* Verifies that clobbered callee-saved registers are properly saved and restored
 221  * and that either no MMX registers are touched or emms is issued */
 222 void checkasm_checked_call(void *func, ...);
 223 /* Verifies that clobbered callee-saved registers are properly saved and restored
 224  * and issues emms for asm functions which are not required to do so */
 225 void checkasm_checked_call_emms(void *func, ...);
 226 /* Verifies that clobbered callee-saved registers are properly saved and restored
 227  * but doesn't issue emms. Meant for dsp functions returning float or double */
 228 void checkasm_checked_call_float(void *func, ...);
 229
 230 #if ARCH_X86_64
 231 /* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
 232  * This is done by clobbering the stack with junk around the stack pointer and calling the
 233  * assembly function through checked_call() with added dummy arguments which forces all
 234  * real arguments to be passed on the stack and not in registers. For 32-bit arguments the
 235  * upper half of the 64-bit register locations on the stack will now contain junk which will
 236  * cause misbehaving functions to either produce incorrect output or segfault. Note that
 237  * even though this works extremely well in practice, it's technically not guaranteed
 238  * and false negatives is theoretically possible, but there can never be any false positives.
 239  */
 240 void checkasm_stack_clobber(uint64_t clobber, ...);
 241 #define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
 242                               = (void *)checkasm_checked_call;
 243 #define declare_new_float(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__)\
 244                                     = (void *)checkasm_checked_call_float;
 245 #define declare_new_emms(cpu_flags, ret, ...) \
 246     ret (*checked_call)(void *, int, int, int, int, int, __VA_ARGS__) = \
 247         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms : \
 248                                              (void *)checkasm_checked_call;
 249 #define CLOB (UINT64_C(0xdeadbeefdeadbeef))
 250 #define call_new(...) (checkasm_set_signal_handler_state(1),\
 251                        checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
 252                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
 253                        checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__));\
 254                       checkasm_set_signal_handler_state(0)
 255 #elif ARCH_X86_32
 256 #define declare_new(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call;
 257 #define declare_new_float(ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = (void *)checkasm_checked_call_float;
 258 #define declare_new_emms(cpu_flags, ret, ...) ret (*checked_call)(void *, __VA_ARGS__) = \
 259         ((cpu_flags) & av_get_cpu_flags()) ? (void *)checkasm_checked_call_emms :        \
 260                                              (void *)checkasm_checked_call;
 261 #define call_new(...)\
 262     (checkasm_set_signal_handler_state(1),\
 263      checked_call(func_new, __VA_ARGS__));\
 264     checkasm_set_signal_handler_state(0)
 265 #endif
 266 #elif ARCH_ARM && HAVE_ARMV5TE_EXTERNAL
 267 /* Use a dummy argument, to offset the real parameters by 2, not only 1.
 268  * This makes sure that potential 8-byte-alignment of parameters is kept the same
 269  * even when the extra parameters have been removed. */
 270 void checkasm_checked_call_vfp(void *func, int dummy, ...);
 271 void checkasm_checked_call_novfp(void *func, int dummy, ...);
 272 extern void (*checkasm_checked_call)(void *func, int dummy, ...);
 273 #define declare_new(ret, ...) ret (*checked_call)(void *, int dummy, __VA_ARGS__, \
 274                                                   int, int, int, int, int, int, int, int, \
 275                                                   int, int, int, int, int, int, int) = (void *)checkasm_checked_call;
 276 #define call_new(...) \
 277     (checkasm_set_signal_handler_state(1),\
 278      checked_call(func_new, 0, __VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0));\
 279     checkasm_set_signal_handler_state(0)
 280 #elif ARCH_AARCH64 && !defined(__APPLE__)
 281 void checkasm_stack_clobber(uint64_t clobber, ...);
 282 void checkasm_checked_call(void *func, ...);
 283 #define declare_new(ret, ...) ret (*checked_call)(void *, int, int, int, int, int, int, int, __VA_ARGS__,\
 284                                                   int, int, int, int, int, int, int, int,\
 285                                                   int, int, int, int, int, int, int)\
 286                               = (void *)checkasm_checked_call;
 287 #define CLOB (UINT64_C(0xdeadbeefdeadbeef))
 288 #define call_new(...) (checkasm_set_signal_handler_state(1),\
 289                        checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
 290                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
 291                       checked_call(func_new, 0, 0, 0, 0, 0, 0, 0, __VA_ARGS__,\
 292                                    7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0));\
 293                      checkasm_set_signal_handler_state(0)
 294 #elif ARCH_RISCV
 295 void checkasm_set_function(void *);
 296 void *checkasm_get_wrapper(void);
 297
 298 #if HAVE_RV && (__riscv_xlen == 64) && defined (__riscv_d)
 299 #define declare_new(ret, ...) \
 300     ret (*checked_call)(__VA_ARGS__) = checkasm_get_wrapper();
 301 #define call_new(...) \
 302     (checkasm_set_signal_handler_state(1),\
 303      checkasm_set_function(func_new), checked_call(__VA_ARGS__));\
 304     checkasm_set_signal_handler_state(0)
 305 #else
 306 #define declare_new(ret, ...)
 307 #define call_new(...)\
 308     (checkasm_set_signal_handler_state(1),\
 309      ((func_type *)func_new)(__VA_ARGS__));\
 310     checkasm_set_signal_handler_state(0)
 311 #endif
 312 #else
 313 #define declare_new(ret, ...)
 314 #define declare_new_float(ret, ...)
 315 #define declare_new_emms(cpu_flags, ret, ...)
 316 /* Call the function */
 317 #define call_new(...)\
 318     (checkasm_set_signal_handler_state(1),\
 319      ((func_type *)func_new)(__VA_ARGS__));\
 320     checkasm_set_signal_handler_state(0)
 321 #endif
 322
 323 #ifndef declare_new_emms
 324 #define declare_new_emms(cpu_flags, ret, ...) declare_new(ret, __VA_ARGS__)
 325 #endif
 326 #ifndef declare_new_float
 327 #define declare_new_float(ret, ...) declare_new(ret, __VA_ARGS__)
 328 #endif
 329
 330 typedef struct CheckasmPerf {
 331     int sysfd;
 332     uint64_t cycles;
 333     int iterations;
 334 } CheckasmPerf;
 335
 336 #if defined(AV_READ_TIME) || CONFIG_LINUX_PERF || CONFIG_MACOS_KPERF
 337
 338 #if CONFIG_LINUX_PERF
 339 #define PERF_START(t) do {                              \
 340     ioctl(sysfd, PERF_EVENT_IOC_RESET, 0);              \
 341     ioctl(sysfd, PERF_EVENT_IOC_ENABLE, 0);             \
 342 } while (0)
 343 #define PERF_STOP(t) do {                               \
 344     int ret;                                            \
 345     ioctl(sysfd, PERF_EVENT_IOC_DISABLE, 0);            \
 346     ret = read(sysfd, &t, sizeof(t));                   \
 347     (void)ret;                                          \
 348 } while (0)
 349 #elif CONFIG_MACOS_KPERF
 350 #define PERF_START(t) t = ff_kperf_cycles()
 351 #define PERF_STOP(t)  t = ff_kperf_cycles() - t
 352 #else
 353 #define PERF_START(t) t = AV_READ_TIME()
 354 #define PERF_STOP(t)  t = AV_READ_TIME() - t
 355 #endif
 356
 357 #define CALL4(...)\
 358     do {\
 359         tfunc(__VA_ARGS__); \
 360         tfunc(__VA_ARGS__); \
 361         tfunc(__VA_ARGS__); \
 362         tfunc(__VA_ARGS__); \
 363     } while (0)
 364
 365 #define CALL16(...)\
 366     do {\
 367         CALL4(__VA_ARGS__); \
 368         CALL4(__VA_ARGS__); \
 369         CALL4(__VA_ARGS__); \
 370         CALL4(__VA_ARGS__); \
 371     } while (0)
 372
 373 /* Benchmark the function */
 374 #define bench_new(...)\
 375     do {\
 376         if (checkasm_bench_func()) {\
 377             struct CheckasmPerf *perf = checkasm_get_perf_context();\
 378             av_unused const int sysfd = perf->sysfd;\
 379             func_type *tfunc = func_new;\
 380             uint64_t tsum = 0;\
 381             uint64_t ti, tcount = 0;\
 382             uint64_t t = 0; \
 383             const uint64_t truns = FFMAX(bench_runs >> 3, 1);\
 384             checkasm_set_signal_handler_state(1);\
 385             for (ti = 0; ti < truns; ti++) {\
 386                 PERF_START(t);\
 387                 CALL16(__VA_ARGS__);\
 388                 CALL16(__VA_ARGS__);\
 389                 PERF_STOP(t);\
 390                 if (t*tcount <= tsum*4 && ti > 0) {\
 391                     tsum += t;\
 392                     tcount++;\
 393                 }\
 394             }\
 395             emms_c();\
 396             perf->cycles += tsum;\
 397             perf->iterations += tcount;\
 398             checkasm_set_signal_handler_state(0);\
 399         }\
 400     } while (0)
 401 #else
 402 #define bench_new(...) while(0)
 403 #define PERF_START(t)  while(0)
 404 #define PERF_STOP(t)   while(0)
 405 #endif
 406
 407 #define BUF_RECT(type, name, w, h) \
 408     LOCAL_ALIGNED_32(type, name##_buf, [((h)+32)*(FFALIGN(w,64)+64) + 64]); \
 409     av_unused ptrdiff_t name##_stride = sizeof(type)*(FFALIGN(w,64)+64); \
 410     av_unused int name##_buf_h = (h)+32; \
 411     type *name = name##_buf + (FFALIGN(w,64)+64)*16 + 64
 412
 413 #define PIXEL_RECT(name, w, h) \
 414     LOCAL_ALIGNED_32(uint8_t, name##_buf, [sizeof(uint16_t) * (((h)+32)*(FFALIGN(w,64)+64) + 64)],); \
 415     av_unused ptrdiff_t name##_stride = sizeof(uint16_t) * (FFALIGN(w,64)+64); \
 416     av_unused int name##_buf_h = (h)+32; \
 417     uint8_t *name = name##_buf + (FFALIGN(w,64)+64)*16 + 64
 418
 419 #define CLEAR_BUF_RECT(name) \
 420     memset(name##_buf, 0x99, name##_stride * name##_buf_h + 64)
 421 #define CLEAR_PIXEL_RECT(name) \
 422     CLEAR_BUF_RECT(name)
 423
 424 #define DECL_CHECKASM_CHECK_FUNC(type) \
 425 int checkasm_check_##type(const char *file, int line, \
 426                           const type *buf1, ptrdiff_t stride1, \
 427                           const type *buf2, ptrdiff_t stride2, \
 428                           int w, int h, const char *name, \
 429                           int align_w, int align_h, \
 430                           int padding)
 431
 432 DECL_CHECKASM_CHECK_FUNC(uint8_t);
 433 DECL_CHECKASM_CHECK_FUNC(uint16_t);
 434 DECL_CHECKASM_CHECK_FUNC(uint32_t);
 435 DECL_CHECKASM_CHECK_FUNC(int16_t);
 436 DECL_CHECKASM_CHECK_FUNC(int32_t);
 437
 438 int checkasm_check_float_ulp(const char *file, int line,
 439                              const float *buf1, ptrdiff_t stride1,
 440                              const float *buf2, ptrdiff_t stride2,
 441                              int w, int h, const char *name,
 442                              unsigned max_ulp, int align_w, int align_h,
 443                              int padding);
 444
 445 #define PASTE(a,b) a ## b
 446 #define CONCAT(a,b) PASTE(a,b)
 447
 448 #define checkasm_check2(prefix, ...) CONCAT(checkasm_check_, prefix)(__FILE__, __LINE__, __VA_ARGS__)
 449 #define checkasm_check(prefix, ...) checkasm_check2(prefix, __VA_ARGS__, 0, 0, 0)
 450 /* Check a pointer from BUF_RECT, checking whether there have been
 451  * writes outside of the designated area. */
 452 #define checkasm_check_padded(...) \
 453     checkasm_check2(__VA_ARGS__, 1, 1, 8)
 454 /* Check a pointer from BUF_RECT, checking whether there have been
 455  * writes outside of the designated area. Allow writing slightly past the
 456  * end of the buffer, by aligning w/h to align_w/align_h, and checking
 457  * for overwrites outside of that. */
 458 #define checkasm_check_padded_align(...) \
 459     checkasm_check2(__VA_ARGS__, 8)
 460
 461 /* This assumes that there is a local variable named "bit_depth".
 462  * For tests that don't have that and only operate on a single
 463  * bitdepth, just call checkasm_check(uint8_t, ...) directly. */
 464 #define checkasm_check_pixel2(buf1, stride1, buf2, stride2, ...) \
 465     ((bit_depth > 8) ?                                          \
 466      checkasm_check2(uint16_t, (const uint16_t*)buf1, stride1,   \
 467                                (const uint16_t*)buf2, stride2,   \
 468                                __VA_ARGS__) :                    \
 469      checkasm_check2(uint8_t,  (const uint8_t*) buf1, stride1,   \
 470                                (const uint8_t*) buf2, stride2,   \
 471                                __VA_ARGS__))
 472 #define checkasm_check_pixel(...) \
 473     checkasm_check_pixel2(__VA_ARGS__, 0, 0, 0)
 474 #define checkasm_check_pixel_padded(...) \
 475     checkasm_check_pixel2(__VA_ARGS__, 1, 1, 8)
 476 #define checkasm_check_pixel_padded_align(...) \
 477     checkasm_check_pixel2(__VA_ARGS__, 8)
 478
 479 /* This assumes that there is a local variable named "bit_depth"
 480  * and that the type-specific buffers obey the name ## _BITDEPTH
 481  * convention.
 482  * For tests that don't have that and only operate on a single
 483  * bitdepth, just call checkasm_check(uint8_t, ...) directly. */
 484 #define checkasm_check_dctcoef(buf1, stride1, buf2, stride2, ...) \
 485     ((bit_depth > 8) ?                                        \
 486      checkasm_check(int32_t, buf1 ## _32, stride1,            \
 487                              buf2 ## _32, stride2,            \
 488                              __VA_ARGS__) :                   \
 489      checkasm_check(int16_t, buf1 ## _16, stride1,            \
 490                              buf2 ## _16, stride2,            \
 491                              __VA_ARGS__))
 492
 493 #endif /* TESTS_CHECKASM_CHECKASM_H */