Merge commit '8bc67ec2c0d2b5444d51a1bed1d50f0e10d92717'
authorMichael Niedermayer <michael@niedermayer.cc>
Sun, 12 Jul 2015 19:00:50 +0000 (21:00 +0200)
committerMichael Niedermayer <michael@niedermayer.cc>
Sun, 12 Jul 2015 19:03:06 +0000 (21:03 +0200)
* commit '8bc67ec2c0d2b5444d51a1bed1d50f0e10d92717':
  Checkasm: assembly testing and benchmarking tool

Merged-by: Michael Niedermayer <michael@niedermayer.cc>
1  2 
.gitignore
tests/Makefile
tests/checkasm/checkasm.c
tests/checkasm/checkasm.h
tests/checkasm/h264pred.c
tests/checkasm/x86/checkasm.asm

diff --cc .gitignore
  /libavcodec/*_tables.c
  /libavcodec/*_tables.h
  /libavutil/avconfig.h
 +/libavutil/ffversion.h
  /tests/audiogen
  /tests/base64
+ /tests/checkasm/checkasm
  /tests/data/
  /tests/pixfmts.mak
  /tests/rotozoom
diff --cc tests/Makefile
Simple merge
index 0000000,59383b8..f44f981
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,484 +1,484 @@@
 - * This file is part of Libav.
+ /*
+  * Assembly testing and benchmarking tool
+  * Copyright (c) 2015 Henrik Gramner
+  * Copyright (c) 2008 Loren Merritt
+  *
 - * Libav is free software; you can redistribute it and/or modify
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; either version 2 of the License, or
+  * (at your option) any later version.
+  *
 - * with Libav; if not, write to the Free Software Foundation, Inc.,
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License along
++ * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
+  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+  */
+ #include <stdarg.h>
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+ #include "checkasm.h"
+ #include "libavutil/common.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/random_seed.h"
+ #if ARCH_X86
+ #include "libavutil/x86/cpu.h"
+ #endif
+ #if HAVE_SETCONSOLETEXTATTRIBUTE
+ #include <windows.h>
+ #define COLOR_RED    FOREGROUND_RED
+ #define COLOR_GREEN  FOREGROUND_GREEN
+ #define COLOR_YELLOW (FOREGROUND_RED|FOREGROUND_GREEN)
+ #else
+ #define COLOR_RED    1
+ #define COLOR_GREEN  2
+ #define COLOR_YELLOW 3
+ #endif
+ #if HAVE_UNISTD_H
+ #include <unistd.h>
+ #endif
+ #if !HAVE_ISATTY
+ #define isatty(fd) 1
+ #endif
+ /* List of tests to invoke */
+ static void (* const tests[])(void) = {
+ #if CONFIG_H264PRED
+     checkasm_check_h264pred,
+ #endif
+     NULL
+ };
+ /* List of cpu flags to check */
+ static const struct {
+     const char *name;
+     const char *suffix;
+     int flag;
+ } cpus[] = {
+ #if ARCH_X86
+     { "MMX",      "mmx",      AV_CPU_FLAG_MMX|AV_CPU_FLAG_CMOV },
+     { "MMXEXT",   "mmxext",   AV_CPU_FLAG_MMXEXT },
+     { "3DNOW",    "3dnow",    AV_CPU_FLAG_3DNOW },
+     { "3DNOWEXT", "3dnowext", AV_CPU_FLAG_3DNOWEXT },
+     { "SSE",      "sse",      AV_CPU_FLAG_SSE },
+     { "SSE2",     "sse2",     AV_CPU_FLAG_SSE2|AV_CPU_FLAG_SSE2SLOW },
+     { "SSE3",     "sse3",     AV_CPU_FLAG_SSE3|AV_CPU_FLAG_SSE3SLOW },
+     { "SSSE3",    "ssse3",    AV_CPU_FLAG_SSSE3|AV_CPU_FLAG_ATOM },
+     { "SSE4.1",   "sse4",     AV_CPU_FLAG_SSE4 },
+     { "SSE4.2",   "sse42",    AV_CPU_FLAG_SSE42 },
+     { "AVX",      "avx",      AV_CPU_FLAG_AVX },
+     { "XOP",      "xop",      AV_CPU_FLAG_XOP },
+     { "FMA3",     "fma3",     AV_CPU_FLAG_FMA3 },
+     { "FMA4",     "fma4",     AV_CPU_FLAG_FMA4 },
+     { "AVX2",     "avx2",     AV_CPU_FLAG_AVX2 },
+ #endif
+     { NULL }
+ };
+ typedef struct CheckasmFuncVersion {
+     struct CheckasmFuncVersion *next;
+     intptr_t (*func)();
+     int ok;
+     int cpu;
+     int iterations;
+     uint64_t cycles;
+ } CheckasmFuncVersion;
+ /* Binary search tree node */
+ typedef struct CheckasmFunc {
+     struct CheckasmFunc *child[2];
+     CheckasmFuncVersion versions;
+     char name[1];
+ } CheckasmFunc;
+ /* Internal state */
+ static struct {
+     CheckasmFunc *funcs;
+     CheckasmFunc *current_func;
+     CheckasmFuncVersion *current_func_ver;
+     const char *bench_pattern;
+     int bench_pattern_len;
+     int num_checked;
+     int num_failed;
+     int nop_time;
+     int cpu_flag;
+     const char *cpu_flag_name;
+ } state;
+ /* PRNG state */
+ AVLFG checkasm_lfg;
+ /* Print colored text to stderr if the terminal supports it */
+ static void color_printf(int color, const char *fmt, ...)
+ {
+     static int use_color = -1;
+     va_list arg;
+ #if HAVE_SETCONSOLETEXTATTRIBUTE
+     static HANDLE con;
+     static WORD org_attributes;
+     if (use_color < 0) {
+         CONSOLE_SCREEN_BUFFER_INFO con_info;
+         con = GetStdHandle(STD_ERROR_HANDLE);
+         if (con && con != INVALID_HANDLE_VALUE && GetConsoleScreenBufferInfo(con, &con_info)) {
+             org_attributes = con_info.wAttributes;
+             use_color = 1;
+         } else
+             use_color = 0;
+     }
+     if (use_color)
+         SetConsoleTextAttribute(con, (org_attributes & 0xfff0) | (color & 0x0f));
+ #else
+     if (use_color < 0) {
+         const char *term = getenv("TERM");
+         use_color = term && strcmp(term, "dumb") && isatty(2);
+     }
+     if (use_color)
+         fprintf(stderr, "\x1b[%d;3%dm", (color & 0x08) >> 3, color & 0x07);
+ #endif
+     va_start(arg, fmt);
+     vfprintf(stderr, fmt, arg);
+     va_end(arg);
+     if (use_color) {
+ #if HAVE_SETCONSOLETEXTATTRIBUTE
+         SetConsoleTextAttribute(con, org_attributes);
+ #else
+         fprintf(stderr, "\x1b[0m");
+ #endif
+     }
+ }
+ /* Deallocate a tree */
+ static void destroy_func_tree(CheckasmFunc *f)
+ {
+     if (f) {
+         CheckasmFuncVersion *v = f->versions.next;
+         while (v) {
+             CheckasmFuncVersion *next = v->next;
+             free(v);
+             v = next;
+         }
+         destroy_func_tree(f->child[0]);
+         destroy_func_tree(f->child[1]);
+         free(f);
+     }
+ }
+ /* Allocate a zero-initialized block, clean up and exit on failure */
+ static void *checkasm_malloc(size_t size)
+ {
+     void *ptr = calloc(1, size);
+     if (!ptr) {
+         fprintf(stderr, "checkasm: malloc failed\n");
+         destroy_func_tree(state.funcs);
+         exit(1);
+     }
+     return ptr;
+ }
+ /* Get the suffix of the specified cpu flag */
+ static const char *cpu_suffix(int cpu)
+ {
+     int i = FF_ARRAY_ELEMS(cpus);
+     while (--i >= 0)
+         if (cpu & cpus[i].flag)
+             return cpus[i].suffix;
+     return "c";
+ }
+ #ifdef AV_READ_TIME
+ static int cmp_nop(const void *a, const void *b)
+ {
+     return *(const uint16_t*)a - *(const uint16_t*)b;
+ }
+ /* Measure the overhead of the timing code (in decicycles) */
+ static int measure_nop_time(void)
+ {
+     uint16_t nops[10000];
+     int i, nop_sum = 0;
+     for (i = 0; i < 10000; i++) {
+         uint64_t t = AV_READ_TIME();
+         nops[i] = AV_READ_TIME() - t;
+     }
+     qsort(nops, 10000, sizeof(uint16_t), cmp_nop);
+     for (i = 2500; i < 7500; i++)
+         nop_sum += nops[i];
+     return nop_sum / 500;
+ }
+ /* Print benchmark results */
+ static void print_benchs(CheckasmFunc *f)
+ {
+     if (f) {
+         print_benchs(f->child[0]);
+         /* Only print functions with at least one assembly version */
+         if (f->versions.cpu || f->versions.next) {
+             CheckasmFuncVersion *v = &f->versions;
+             do {
+                 if (v->iterations) {
+                     int decicycles = (10*v->cycles/v->iterations - state.nop_time) / 4;
+                     printf("%s_%s: %d.%d\n", f->name, cpu_suffix(v->cpu), decicycles/10, decicycles%10);
+                 }
+             } while ((v = v->next));
+         }
+         print_benchs(f->child[1]);
+     }
+ }
+ #endif
+ /* ASCIIbetical sort except preserving natural order for numbers */
+ static int cmp_func_names(const char *a, const char *b)
+ {
+     int ascii_diff, digit_diff;
+     for (; !(ascii_diff = *a - *b) && *a; a++, b++);
+     for (; av_isdigit(*a) && av_isdigit(*b); a++, b++);
+     return (digit_diff = av_isdigit(*a) - av_isdigit(*b)) ? digit_diff : ascii_diff;
+ }
+ /* Get a node with the specified name, creating it if it doesn't exist */
+ static CheckasmFunc *get_func(const char *name, int length)
+ {
+     CheckasmFunc *f, **f_ptr = &state.funcs;
+     /* Search the tree for a matching node */
+     while ((f = *f_ptr)) {
+         int cmp = cmp_func_names(name, f->name);
+         if (!cmp)
+             return f;
+         f_ptr = &f->child[(cmp > 0)];
+     }
+     /* Allocate and insert a new node into the tree */
+     f = *f_ptr = checkasm_malloc(sizeof(CheckasmFunc) + length);
+     memcpy(f->name, name, length+1);
+     return f;
+ }
+ /* Perform tests and benchmarks for the specified cpu flag if supported by the host */
+ static void check_cpu_flag(const char *name, int flag)
+ {
+     int old_cpu_flag = state.cpu_flag;
+     flag |= old_cpu_flag;
+     av_set_cpu_flags_mask(flag);
+     state.cpu_flag = av_get_cpu_flags();
+     if (!flag || state.cpu_flag != old_cpu_flag) {
+         int i;
+         state.cpu_flag_name = name;
+         for (i = 0; tests[i]; i++)
+             tests[i]();
+     }
+ }
+ /* Print the name of the current CPU flag, but only do it once */
+ static void print_cpu_name(void)
+ {
+     if (state.cpu_flag_name) {
+         color_printf(COLOR_YELLOW, "%s:\n", state.cpu_flag_name);
+         state.cpu_flag_name = NULL;
+     }
+ }
+ int main(int argc, char *argv[])
+ {
+     int i, seed, ret = 0;
+     if (!tests[0] || !cpus[0].flag) {
+         fprintf(stderr, "checkasm: no tests to perform\n");
+         return 1;
+     }
+     if (argc > 1 && !strncmp(argv[1], "--bench", 7)) {
+ #ifndef AV_READ_TIME
+         fprintf(stderr, "checkasm: --bench is not supported on your system\n");
+         return 1;
+ #endif
+         if (argv[1][7] == '=') {
+             state.bench_pattern = argv[1] + 8;
+             state.bench_pattern_len = strlen(state.bench_pattern);
+         } else
+             state.bench_pattern = "";
+         argc--;
+         argv++;
+     }
+     seed = (argc > 1) ? atoi(argv[1]) : av_get_random_seed();
+     fprintf(stderr, "checkasm: using random seed %u\n", seed);
+     av_lfg_init(&checkasm_lfg, seed);
+     check_cpu_flag(NULL, 0);
+     for (i = 0; cpus[i].flag; i++)
+         check_cpu_flag(cpus[i].name, cpus[i].flag);
+     if (state.num_failed) {
+         fprintf(stderr, "checkasm: %d of %d tests have failed\n", state.num_failed, state.num_checked);
+         ret = 1;
+     } else {
+         fprintf(stderr, "checkasm: all %d tests passed\n", state.num_checked);
+ #ifdef AV_READ_TIME
+         if (state.bench_pattern) {
+             state.nop_time = measure_nop_time();
+             printf("nop: %d.%d\n", state.nop_time/10, state.nop_time%10);
+             print_benchs(state.funcs);
+         }
+ #endif
+     }
+     destroy_func_tree(state.funcs);
+     return ret;
+ }
+ /* Decide whether or not the specified function needs to be tested and
+  * allocate/initialize data structures if needed. Returns a pointer to a
+  * reference function if the function should be tested, otherwise NULL */
+ intptr_t (*checkasm_check_func(intptr_t (*func)(), const char *name, ...))()
+ {
+     char name_buf[256];
+     intptr_t (*ref)() = func;
+     CheckasmFuncVersion *v;
+     int name_length;
+     va_list arg;
+     va_start(arg, name);
+     name_length = vsnprintf(name_buf, sizeof(name_buf), name, arg);
+     va_end(arg);
+     if (!func || name_length <= 0 || name_length >= sizeof(name_buf))
+         return NULL;
+     state.current_func = get_func(name_buf, name_length);
+     v = &state.current_func->versions;
+     if (v->func) {
+         CheckasmFuncVersion *prev;
+         do {
+             /* Only test functions that haven't already been tested */
+             if (v->func == func)
+                 return NULL;
+             if (v->ok)
+                 ref = v->func;
+             prev = v;
+         } while ((v = v->next));
+         v = prev->next = checkasm_malloc(sizeof(CheckasmFuncVersion));
+     }
+     v->func = func;
+     v->ok = 1;
+     v->cpu = state.cpu_flag;
+     state.current_func_ver = v;
+     if (state.cpu_flag)
+         state.num_checked++;
+     return ref;
+ }
+ /* Decide whether or not the current function needs to be benchmarked */
+ int checkasm_bench_func(void)
+ {
+     return !state.num_failed && state.bench_pattern &&
+            !strncmp(state.current_func->name, state.bench_pattern, state.bench_pattern_len);
+ }
+ /* Indicate that the current test has failed */
+ void checkasm_fail_func(const char *msg, ...)
+ {
+     if (state.current_func_ver->cpu && state.current_func_ver->ok) {
+         va_list arg;
+         print_cpu_name();
+         fprintf(stderr, "   %s_%s (", state.current_func->name, cpu_suffix(state.current_func_ver->cpu));
+         va_start(arg, msg);
+         vfprintf(stderr, msg, arg);
+         va_end(arg);
+         fprintf(stderr, ")\n");
+         state.current_func_ver->ok = 0;
+         state.num_failed++;
+     }
+ }
+ /* Update benchmark results of the current function */
+ void checkasm_update_bench(int iterations, uint64_t cycles)
+ {
+     state.current_func_ver->iterations += iterations;
+     state.current_func_ver->cycles += cycles;
+ }
+ /* Print the outcome of all tests performed since the last time this function was called */
+ void checkasm_report(const char *name, ...)
+ {
+     static int prev_checked, prev_failed, max_length;
+     if (state.num_checked > prev_checked) {
+         print_cpu_name();
+         if (*name) {
+             int pad_length = max_length;
+             va_list arg;
+             fprintf(stderr, " - ");
+             va_start(arg, name);
+             pad_length -= vfprintf(stderr, name, arg);
+             va_end(arg);
+             fprintf(stderr, "%*c", FFMAX(pad_length, 0) + 2, '[');
+         } else
+             fprintf(stderr, " - %-*s [", max_length, state.current_func->name);
+         if (state.num_failed == prev_failed)
+             color_printf(COLOR_GREEN, "OK");
+         else
+             color_printf(COLOR_RED, "FAILED");
+         fprintf(stderr, "]\n");
+         prev_checked = state.num_checked;
+         prev_failed  = state.num_failed;
+     } else if (!state.cpu_flag) {
+         int length;
+         /* Calculate the amount of padding required to make the output vertically aligned */
+         if (*name) {
+             va_list arg;
+             va_start(arg, name);
+             length = vsnprintf(NULL, 0, name, arg);
+             va_end(arg);
+         } else
+             length = strlen(state.current_func->name);
+         if (length > max_length)
+             max_length = length;
+     }
+ }
index 0000000,90844e2..039aed7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,115 +1,115 @@@
 - * This file is part of Libav.
