@@ -63,6 +63,7 @@

 /libavutil/ffversion.h

 /tests/audiogen

 /tests/base64

+/tests/checkasm/checkasm

 /tests/data/

 /tests/pixfmts.mak

 /tests/rotozoom

@@ -230,5 +230,7 @@ testclean::

 -include $(wildcard tests/*.d)

+include $(SRC_PATH)/tests/checkasm/Makefile

+

 .PHONY: fate* lcov lcov-reset

 .INTERMEDIATE: coverage.info

new file mode 100644

@@ -0,0 +1,33 @@

+# libavcodec tests

+AVCODECOBJS-$(CONFIG_H264PRED) += h264pred.o

+

+CHECKASMOBJS-$(CONFIG_AVCODEC) += $(AVCODECOBJS-yes)

+

+

+-include $(SRC_PATH)/tests/checkasm/$(ARCH)/Makefile

+

+CHECKASMOBJS += $(CHECKASMOBJS-yes) checkasm.o

+CHECKASMOBJS := $(sort $(CHECKASMOBJS:%=tests/checkasm/%))

+

+-include $(CHECKASMOBJS:.o=.d)

+

+CHECKASMDIRS := $(sort $(dir $(CHECKASMOBJS)))

+$(CHECKASMOBJS): | $(CHECKASMDIRS)

+OBJDIRS += $(CHECKASMDIRS)

+

+# We rely on function pointers intentionally declared without specified argument types.

+tests/checkasm/%.o: CFLAGS := $(CFLAGS:-Wstrict-prototypes=-Wno-strict-prototypes)

+

+CHECKASM := tests/checkasm/checkasm$(EXESUF)

+

+$(CHECKASM): $(EXEOBJS) $(CHECKASMOBJS) $(FF_DEP_LIBS)

+	$(LD) $(LDFLAGS) $(LDEXEFLAGS) $(LD_O) $(CHECKASMOBJS) $(FF_EXTRALIBS)

+

+checkasm: $(CHECKASM)

+

+clean:: checkasmclean

+

+checkasmclean:

+	$(RM) $(CHECKASM) $(CLEANSUFFIXES:%=tests/checkasm/%) $(CLEANSUFFIXES:%=tests/checkasm/$(ARCH)/%)

+

+.PHONY: checkasm

new file mode 100644

@@ -0,0 +1,484 @@

+/*

+ * Assembly testing and benchmarking tool

+ * Copyright (c) 2015 Henrik Gramner

+ * Copyright (c) 2008 Loren Merritt

+ *

+ * This file is part of FFmpeg.

+ *

+ * 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 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;

+    }

+}

new file mode 100644

@@ -0,0 +1,115 @@

+/*

+ * Assembly testing and benchmarking tool

+ * Copyright (c) 2015 Henrik Gramner

+ * Copyright (c) 2008 Loren Merritt

+ *

+ * This file is part of FFmpeg.

+ *

+ * 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 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

new file mode 100644

@@ -0,0 +1,252 @@

+/*

+ * Copyright (c) 2015 Henrik Gramner

+ *

+ * This file is part of FFmpeg.

+ *

+ * 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 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);

+                }

+            }

+        }