+ /*
+  * Assembly testing and benchmarking tool
+  * Copyright (c) 2015 Henrik Gramner
+  * Copyright (c) 2008 Loren Merritt
+  *
 - * Libav is free software; you can redistribute it and/or modify
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; either version 2 of the License, or
+  * (at your option) any later version.
+  *
 - * with Libav; if not, write to the Free Software Foundation, Inc.,
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License along
++ * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
+  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+  */
+ #ifndef CHECKASM_H
+ #define CHECKASM_H
+ #include <stdint.h>
+ #include "config.h"
+ #include "libavutil/avstring.h"
+ #include "libavutil/lfg.h"
+ #include "libavutil/timer.h"
+ void checkasm_check_h264pred(void);
+ intptr_t (*checkasm_check_func(intptr_t (*func)(), const char *name, ...))() av_printf_format(2, 3);
+ int checkasm_bench_func(void);
+ void checkasm_fail_func(const char *msg, ...) av_printf_format(1, 2);
+ void checkasm_update_bench(int iterations, uint64_t cycles);
+ void checkasm_report(const char *name, ...) av_printf_format(1, 2);
+ extern AVLFG checkasm_lfg;
+ #define rnd() av_lfg_get(&checkasm_lfg)
+ static av_unused intptr_t (*func_ref)();
+ static av_unused intptr_t (*func_new)();
+ #define BENCH_RUNS 1000 /* Trade-off between accuracy and speed */
+ /* Decide whether or not the specified function needs to be tested */
+ #define check_func(func, ...) ((func_new = (intptr_t (*)())func) &&\
+                               (func_ref = checkasm_check_func(func_new, __VA_ARGS__)))
+ /* Indicate that the current test has failed */
+ #define fail() checkasm_fail_func("%s:%d", av_basename(__FILE__), __LINE__)
+ /* Print the test outcome */
+ #define report(...) checkasm_report("" __VA_ARGS__)
+ /* Call the reference function */
+ #define call_ref(...) func_ref(__VA_ARGS__)
+ #if ARCH_X86 && HAVE_YASM
+ /* Verifies that clobbered callee-saved registers are properly saved and restored */
+ intptr_t checkasm_checked_call(intptr_t (*func)(), ...);
+ #endif
+ /* Call the function */
+ #if ARCH_X86_64 && HAVE_YASM
+ /* Evil hack: detect incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
+  * This is done by clobbering the stack with junk around the stack pointer and calling the
+  * assembly function through x264_checkasm_call with added dummy arguments which forces all
+  * real arguments to be passed on the stack and not in registers. For 32-bit arguments the
+  * upper half of the 64-bit register locations on the stack will now contain junk which will
+  * cause misbehaving functions to either produce incorrect output or segfault. Note that
+  * even though this works extremely well in practice, it's technically not guaranteed
+  * and false negatives is theoretically possible, but there can never be any false positives.
+  */
+ void checkasm_stack_clobber(uint64_t clobber, ...);
+ #define CLOB (UINT64_C(0xdeadbeefdeadbeef))
+ #define call_new(...) (checkasm_stack_clobber(CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,\
+                                               CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB,CLOB),\
+                       checkasm_checked_call(func_new, 0, 0, 0, 0, 0, __VA_ARGS__))
+ #elif ARCH_X86_32 && HAVE_YASM
+ #define call_new(...) checkasm_checked_call(func_new, __VA_ARGS__)
+ #else
+ #define call_new(...) func_new(__VA_ARGS__)
+ #endif
+ /* Benchmark the function */
+ #ifdef AV_READ_TIME
+ #define bench_new(...)\
+     do {\
+         if (checkasm_bench_func()) {\
+             intptr_t (*tfunc)() = func_new;\
+             uint64_t tsum = 0;\
+             int ti, tcount = 0;\
+             for (ti = 0; ti < BENCH_RUNS; ti++) {\
+                 uint64_t t = AV_READ_TIME();\
+                 tfunc(__VA_ARGS__);\
+                 tfunc(__VA_ARGS__);\
+                 tfunc(__VA_ARGS__);\
+                 tfunc(__VA_ARGS__);\
+                 t = AV_READ_TIME() - t;\
+                 if (t*tcount <= tsum*4 && ti > 0) {\
+                     tsum += t;\
+                     tcount++;\
+                 }\
+             }\
+             checkasm_update_bench(tcount, tsum);\
+         }\
+     } while (0)
+ #else
+ #define bench_new(...)
+ #endif
+ #endif
index 0000000,f0d493d..5ac91e2
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,252 +1,252 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2015 Henrik Gramner
+  *
 - * Libav is free software; you can redistribute it and/or modify
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published by
+  * the Free Software Foundation; either version 2 of the License, or
+  * (at your option) any later version.
+  *
 - * with Libav; if not, write to the Free Software Foundation, Inc.,
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  * GNU General Public License for more details.
+  *
+  * You should have received a copy of the GNU General Public License along
++ * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
+  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+  */
+ #include <string.h>
+ #include "checkasm.h"
+ #include "libavcodec/avcodec.h"
+ #include "libavcodec/h264pred.h"
+ #include "libavutil/common.h"
+ #include "libavutil/intreadwrite.h"
+ static const int codec_ids[4] = { AV_CODEC_ID_H264, AV_CODEC_ID_VP8, AV_CODEC_ID_RV40, AV_CODEC_ID_SVQ3 };
+ static const char * const pred4x4_modes[4][15] = {
+     { /* H264 */
+         [VERT_PRED           ] = "vertical",
+         [HOR_PRED            ] = "horizontal",
+         [DC_PRED             ] = "dc",
+         [DIAG_DOWN_LEFT_PRED ] = "down_left",
+         [DIAG_DOWN_RIGHT_PRED] = "down_right",
+         [VERT_RIGHT_PRED     ] = "vertical_right",
+         [HOR_DOWN_PRED       ] = "horizontal_right",
+         [VERT_LEFT_PRED      ] = "vertical_left",
+         [HOR_UP_PRED         ] = "horizontal_up",
+         [LEFT_DC_PRED        ] = "left_dc",
+         [TOP_DC_PRED         ] = "top_dc",
+         [DC_128_PRED         ] = "dc_128",
+     },
+     { /* VP8 */
+         [VERT_PRED     ] = "vertical_vp8",
+         [HOR_PRED      ] = "horizontal_vp8",
+         [VERT_LEFT_PRED] = "vertical_left_vp8",
+         [TM_VP8_PRED   ] = "tm_vp8",
+         [DC_127_PRED   ] = "dc_127_vp8",
+         [DC_129_PRED   ] = "dc_129_vp8",
+     },
+     { /* RV40 */
+         [DIAG_DOWN_LEFT_PRED            ] = "down_left_rv40",
+         [VERT_LEFT_PRED                 ] = "vertical_left_rv40",
+         [HOR_UP_PRED                    ] = "horizontal_up_rv40",
+         [DIAG_DOWN_LEFT_PRED_RV40_NODOWN] = "down_left_nodown_rv40",
+         [HOR_UP_PRED_RV40_NODOWN        ] = "horizontal_up_nodown_rv40",
+         [VERT_LEFT_PRED_RV40_NODOWN     ] = "vertical_left_nodown_rv40",
+     },
+     { /* SVQ3 */
+         [DIAG_DOWN_LEFT_PRED] = "down_left_svq3",
+     },
+ };
+ static const char * const pred8x8_modes[4][11] = {
+     { /* H264 */
+         [DC_PRED8x8              ] = "dc",
+         [HOR_PRED8x8             ] = "horizontal",
+         [VERT_PRED8x8            ] = "vertical",
+         [PLANE_PRED8x8           ] = "plane",
+         [LEFT_DC_PRED8x8         ] = "left_dc",
+         [TOP_DC_PRED8x8          ] = "top_dc",
+         [DC_128_PRED8x8          ] = "dc_128",
+         [ALZHEIMER_DC_L0T_PRED8x8] = "mad_cow_dc_l0t",
+         [ALZHEIMER_DC_0LT_PRED8x8] = "mad_cow_dc_0lt",
+         [ALZHEIMER_DC_L00_PRED8x8] = "mad_cow_dc_l00",
+         [ALZHEIMER_DC_0L0_PRED8x8] = "mad_cow_dc_0l0",
+     },
+     { /* VP8 */
+         [PLANE_PRED8x8 ] = "tm_vp8",
+         [DC_127_PRED8x8] = "dc_127_vp8",
+         [DC_129_PRED8x8] = "dc_129_vp8",
+     },
+     { /* RV40 */
+         [DC_PRED8x8     ] = "dc_rv40",
+         [LEFT_DC_PRED8x8] = "left_dc_rv40",
+         [TOP_DC_PRED8x8 ] = "top_dc_rv40",
+     },
+     { /* SVQ3 */
+     },
+ };
+ static const char * const pred16x16_modes[4][9] = {
+     { /* H264 */
+         [DC_PRED8x8     ] = "dc",
+         [HOR_PRED8x8    ] = "horizontal",
+         [VERT_PRED8x8   ] = "vertical",
+         [PLANE_PRED8x8  ] = "plane",
+         [LEFT_DC_PRED8x8] = "left_dc",
+         [TOP_DC_PRED8x8 ] = "top_dc",
+         [DC_128_PRED8x8 ] = "dc_128",
+     },
+     { /* VP8 */
+         [PLANE_PRED8x8 ] = "tm_vp8",
+         [DC_127_PRED8x8] = "dc_127_vp8",
+         [DC_129_PRED8x8] = "dc_129_vp8",
+     },
+     { /* RV40 */
+         [PLANE_PRED8x8] = "plane_rv40",
+     },
+     { /* SVQ3 */
+         [PLANE_PRED8x8] = "plane_svq3",
+     },
+ };
+ static const uint32_t pixel_mask[3] = { 0xffffffff, 0x01ff01ff, 0x03ff03ff };
+ #define SIZEOF_PIXEL ((bit_depth + 7) / 8)
+ #define BUF_SIZE (3*16*17)
+ #define check_pred_func(func, name, mode_name)\
+     (mode_name && ((codec_ids[codec] == AV_CODEC_ID_H264) ?\
+     check_func(func, "pred%s_%s_%d", name, mode_name, bit_depth) :\
+     check_func(func, "pred%s_%s", name, mode_name)))
+ #define randomize_buffers()\
+     do {\
+         uint32_t mask = pixel_mask[bit_depth-8];\
+         int i;\
+         for (i = 0; i < BUF_SIZE; i += 4) {\
+             uint32_t r = rnd() & mask;\
+             AV_WN32A(buf0+i, r);\
+             AV_WN32A(buf1+i, r);\
+         }\
+     } while (0)
+ #define src0 (buf0 + 4*16) /* Offset to allow room for top and left */
+ #define src1 (buf1 + 4*16)
+ static void check_pred4x4(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
+                           int codec, int chroma_format, int bit_depth)
+ {
+     if (chroma_format == 1) {
+         uint8_t *topright = buf0 + 2*16;
+         int pred_mode;
+         for (pred_mode = 0; pred_mode < 15; pred_mode++) {
+             if (check_pred_func(h->pred4x4[pred_mode], "4x4", pred4x4_modes[codec][pred_mode])) {
+                 randomize_buffers();
+                 call_ref(src0, topright, (ptrdiff_t)12*SIZEOF_PIXEL);
+                 call_new(src1, topright, (ptrdiff_t)12*SIZEOF_PIXEL);
+                 if (memcmp(buf0, buf1, BUF_SIZE))
+                     fail();
+                 bench_new(src1, topright, (ptrdiff_t)12*SIZEOF_PIXEL);
+             }
+         }
+     }
+ }
+ static void check_pred8x8(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
+                           int codec, int chroma_format, int bit_depth)
+ {
+     int pred_mode;
+     for (pred_mode = 0; pred_mode < 11; pred_mode++) {
+         if (check_pred_func(h->pred8x8[pred_mode], (chroma_format == 2) ? "8x16" : "8x8",
+                             pred8x8_modes[codec][pred_mode])) {
+             randomize_buffers();
+             call_ref(src0, (ptrdiff_t)24*SIZEOF_PIXEL);
+             call_new(src1, (ptrdiff_t)24*SIZEOF_PIXEL);
+             if (memcmp(buf0, buf1, BUF_SIZE))
+                 fail();
+             bench_new(src1, (ptrdiff_t)24*SIZEOF_PIXEL);
+         }
+     }
+ }
+ static void check_pred16x16(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
+                             int codec, int chroma_format, int bit_depth)
+ {
+     if (chroma_format == 1) {
+         int pred_mode;
+         for (pred_mode = 0; pred_mode < 9; pred_mode++) {
+             if (check_pred_func(h->pred16x16[pred_mode], "16x16", pred16x16_modes[codec][pred_mode])) {
+                 randomize_buffers();
+                 call_ref(src0, (ptrdiff_t)48);
+                 call_new(src1, (ptrdiff_t)48);
+                 if (memcmp(buf0, buf1, BUF_SIZE))
+                     fail();
+                 bench_new(src1, (ptrdiff_t)48);
+             }
+         }
+     }
+ }
+ static void check_pred8x8l(H264PredContext *h, uint8_t *buf0, uint8_t *buf1,
+                            int codec, int chroma_format, int bit_depth)
+ {
+     if (chroma_format == 1 && codec_ids[codec] == AV_CODEC_ID_H264) {
+         int pred_mode;
+         for (pred_mode = 0; pred_mode < 12; pred_mode++) {
+             if (check_pred_func(h->pred8x8l[pred_mode], "8x8l", pred4x4_modes[codec][pred_mode])) {
+                 int neighbors;
+                 for (neighbors = 0; neighbors <= 0xc000; neighbors += 0x4000) {
+                     int has_topleft  = neighbors & 0x8000;
+                     int has_topright = neighbors & 0x4000;
+                     if ((pred_mode == DIAG_DOWN_RIGHT_PRED || pred_mode == VERT_RIGHT_PRED) && !has_topleft)
+                         continue; /* Those aren't allowed according to the spec */
+                     randomize_buffers();
+                     call_ref(src0, has_topleft, has_topright, (ptrdiff_t)24*SIZEOF_PIXEL);
+                     call_new(src1, has_topleft, has_topright, (ptrdiff_t)24*SIZEOF_PIXEL);
+                     if (memcmp(buf0, buf1, BUF_SIZE))
+                         fail();
+                     bench_new(src1, has_topleft, has_topright, (ptrdiff_t)24*SIZEOF_PIXEL);
+                 }
+             }
+         }
+     }
+ }
+ /* TODO: Add tests for H.264 lossless H/V prediction */
+ void checkasm_check_h264pred(void)
+ {
+     static const struct {
+         void (*func)(H264PredContext*, uint8_t*, uint8_t*, int, int, int);
+         const char *name;
+     } tests[] = {
+         { check_pred4x4,   "pred4x4"   },
+         { check_pred8x8,   "pred8x8"   },
+         { check_pred16x16, "pred16x16" },
+         { check_pred8x8l,  "pred8x8l"  },
+     };
+     DECLARE_ALIGNED(16, uint8_t, buf0)[BUF_SIZE];
+     DECLARE_ALIGNED(16, uint8_t, buf1)[BUF_SIZE];
+     H264PredContext h;
+     int test, codec, chroma_format, bit_depth;
+     for (test = 0; test < FF_ARRAY_ELEMS(tests); test++) {
+         for (codec = 0; codec < 4; codec++) {
+             int codec_id = codec_ids[codec];
+             for (bit_depth = 8; bit_depth <= (codec_id == AV_CODEC_ID_H264 ? 10 : 8); bit_depth++)
+                 for (chroma_format = 1; chroma_format <= (codec_id == AV_CODEC_ID_H264 ? 2 : 1); chroma_format++) {
+                     ff_h264_pred_init(&h, codec_id, bit_depth, chroma_format);
+                     tests[test].func(&h, buf0, buf1, codec, chroma_format, bit_depth);
+                 }
+         }
+         report("%s", tests[test].name);
+     }
+ }
index 0000000,0864a4f..82d4076
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,193 +1,193 @@@
 -;* This file is part of Libav.
+ ;*****************************************************************************
+ ;* Assembly testing and benchmarking tool
+ ;* Copyright (c) 2008 Loren Merritt
+ ;* Copyright (c) 2012 Henrik Gramner
+ ;*
 -;* Libav is free software; you can redistribute it and/or modify
++;* This file is part of FFmpeg.
+ ;*
 -;* Libav is distributed in the hope that it will be useful,
++;* FFmpeg is free software; you can redistribute it and/or modify
+ ;* it under the terms of the GNU General Public License as published by
+ ;* the Free Software Foundation; either version 2 of the License, or
+ ;* (at your option) any later version.
+ ;*
++;* FFmpeg is distributed in the hope that it will be useful,
+ ;* but WITHOUT ANY WARRANTY; without even the implied warranty of
+ ;* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ ;* GNU General Public License for more details.
+ ;*
+ ;* You should have received a copy of the GNU General Public License
+ ;* along with this program; if not, write to the Free Software
+ ;* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
+ ;*****************************************************************************
+ %define private_prefix checkasm
+ %include "libavutil/x86/x86inc.asm"
+ SECTION_RODATA
+ error_message: db "failed to preserve register", 0
+ %if ARCH_X86_64
+ ; just random numbers to reduce the chance of incidental match
+ ALIGN 16
+ x6:  dq 0x1a1b2550a612b48c,0x79445c159ce79064
+ x7:  dq 0x2eed899d5a28ddcd,0x86b2536fcd8cf636
+ x8:  dq 0xb0856806085e7943,0x3f2bf84fc0fcca4e
+ x9:  dq 0xacbd382dcf5b8de2,0xd229e1f5b281303f
+ x10: dq 0x71aeaff20b095fd9,0xab63e2e11fa38ed9
+ x11: dq 0x89b0c0765892729a,0x77d410d5c42c882d
+ x12: dq 0xc45ea11a955d8dd5,0x24b3c1d2a024048b
+ x13: dq 0x2e8ec680de14b47c,0xdd7b8919edd42786
+ x14: dq 0x135ce6888fa02cbf,0x11e53e2b2ac655ef
+ x15: dq 0x011ff554472a7a10,0x6de8f4c914c334d5
+ n7:  dq 0x21f86d66c8ca00ce
+ n8:  dq 0x75b6ba21077c48ad
+ n9:  dq 0xed56bb2dcb3c7736
+ n10: dq 0x8bda43d3fd1a7e06
+ n11: dq 0xb64a9c9e5d318408
+ n12: dq 0xdf9a54b303f1d3a3
+ n13: dq 0x4a75479abd64e097
+ n14: dq 0x249214109d5d1c88
+ %endif
+ SECTION .text
+ cextern fail_func
+ ; max number of args used by any asm function.
+ ; (max_args % 4) must equal 3 for stack alignment
+ %define max_args 15
+ %if ARCH_X86_64
+ ;-----------------------------------------------------------------------------
+ ; int checkasm_stack_clobber(uint64_t clobber, ...)
+ ;-----------------------------------------------------------------------------
+ cglobal stack_clobber, 1,2
+     ; Clobber the stack with junk below the stack pointer
+     %define size (max_args+6)*8
+     SUB  rsp, size
+     mov   r1, size-8
+ .loop:
+     mov [rsp+r1], r0
+     sub   r1, 8
+     jge .loop
+     ADD  rsp, size
+     RET
+ %if WIN64
+     %assign free_regs 7
+ %else
+     %assign free_regs 9
+ %endif
+ ;-----------------------------------------------------------------------------
+ ; intptr_t checkasm_checked_call(intptr_t (*func)(), ...)
+ ;-----------------------------------------------------------------------------
+ INIT_XMM
+ cglobal checked_call, 2,15,16,max_args*8+8
+     mov  r6, r0
+     ; All arguments have been pushed on the stack instead of registers in order to
+     ; test for incorrect assumptions that 32-bit ints are zero-extended to 64-bit.
+     mov  r0, r6mp
+     mov  r1, r7mp
+     mov  r2, r8mp
+     mov  r3, r9mp
+ %if UNIX64
+     mov  r4, r10mp
+     mov  r5, r11mp
+     %assign i 6
+     %rep max_args-6
+         mov  r9, [rsp+stack_offset+(i+1)*8]
+         mov  [rsp+(i-6)*8], r9
+         %assign i i+1
+     %endrep
+ %else
+     %assign i 4
+     %rep max_args-4
+         mov  r9, [rsp+stack_offset+(i+7)*8]
+         mov  [rsp+i*8], r9
+         %assign i i+1
+     %endrep
+ %endif
+ %if WIN64
+     %assign i 6
+     %rep 16-6
+         mova m %+ i, [x %+ i]
+         %assign i i+1
+     %endrep
+ %endif
+ %assign i 14
+ %rep 15-free_regs
+     mov r %+ i, [n %+ i]
+     %assign i i-1
+ %endrep
+     call r6
+ %assign i 14
+ %rep 15-free_regs
+     xor r %+ i, [n %+ i]
+     or  r14, r %+ i
+     %assign i i-1
+ %endrep
+ %if WIN64
+     %assign i 6
+     %rep 16-6
+         pxor m %+ i, [x %+ i]
+         por  m6, m %+ i
+         %assign i i+1
+     %endrep
+     packsswb m6, m6
+     movq r5, m6
+     or  r14, r5
+ %endif
+     jz .ok
+     mov  r9, rax
+     lea  r0, [error_message]
+     call fail_func
+     mov rax, r9
+ .ok:
+     RET
+ %else
+ ; just random numbers to reduce the chance of incidental match
+ %define n3 dword 0x6549315c
+ %define n4 dword 0xe02f3e23
+ %define n5 dword 0xb78d0d1d
+ %define n6 dword 0x33627ba7
+ ;-----------------------------------------------------------------------------
+ ; intptr_t checkasm_checked_call(intptr_t (*func)(), ...)
+ ;-----------------------------------------------------------------------------
+ cglobal checked_call, 1,7
+     mov  r3, n3
+     mov  r4, n4
+     mov  r5, n5
+     mov  r6, n6
+ %rep max_args
+     PUSH dword [esp+20+max_args*4]
+ %endrep
+     call r0
+     xor  r3, n3
+     xor  r4, n4
+     xor  r5, n5
+     xor  r6, n6
+     or   r3, r4
+     or   r5, r6
+     or   r3, r5
+     jz .ok
+     mov  r3, eax
+     lea  r0, [error_message]
+     mov [esp], r0
+     call fail_func
+     mov  eax, r3
+ .ok:
+     add  esp, max_args*4
+     REP_RET
+ %endif ; ARCH_X86_64