[FFmpeg-cvslog] Merge commit 'f8d17d53957056c053a46f9320fa7ae6fe1479a5'

Hendrik Leppkes git at videolan.org
Mon Nov 14 16:29:38 EET 2016


ffmpeg | branch: master | Hendrik Leppkes <h.leppkes at gmail.com> | Mon Nov 14 15:27:48 2016 +0100| [47f75839e4995922f18d9eb2a49cf2ac3e8724ad] | committer: Hendrik Leppkes

Merge commit 'f8d17d53957056c053a46f9320fa7ae6fe1479a5'

* commit 'f8d17d53957056c053a46f9320fa7ae6fe1479a5':
  checkasm: Add tests for vp8dsp

Merged-by: Hendrik Leppkes <h.leppkes at gmail.com>

> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=47f75839e4995922f18d9eb2a49cf2ac3e8724ad
---

 tests/checkasm/Makefile   |   1 +
 tests/checkasm/checkasm.c |   3 +
 tests/checkasm/checkasm.h |   1 +
 tests/checkasm/vp8dsp.c   | 517 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 522 insertions(+)

diff --git a/tests/checkasm/Makefile b/tests/checkasm/Makefile
index b886cb0..22a74b6 100644
--- a/tests/checkasm/Makefile
+++ b/tests/checkasm/Makefile
@@ -6,6 +6,7 @@ AVCODECOBJS-$(CONFIG_FMTCONVERT)        += fmtconvert.o
 AVCODECOBJS-$(CONFIG_H264DSP)           += h264dsp.o
 AVCODECOBJS-$(CONFIG_H264PRED)          += h264pred.o
 AVCODECOBJS-$(CONFIG_H264QPEL)          += h264qpel.o
+AVCODECOBJS-$(CONFIG_VP8DSP)            += vp8dsp.o
 AVCODECOBJS-$(CONFIG_VIDEODSP)          += videodsp.o
 
 # decoders/encoders
diff --git a/tests/checkasm/checkasm.c b/tests/checkasm/checkasm.c
index cca227a..f2dbce4 100644
--- a/tests/checkasm/checkasm.c
+++ b/tests/checkasm/checkasm.c
@@ -98,6 +98,9 @@ static const struct {
     #if CONFIG_V210_ENCODER
         { "v210enc", checkasm_check_v210enc },
     #endif
+    #if CONFIG_VP8DSP
+        { "vp8dsp", checkasm_check_vp8dsp },
+    #endif
     #if CONFIG_VP9_DECODER
         { "vp9dsp", checkasm_check_vp9dsp },
     #endif
diff --git a/tests/checkasm/checkasm.h b/tests/checkasm/checkasm.h
index 7877251..a8c955b 100644
--- a/tests/checkasm/checkasm.h
+++ b/tests/checkasm/checkasm.h
@@ -44,6 +44,7 @@ void checkasm_check_jpeg2000dsp(void);
 void checkasm_check_pixblockdsp(void);
 void checkasm_check_synth_filter(void);
 void checkasm_check_v210enc(void);
+void checkasm_check_vp8dsp(void);
 void checkasm_check_vp9dsp(void);
 void checkasm_check_videodsp(void);
 
diff --git a/tests/checkasm/vp8dsp.c b/tests/checkasm/vp8dsp.c
new file mode 100644
index 0000000..76abe4c
--- /dev/null
+++ b/tests/checkasm/vp8dsp.c
@@ -0,0 +1,517 @@
+/*
+ * Copyright (c) 2016 Martin Storsjo
+ *
+ * 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 "libavcodec/avcodec.h"
+#include "libavcodec/vp8dsp.h"
+
+#include "libavutil/common.h"
+#include "libavutil/intreadwrite.h"
+
+#include "checkasm.h"
+
+#define PIXEL_STRIDE 16
+
+#define randomize_buffers(src, dst, stride, coef)                            \
+    do {                                                                     \
+        int x, y;                                                            \
+        for (y = 0; y < 4; y++) {                                            \
+            AV_WN32A((src) + y * (stride), rnd());                           \
+            AV_WN32A((dst) + y * (stride), rnd());                           \
+            for (x = 0; x < 4; x++)                                          \
+                (coef)[y * 4 + x] = (src)[y * (stride) + x] -                \
+                                    (dst)[y * (stride) + x];                 \
+        }                                                                    \
+    } while (0)
+
+static void dct4x4(int16_t *coef)
+{
+    int i;
+    for (i = 0; i < 4; i++) {
+        const int a1 = (coef[i*4 + 0] + coef[i*4 + 3]) * 8;
+        const int b1 = (coef[i*4 + 1] + coef[i*4 + 2]) * 8;
+        const int c1 = (coef[i*4 + 1] - coef[i*4 + 2]) * 8;
+        const int d1 = (coef[i*4 + 0] - coef[i*4 + 3]) * 8;
+        coef[i*4 + 0] =  a1 + b1;
+        coef[i*4 + 1] = (c1 * 2217 + d1 * 5352 + 14500) >> 12;
+        coef[i*4 + 2] =  a1 - b1;
+        coef[i*4 + 3] = (d1 * 2217 - c1 * 5352 +  7500) >> 12;
+    }
+    for (i = 0; i < 4; i++) {
+        const int a1 = coef[i + 0*4] + coef[i + 3*4];
+        const int b1 = coef[i + 1*4] + coef[i + 2*4];
+        const int c1 = coef[i + 1*4] - coef[i + 2*4];
+        const int d1 = coef[i + 0*4] - coef[i + 3*4];
+        coef[i + 0*4] =  (a1 + b1 + 7) >> 4;
+        coef[i + 1*4] = ((c1 * 2217 + d1 * 5352 + 12000) >> 16) + !!d1;
+        coef[i + 2*4] =  (a1 - b1 + 7) >> 4;
+        coef[i + 3*4] =  (d1 * 2217 - c1 * 5352 + 51000) >> 16;
+    }
+}
+
+static void wht4x4(int16_t *coef)
+{
+    int i;
+    for (i = 0; i < 4; i++) {
+        int a1 = coef[0 * 4 + i];
+        int b1 = coef[1 * 4 + i];
+        int c1 = coef[2 * 4 + i];
+        int d1 = coef[3 * 4 + i];
+        int e1;
+        a1 += b1;
+        d1 -= c1;
+        e1 = (a1 - d1) >> 1;
+        b1 = e1 - b1;
+        c1 = e1 - c1;
+        a1 -= c1;
+        d1 += b1;
+        coef[0 * 4 + i] = a1;
+        coef[1 * 4 + i] = c1;
+        coef[2 * 4 + i] = d1;
+        coef[3 * 4 + i] = b1;
+    }
+    for (i = 0; i < 4; i++) {
+        int a1 = coef[i * 4 + 0];
+        int b1 = coef[i * 4 + 1];
+        int c1 = coef[i * 4 + 2];
+        int d1 = coef[i * 4 + 3];
+        int e1;
+        a1 += b1;
+        d1 -= c1;
+        e1 = (a1 - d1) >> 1;
+        b1 = e1 - b1;
+        c1 = e1 - c1;
+        a1 -= c1;
+        d1 += b1;
+        coef[i * 4 + 0] = a1 * 2;
+        coef[i * 4 + 1] = c1 * 2;
+        coef[i * 4 + 2] = d1 * 2;
+        coef[i * 4 + 3] = b1 * 2;
+    }
+}
+
+static void check_idct(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, coef, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef0, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef1, [4 * 4]);
+    VP8DSPContext d;
+    int dc;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, ptrdiff_t stride);
+
+    ff_vp8dsp_init(&d);
+    randomize_buffers(src, dst, 4, coef);
+
+    dct4x4(coef);
+
+    for (dc = 0; dc <= 1; dc++) {
+        void (*idct)(uint8_t *, int16_t *, ptrdiff_t) = dc ? d.vp8_idct_dc_add : d.vp8_idct_add;
+
+        if (check_func(idct, "vp8_idct_%sadd", dc ? "dc_" : "")) {
+            if (dc) {
+                memset(subcoef0, 0, 4 * 4 * sizeof(int16_t));
+                subcoef0[0] = coef[0];
+            } else {
+                memcpy(subcoef0, coef, 4 * 4 * sizeof(int16_t));
+            }
+            memcpy(dst0, dst, 4 * 4);
+            memcpy(dst1, dst, 4 * 4);
+            memcpy(subcoef1, subcoef0, 4 * 4 * sizeof(int16_t));
+            // Note, this uses a pixel stride of 4, even though the real decoder uses a stride as a
+            // multiple of 16. If optimizations want to take advantage of that, this test needs to be
+            // updated to make it more like the h264dsp tests.
+            call_ref(dst0, subcoef0, 4);
+            call_new(dst1, subcoef1, 4);
+            if (memcmp(dst0, dst1, 4 * 4) ||
+                memcmp(subcoef0, subcoef1, 4 * 4 * sizeof(int16_t)))
+                fail();
+
+            bench_new(dst1, subcoef1, 4);
+        }
+    }
+}
+
+static void check_idct_dc4(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, coef, [4], [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef0, [4], [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, subcoef1, [4], [4 * 4]);
+    VP8DSPContext d;
+    int i, chroma;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
+
+    ff_vp8dsp_init(&d);
+
+    for (chroma = 0; chroma <= 1; chroma++) {
+        void (*idct4dc)(uint8_t *, int16_t[4][16], ptrdiff_t) = chroma ? d.vp8_idct_dc_add4uv : d.vp8_idct_dc_add4y;
+        if (check_func(idct4dc, "vp8_idct_dc_add4%s", chroma ? "uv" : "y")) {
+            int stride = chroma ? 8 : 16;
+            int w      = chroma ? 2 : 4;
+            for (i = 0; i < 4; i++) {
+                int blockx = 4 * (i % w);
+                int blocky = 4 * (i / w);
+                randomize_buffers(src + stride * blocky + blockx, dst + stride * blocky + blockx, stride, coef[i]);
+                dct4x4(coef[i]);
+                memset(&coef[i][1], 0, 15 * sizeof(int16_t));
+            }
+
+            memcpy(dst0, dst, 4 * 4 * 4);
+            memcpy(dst1, dst, 4 * 4 * 4);
+            memcpy(subcoef0, coef, 4 * 4 * 4 * sizeof(int16_t));
+            memcpy(subcoef1, coef, 4 * 4 * 4 * sizeof(int16_t));
+            call_ref(dst0, subcoef0, stride);
+            call_new(dst1, subcoef1, stride);
+            if (memcmp(dst0, dst1, 4 * 4 * 4) ||
+                memcmp(subcoef0, subcoef1, 4 * 4 * 4 * sizeof(int16_t)))
+                fail();
+            bench_new(dst1, subcoef1, stride);
+        }
+    }
+
+}
+
+static void check_luma_dc_wht(void)
+{
+    LOCAL_ALIGNED_16(int16_t, dc, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, dc0, [4 * 4]);
+    LOCAL_ALIGNED_16(int16_t, dc1, [4 * 4]);
+    int16_t block[4][4][16];
+    LOCAL_ALIGNED_16(int16_t, block0, [4], [4][16]);
+    LOCAL_ALIGNED_16(int16_t, block1, [4], [4][16]);
+    VP8DSPContext d;
+    int dc_only;
+    int blockx, blocky;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t block[4][4][16], int16_t dc[16]);
+
+    ff_vp8dsp_init(&d);
+
+    for (blocky = 0; blocky < 4; blocky++) {
+        for (blockx = 0; blockx < 4; blockx++) {
+            uint8_t src[16], dst[16];
+            randomize_buffers(src, dst, 4, block[blocky][blockx]);
+
+            dct4x4(block[blocky][blockx]);
+            dc[blocky * 4 + blockx] = block[blocky][blockx][0];
+            block[blocky][blockx][0] = rnd();
+        }
+    }
+    wht4x4(dc);
+
+    for (dc_only = 0; dc_only <= 1; dc_only++) {
+        void (*idct)(int16_t [4][4][16], int16_t [16]) = dc_only ? d.vp8_luma_dc_wht_dc : d.vp8_luma_dc_wht;
+
+        if (check_func(idct, "vp8_luma_dc_wht%s", dc_only ? "_dc" : "")) {
+            if (dc_only) {
+                memset(dc0, 0, 16 * sizeof(int16_t));
+                dc0[0] = dc[0];
+            } else {
+                memcpy(dc0, dc, 16 * sizeof(int16_t));
+            }
+            memcpy(dc1, dc0, 16 * sizeof(int16_t));
+            memcpy(block0, block, 4 * 4 * 16 * sizeof(int16_t));
+            memcpy(block1, block, 4 * 4 * 16 * sizeof(int16_t));
+            call_ref(block0, dc0);
+            call_new(block1, dc1);
+            if (memcmp(block0, block1, 4 * 4 * 16 * sizeof(int16_t)) ||
+                memcmp(dc0, dc1, 16 * sizeof(int16_t)))
+                fail();
+            bench_new(block1, dc1);
+        }
+    }
+}
+
+#define SRC_BUF_STRIDE 32
+#define SRC_BUF_SIZE ((size + 5) * SRC_BUF_STRIDE)
+// The mc subpixel interpolation filter needs the 2 previous pixels in either
+// direction, the +1 is to make sure the actual load addresses always are
+// unaligned.
+#define src (buf + 2 * SRC_BUF_STRIDE + 2 + 1)
+
+#undef randomize_buffers
+#define randomize_buffers()                               \
+    do {                                                  \
+        int k;                                            \
+        for (k = 0; k < SRC_BUF_SIZE; k += 4) {           \
+            AV_WN32A(buf + k, rnd());                     \
+        }                                                 \
+    } while (0)
+
+static void check_mc(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, buf, [32 * 32]);
+    LOCAL_ALIGNED_16(uint8_t, dst0, [16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, dst1, [16 * 16]);
+    VP8DSPContext d;
+    int type, hsize, dx, dy;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp78dsp_init(&d);
+
+    for (type = 0; type < 2; type++) {
+        vp8_mc_func (*tab)[3][3] = type ? d.put_vp8_bilinear_pixels_tab : d.put_vp8_epel_pixels_tab;
+        for (hsize = 0; hsize < 3; hsize++) {
+            int size = 16 >> hsize;
+            for (dy = 0; dy < 3; dy++) {
+                for (dx = 0; dx < 3; dx++) {
+                    char str[100];
+                    if (dx || dy) {
+                        if (type == 0) {
+                            static const char *dx_names[] = { "", "h4", "h6" };
+                            static const char *dy_names[] = { "", "v4", "v6" };
+                            snprintf(str, sizeof(str), "epel%d_%s%s", size, dx_names[dx], dy_names[dy]);
+                        } else {
+                            snprintf(str, sizeof(str), "bilin%d_%s%s", size, dx ? "h" : "", dy ? "v" : "");
+                        }
+                    } else {
+                        snprintf(str, sizeof(str), "pixels%d", size);
+                    }
+                    if (check_func(tab[hsize][dy][dx], "vp8_put_%s", str)) {
+                        int mx, my;
+                        int i;
+                        if (type == 0) {
+                            mx = dx == 2 ? 2 + 2 * (rnd() % 3) : dx == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                            my = dy == 2 ? 2 + 2 * (rnd() % 3) : dy == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                        } else {
+                            mx = dx ? 1 + (rnd() % 7) : 0;
+                            my = dy ? 1 + (rnd() % 7) : 0;
+                        }
+                        randomize_buffers();
+                        for (i = -2; i <= 3; i++) {
+                            int val = (i == -1 || i == 2) ? 0 : 0xff;
+                            // Set pixels in the first row and column to the maximum pattern,
+                            // to test for potential overflows in the filter.
+                            src[i                 ] = val;
+                            src[i * SRC_BUF_STRIDE] = val;
+                        }
+                        call_ref(dst0, size, src, SRC_BUF_STRIDE, size, mx, my);
+                        call_new(dst1, size, src, SRC_BUF_STRIDE, size, mx, my);
+                        if (memcmp(dst0, dst1, size * size))
+                            fail();
+                        bench_new(dst1, size, src, SRC_BUF_STRIDE, size, mx, my);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#undef randomize_buffers
+
+#define setpx(a, b, c) buf[(a) + (b) * jstride] = av_clip_uint8(c)
+// Set the pixel to c +/- [0,d]
+#define setdx(a, b, c, d) setpx(a, b, c - (d) + (rnd() % ((d) * 2 + 1)))
+// Set the pixel to c +/- [d,d+e] (making sure it won't be clipped)
+#define setdx2(a, b, o, c, d, e) setpx(a, b, o = c + ((d) + (rnd() % (e))) * (c >= 128 ? -1 : 1))
+
+static void randomize_loopfilter_buffers(int lineoff, int str,
+                                         int dir, int flim_E, int flim_I,
+                                         int hev_thresh, uint8_t *buf,
+                                         int force_hev)
+{
+    uint32_t mask = 0xff;
+    int off = dir ? lineoff : lineoff * str;
+    int istride = dir ? 1 : str;
+    int jstride = dir ? str : 1;
+    int i;
+    for (i = 0; i < 8; i += 2) {
+        // Row 0 will trigger hev for q0/q1, row 2 will trigger hev for p0/p1,
+        // rows 4 and 6 will not trigger hev.
+        // force_hev 1 will make sure all rows trigger hev, while force_hev -1
+        // makes none of them trigger it.
+        int idx = off + i * istride, p2, p1, p0, q0, q1, q2;
+        setpx(idx,  0, q0 = rnd() & mask);
+        if (i == 0 && force_hev >= 0 || force_hev > 0)
+            setdx2(idx, 1, q1, q0, hev_thresh + 1, flim_I - hev_thresh - 1);
+        else
+            setdx(idx,  1, q1 = q0, hev_thresh);
+        setdx(idx,  2, q2 = q1, flim_I);
+        setdx(idx,  3, q2,      flim_I);
+        setdx(idx, -1, p0 = q0, flim_E >> 2);
+        if (i == 2 && force_hev >= 0 || force_hev > 0)
+            setdx2(idx, -2, p1, p0, hev_thresh + 1, flim_I - hev_thresh - 1);
+        else
+            setdx(idx, -2, p1 = p0, hev_thresh);
+        setdx(idx, -3, p2 = p1, flim_I);
+        setdx(idx, -4, p2,      flim_I);
+    }
+}
+
+// Fill the buffer with random pixels
+static void fill_loopfilter_buffers(uint8_t *buf, int stride, int w, int h)
+{
+    int x, y;
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            buf[y * stride + x] = rnd() & 0xff;
+}
+
+#define randomize_buffers(buf, lineoff, str, force_hev) \
+    randomize_loopfilter_buffers(lineoff, str, dir, flim_E, flim_I, hev_thresh, buf, force_hev)
+
+static void check_loopfilter_16y(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir, edge, force_hev;
+    int flim_E = 20, flim_I = 10, hev_thresh = 7;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0 = base0 + midoff_aligned;
+        uint8_t *buf1 = base1 + midoff_aligned;
+        for (edge = 0; edge < 2; edge++) {
+            void (*func)(uint8_t *, ptrdiff_t, int, int, int) = NULL;
+            switch (dir << 1 | edge) {
+            case (0 << 1) | 0: func = d.vp8_h_loop_filter16y; break;
+            case (1 << 1) | 0: func = d.vp8_v_loop_filter16y; break;
+            case (0 << 1) | 1: func = d.vp8_h_loop_filter16y_inner; break;
+            case (1 << 1) | 1: func = d.vp8_v_loop_filter16y_inner; break;
+            }
+            if (check_func(func, "vp8_loop_filter16y%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                for (force_hev = -1; force_hev <= 1; force_hev++) {
+                    fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                    randomize_buffers(buf0, 0, 16, force_hev);
+                    randomize_buffers(buf0, 8, 16, force_hev);
+                    memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+                    call_ref(buf0, 16, flim_E, flim_I, hev_thresh);
+                    call_new(buf1, 16, flim_E, flim_I, hev_thresh);
+                    if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                        fail();
+                }
+                fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                randomize_buffers(buf0, 0, 16, 0);
+                randomize_buffers(buf0, 8, 16, 0);
+                bench_new(buf0, 16, flim_E, flim_I, hev_thresh);
+            }
+        }
+    }
+}
+
+static void check_loopfilter_8uv(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0u, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base0v, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1u, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1v, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir, edge, force_hev;
+    int flim_E = 20, flim_I = 10, hev_thresh = 7;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, uint8_t *, ptrdiff_t, int, int, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0u = base0u + midoff_aligned;
+        uint8_t *buf0v = base0v + midoff_aligned;
+        uint8_t *buf1u = base1u + midoff_aligned;
+        uint8_t *buf1v = base1v + midoff_aligned;
+        for (edge = 0; edge < 2; edge++) {
+            void (*func)(uint8_t *, uint8_t *, ptrdiff_t, int, int, int) = NULL;
+            switch (dir << 1 | edge) {
+            case (0 << 1) | 0: func = d.vp8_h_loop_filter8uv; break;
+            case (1 << 1) | 0: func = d.vp8_v_loop_filter8uv; break;
+            case (0 << 1) | 1: func = d.vp8_h_loop_filter8uv_inner; break;
+            case (1 << 1) | 1: func = d.vp8_v_loop_filter8uv_inner; break;
+            }
+            if (check_func(func, "vp8_loop_filter8uv%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                for (force_hev = -1; force_hev <= 1; force_hev++) {
+                    fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                    fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                    randomize_buffers(buf0u, 0, 16, force_hev);
+                    randomize_buffers(buf0v, 0, 16, force_hev);
+                    memcpy(buf1u - midoff, buf0u - midoff, 16 * 16);
+                    memcpy(buf1v - midoff, buf0v - midoff, 16 * 16);
+
+                    call_ref(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+                    call_new(buf1u, buf1v, 16, flim_E, flim_I, hev_thresh);
+                    if (memcmp(buf0u - midoff, buf1u - midoff, 16 * 16) ||
+                        memcmp(buf0v - midoff, buf1v - midoff, 16 * 16))
+                        fail();
+                }
+                fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                randomize_buffers(buf0u, 0, 16, 0);
+                randomize_buffers(buf0v, 0, 16, 0);
+                bench_new(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+            }
+        }
+    }
+}
+
+static void check_loopfilter_simple(void)
+{
+    LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+    LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+    VP8DSPContext d;
+    int dir;
+    int flim_E = 20, flim_I = 30, hev_thresh = 0;
+    declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int);
+
+    ff_vp8dsp_init(&d);
+
+    for (dir = 0; dir < 2; dir++) {
+        int midoff = dir ? 4 * 16 : 4;
+        int midoff_aligned = dir ? 4 * 16 : 16;
+        uint8_t *buf0 = base0 + midoff_aligned;
+        uint8_t *buf1 = base1 + midoff_aligned;
+        void (*func)(uint8_t *, ptrdiff_t, int) = dir ? d.vp8_v_loop_filter_simple : d.vp8_h_loop_filter_simple;
+        if (check_func(func, "vp8_loop_filter_simple_%s", dir ? "v" : "h")) {
+            fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+            randomize_buffers(buf0, 0, 16, -1);
+            randomize_buffers(buf0, 8, 16, -1);
+            memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+            call_ref(buf0, 16, flim_E);
+            call_new(buf1, 16, flim_E);
+            if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                fail();
+            bench_new(buf0, 16, flim_E);
+        }
+    }
+}
+
+void checkasm_check_vp8dsp(void)
+{
+    check_idct();
+    check_idct_dc4();
+    check_luma_dc_wht();
+    report("idct");
+    check_mc();
+    report("mc");
+    check_loopfilter_16y();
+    check_loopfilter_8uv();
+    check_loopfilter_simple();
+    report("loopfilter");
+}


======================================================================

diff --cc tests/checkasm/Makefile
index b886cb0,7c1d0ec..22a74b6
--- a/tests/checkasm/Makefile
+++ b/tests/checkasm/Makefile
@@@ -6,15 -5,12 +6,16 @@@ AVCODECOBJS-$(CONFIG_FMTCONVERT
  AVCODECOBJS-$(CONFIG_H264DSP)           += h264dsp.o
  AVCODECOBJS-$(CONFIG_H264PRED)          += h264pred.o
  AVCODECOBJS-$(CONFIG_H264QPEL)          += h264qpel.o
+ AVCODECOBJS-$(CONFIG_VP8DSP)            += vp8dsp.o
 +AVCODECOBJS-$(CONFIG_VIDEODSP)          += videodsp.o
  
  # decoders/encoders
 -AVCODECOBJS-$(CONFIG_DCA_DECODER)       += dcadsp.o synth_filter.o
 -AVCODECOBJS-$(CONFIG_HEVC_DECODER)      += hevc_mc.o
 +AVCODECOBJS-$(CONFIG_ALAC_DECODER)      += alacdsp.o
 +AVCODECOBJS-$(CONFIG_DCA_DECODER)       += synth_filter.o
 +AVCODECOBJS-$(CONFIG_JPEG2000_DECODER)  += jpeg2000dsp.o
 +AVCODECOBJS-$(CONFIG_PIXBLOCKDSP)       += pixblockdsp.o
  AVCODECOBJS-$(CONFIG_V210_ENCODER)      += v210enc.o
 +AVCODECOBJS-$(CONFIG_VP9_DECODER)       += vp9dsp.o
  
  CHECKASMOBJS-$(CONFIG_AVCODEC)          += $(AVCODECOBJS-yes)
  
diff --cc tests/checkasm/checkasm.c
index cca227a,739da61..f2dbce4
--- a/tests/checkasm/checkasm.c
+++ b/tests/checkasm/checkasm.c
@@@ -64,54 -64,33 +64,57 @@@ static const struct 
      const char *name;
      void (*func)(void);
  } tests[] = {
 -#if CONFIG_BSWAPDSP
 -    { "bswapdsp", checkasm_check_bswapdsp },
 +#if CONFIG_AVCODEC
 +    #if CONFIG_ALAC_DECODER
 +        { "alacdsp", checkasm_check_alacdsp },
 +    #endif
 +    #if CONFIG_BSWAPDSP
 +        { "bswapdsp", checkasm_check_bswapdsp },
 +    #endif
 +    #if CONFIG_DCA_DECODER
 +        { "synth_filter", checkasm_check_synth_filter },
 +    #endif
 +    #if CONFIG_FLACDSP
 +        { "flacdsp", checkasm_check_flacdsp },
 +    #endif
 +    #if CONFIG_FMTCONVERT
 +        { "fmtconvert", checkasm_check_fmtconvert },
 +    #endif
 +    #if CONFIG_H264DSP
 +        { "h264dsp", checkasm_check_h264dsp },
 +    #endif
 +    #if CONFIG_H264PRED
 +        { "h264pred", checkasm_check_h264pred },
 +    #endif
 +    #if CONFIG_H264QPEL
 +        { "h264qpel", checkasm_check_h264qpel },
 +    #endif
 +    #if CONFIG_JPEG2000_DECODER
 +        { "jpeg2000dsp", checkasm_check_jpeg2000dsp },
 +    #endif
 +    #if CONFIG_PIXBLOCKDSP
 +        { "pixblockdsp", checkasm_check_pixblockdsp },
 +    #endif
 +    #if CONFIG_V210_ENCODER
 +        { "v210enc", checkasm_check_v210enc },
 +    #endif
++    #if CONFIG_VP8DSP
++        { "vp8dsp", checkasm_check_vp8dsp },
++    #endif
 +    #if CONFIG_VP9_DECODER
 +        { "vp9dsp", checkasm_check_vp9dsp },
 +    #endif
 +    #if CONFIG_VIDEODSP
 +        { "videodsp", checkasm_check_videodsp },
 +    #endif
  #endif
 -#if CONFIG_DCA_DECODER
 -    { "dcadsp", checkasm_check_dcadsp },
 -    { "synth_filter", checkasm_check_synth_filter },
 -#endif
 -#if CONFIG_FMTCONVERT
 -    { "fmtconvert", checkasm_check_fmtconvert },
 -#endif
 -#if CONFIG_H264DSP
 -    { "h264dsp", checkasm_check_h264dsp },
 -#endif
 -#if CONFIG_H264PRED
 -    { "h264pred", checkasm_check_h264pred },
 -#endif
 -#if CONFIG_H264QPEL
 -    { "h264qpel", checkasm_check_h264qpel },
 -#endif
 -#if CONFIG_HEVC_DECODER
 -    { "hevc_mc", checkasm_check_hevc_mc },
 -#endif
 -#if CONFIG_V210_ENCODER
 -    { "v210enc", checkasm_check_v210enc },
 -#endif
 -#if CONFIG_VP8DSP
 -    { "vp8dsp", checkasm_check_vp8dsp },
 +#if CONFIG_AVFILTER
 +    #if CONFIG_BLEND_FILTER
 +        { "vf_blend", checkasm_check_blend },
 +    #endif
 +    #if CONFIG_COLORSPACE_FILTER
 +        { "vf_colorspace", checkasm_check_colorspace },
 +    #endif
  #endif
      { NULL }
  };
diff --cc tests/checkasm/checkasm.h
index 7877251,7f15b9c..a8c955b
--- a/tests/checkasm/checkasm.h
+++ b/tests/checkasm/checkasm.h
@@@ -40,12 -37,10 +40,13 @@@ void checkasm_check_fmtconvert(void)
  void checkasm_check_h264dsp(void);
  void checkasm_check_h264pred(void);
  void checkasm_check_h264qpel(void);
 -void checkasm_check_hevc_mc(void);
 +void checkasm_check_jpeg2000dsp(void);
 +void checkasm_check_pixblockdsp(void);
  void checkasm_check_synth_filter(void);
  void checkasm_check_v210enc(void);
+ void checkasm_check_vp8dsp(void);
 +void checkasm_check_vp9dsp(void);
 +void checkasm_check_videodsp(void);
  
  void *checkasm_check_func(void *func, const char *name, ...) av_printf_format(2, 3);
  int checkasm_bench_func(void);
diff --cc tests/checkasm/vp8dsp.c
index 0000000,3fe09c5..76abe4c
mode 000000,100644..100644
--- a/tests/checkasm/vp8dsp.c
+++ b/tests/checkasm/vp8dsp.c
@@@ -1,0 -1,517 +1,517 @@@
+ /*
+  * Copyright (c) 2016 Martin Storsjo
+  *
 - * This file is part of Libav.
++ * This file is part of FFmpeg.
+  *
 - * Libav is free software; you can redistribute it and/or modify
++ * 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.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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 Libav; if not, write to the Free Software Foundation, Inc.,
++ * 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 "libavcodec/avcodec.h"
+ #include "libavcodec/vp8dsp.h"
+ 
+ #include "libavutil/common.h"
+ #include "libavutil/intreadwrite.h"
+ 
+ #include "checkasm.h"
+ 
+ #define PIXEL_STRIDE 16
+ 
+ #define randomize_buffers(src, dst, stride, coef)                            \
+     do {                                                                     \
+         int x, y;                                                            \
+         for (y = 0; y < 4; y++) {                                            \
+             AV_WN32A((src) + y * (stride), rnd());                           \
+             AV_WN32A((dst) + y * (stride), rnd());                           \
+             for (x = 0; x < 4; x++)                                          \
+                 (coef)[y * 4 + x] = (src)[y * (stride) + x] -                \
+                                     (dst)[y * (stride) + x];                 \
+         }                                                                    \
+     } while (0)
+ 
+ static void dct4x4(int16_t *coef)
+ {
+     int i;
+     for (i = 0; i < 4; i++) {
+         const int a1 = (coef[i*4 + 0] + coef[i*4 + 3]) * 8;
+         const int b1 = (coef[i*4 + 1] + coef[i*4 + 2]) * 8;
+         const int c1 = (coef[i*4 + 1] - coef[i*4 + 2]) * 8;
+         const int d1 = (coef[i*4 + 0] - coef[i*4 + 3]) * 8;
+         coef[i*4 + 0] =  a1 + b1;
+         coef[i*4 + 1] = (c1 * 2217 + d1 * 5352 + 14500) >> 12;
+         coef[i*4 + 2] =  a1 - b1;
+         coef[i*4 + 3] = (d1 * 2217 - c1 * 5352 +  7500) >> 12;
+     }
+     for (i = 0; i < 4; i++) {
+         const int a1 = coef[i + 0*4] + coef[i + 3*4];
+         const int b1 = coef[i + 1*4] + coef[i + 2*4];
+         const int c1 = coef[i + 1*4] - coef[i + 2*4];
+         const int d1 = coef[i + 0*4] - coef[i + 3*4];
+         coef[i + 0*4] =  (a1 + b1 + 7) >> 4;
+         coef[i + 1*4] = ((c1 * 2217 + d1 * 5352 + 12000) >> 16) + !!d1;
+         coef[i + 2*4] =  (a1 - b1 + 7) >> 4;
+         coef[i + 3*4] =  (d1 * 2217 - c1 * 5352 + 51000) >> 16;
+     }
+ }
+ 
+ static void wht4x4(int16_t *coef)
+ {
+     int i;
+     for (i = 0; i < 4; i++) {
+         int a1 = coef[0 * 4 + i];
+         int b1 = coef[1 * 4 + i];
+         int c1 = coef[2 * 4 + i];
+         int d1 = coef[3 * 4 + i];
+         int e1;
+         a1 += b1;
+         d1 -= c1;
+         e1 = (a1 - d1) >> 1;
+         b1 = e1 - b1;
+         c1 = e1 - c1;
+         a1 -= c1;
+         d1 += b1;
+         coef[0 * 4 + i] = a1;
+         coef[1 * 4 + i] = c1;
+         coef[2 * 4 + i] = d1;
+         coef[3 * 4 + i] = b1;
+     }
+     for (i = 0; i < 4; i++) {
+         int a1 = coef[i * 4 + 0];
+         int b1 = coef[i * 4 + 1];
+         int c1 = coef[i * 4 + 2];
+         int d1 = coef[i * 4 + 3];
+         int e1;
+         a1 += b1;
+         d1 -= c1;
+         e1 = (a1 - d1) >> 1;
+         b1 = e1 - b1;
+         c1 = e1 - c1;
+         a1 -= c1;
+         d1 += b1;
+         coef[i * 4 + 0] = a1 * 2;
+         coef[i * 4 + 1] = c1 * 2;
+         coef[i * 4 + 2] = d1 * 2;
+         coef[i * 4 + 3] = b1 * 2;
+     }
+ }
+ 
+ static void check_idct(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, coef, [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, subcoef0, [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, subcoef1, [4 * 4]);
+     VP8DSPContext d;
+     int dc;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t *block, ptrdiff_t stride);
+ 
+     ff_vp8dsp_init(&d);
+     randomize_buffers(src, dst, 4, coef);
+ 
+     dct4x4(coef);
+ 
+     for (dc = 0; dc <= 1; dc++) {
+         void (*idct)(uint8_t *, int16_t *, ptrdiff_t) = dc ? d.vp8_idct_dc_add : d.vp8_idct_add;
+ 
+         if (check_func(idct, "vp8_idct_%sadd", dc ? "dc_" : "")) {
+             if (dc) {
+                 memset(subcoef0, 0, 4 * 4 * sizeof(int16_t));
+                 subcoef0[0] = coef[0];
+             } else {
+                 memcpy(subcoef0, coef, 4 * 4 * sizeof(int16_t));
+             }
+             memcpy(dst0, dst, 4 * 4);
+             memcpy(dst1, dst, 4 * 4);
+             memcpy(subcoef1, subcoef0, 4 * 4 * sizeof(int16_t));
+             // Note, this uses a pixel stride of 4, even though the real decoder uses a stride as a
+             // multiple of 16. If optimizations want to take advantage of that, this test needs to be
+             // updated to make it more like the h264dsp tests.
+             call_ref(dst0, subcoef0, 4);
+             call_new(dst1, subcoef1, 4);
+             if (memcmp(dst0, dst1, 4 * 4) ||
+                 memcmp(subcoef0, subcoef1, 4 * 4 * sizeof(int16_t)))
+                 fail();
+ 
+             bench_new(dst1, subcoef1, 4);
+         }
+     }
+ }
+ 
+ static void check_idct_dc4(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, src,  [4 * 4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst,  [4 * 4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst0, [4 * 4 * 4]);
+     LOCAL_ALIGNED_16(uint8_t, dst1, [4 * 4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, coef, [4], [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, subcoef0, [4], [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, subcoef1, [4], [4 * 4]);
+     VP8DSPContext d;
+     int i, chroma;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);
+ 
+     ff_vp8dsp_init(&d);
+ 
+     for (chroma = 0; chroma <= 1; chroma++) {
+         void (*idct4dc)(uint8_t *, int16_t[4][16], ptrdiff_t) = chroma ? d.vp8_idct_dc_add4uv : d.vp8_idct_dc_add4y;
+         if (check_func(idct4dc, "vp8_idct_dc_add4%s", chroma ? "uv" : "y")) {
+             int stride = chroma ? 8 : 16;
+             int w      = chroma ? 2 : 4;
+             for (i = 0; i < 4; i++) {
+                 int blockx = 4 * (i % w);
+                 int blocky = 4 * (i / w);
+                 randomize_buffers(src + stride * blocky + blockx, dst + stride * blocky + blockx, stride, coef[i]);
+                 dct4x4(coef[i]);
+                 memset(&coef[i][1], 0, 15 * sizeof(int16_t));
+             }
+ 
+             memcpy(dst0, dst, 4 * 4 * 4);
+             memcpy(dst1, dst, 4 * 4 * 4);
+             memcpy(subcoef0, coef, 4 * 4 * 4 * sizeof(int16_t));
+             memcpy(subcoef1, coef, 4 * 4 * 4 * sizeof(int16_t));
+             call_ref(dst0, subcoef0, stride);
+             call_new(dst1, subcoef1, stride);
+             if (memcmp(dst0, dst1, 4 * 4 * 4) ||
+                 memcmp(subcoef0, subcoef1, 4 * 4 * 4 * sizeof(int16_t)))
+                 fail();
+             bench_new(dst1, subcoef1, stride);
+         }
+     }
+ 
+ }
+ 
+ static void check_luma_dc_wht(void)
+ {
+     LOCAL_ALIGNED_16(int16_t, dc, [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, dc0, [4 * 4]);
+     LOCAL_ALIGNED_16(int16_t, dc1, [4 * 4]);
+     int16_t block[4][4][16];
+     LOCAL_ALIGNED_16(int16_t, block0, [4], [4][16]);
+     LOCAL_ALIGNED_16(int16_t, block1, [4], [4][16]);
+     VP8DSPContext d;
+     int dc_only;
+     int blockx, blocky;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, int16_t block[4][4][16], int16_t dc[16]);
+ 
+     ff_vp8dsp_init(&d);
+ 
+     for (blocky = 0; blocky < 4; blocky++) {
+         for (blockx = 0; blockx < 4; blockx++) {
+             uint8_t src[16], dst[16];
+             randomize_buffers(src, dst, 4, block[blocky][blockx]);
+ 
+             dct4x4(block[blocky][blockx]);
+             dc[blocky * 4 + blockx] = block[blocky][blockx][0];
+             block[blocky][blockx][0] = rnd();
+         }
+     }
+     wht4x4(dc);
+ 
+     for (dc_only = 0; dc_only <= 1; dc_only++) {
+         void (*idct)(int16_t [4][4][16], int16_t [16]) = dc_only ? d.vp8_luma_dc_wht_dc : d.vp8_luma_dc_wht;
+ 
+         if (check_func(idct, "vp8_luma_dc_wht%s", dc_only ? "_dc" : "")) {
+             if (dc_only) {
+                 memset(dc0, 0, 16 * sizeof(int16_t));
+                 dc0[0] = dc[0];
+             } else {
+                 memcpy(dc0, dc, 16 * sizeof(int16_t));
+             }
+             memcpy(dc1, dc0, 16 * sizeof(int16_t));
+             memcpy(block0, block, 4 * 4 * 16 * sizeof(int16_t));
+             memcpy(block1, block, 4 * 4 * 16 * sizeof(int16_t));
+             call_ref(block0, dc0);
+             call_new(block1, dc1);
+             if (memcmp(block0, block1, 4 * 4 * 16 * sizeof(int16_t)) ||
+                 memcmp(dc0, dc1, 16 * sizeof(int16_t)))
+                 fail();
+             bench_new(block1, dc1);
+         }
+     }
+ }
+ 
+ #define SRC_BUF_STRIDE 32
+ #define SRC_BUF_SIZE ((size + 5) * SRC_BUF_STRIDE)
+ // The mc subpixel interpolation filter needs the 2 previous pixels in either
+ // direction, the +1 is to make sure the actual load addresses always are
+ // unaligned.
+ #define src (buf + 2 * SRC_BUF_STRIDE + 2 + 1)
+ 
+ #undef randomize_buffers
+ #define randomize_buffers()                               \
+     do {                                                  \
+         int k;                                            \
+         for (k = 0; k < SRC_BUF_SIZE; k += 4) {           \
+             AV_WN32A(buf + k, rnd());                     \
+         }                                                 \
+     } while (0)
+ 
+ static void check_mc(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, buf, [32 * 32]);
+     LOCAL_ALIGNED_16(uint8_t, dst0, [16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, dst1, [16 * 16]);
+     VP8DSPContext d;
+     int type, hsize, dx, dy;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, uint8_t *, ptrdiff_t, int, int, int);
+ 
+     ff_vp78dsp_init(&d);
+ 
+     for (type = 0; type < 2; type++) {
+         vp8_mc_func (*tab)[3][3] = type ? d.put_vp8_bilinear_pixels_tab : d.put_vp8_epel_pixels_tab;
+         for (hsize = 0; hsize < 3; hsize++) {
+             int size = 16 >> hsize;
+             for (dy = 0; dy < 3; dy++) {
+                 for (dx = 0; dx < 3; dx++) {
+                     char str[100];
+                     if (dx || dy) {
+                         if (type == 0) {
+                             static const char *dx_names[] = { "", "h4", "h6" };
+                             static const char *dy_names[] = { "", "v4", "v6" };
+                             snprintf(str, sizeof(str), "epel%d_%s%s", size, dx_names[dx], dy_names[dy]);
+                         } else {
+                             snprintf(str, sizeof(str), "bilin%d_%s%s", size, dx ? "h" : "", dy ? "v" : "");
+                         }
+                     } else {
+                         snprintf(str, sizeof(str), "pixels%d", size);
+                     }
+                     if (check_func(tab[hsize][dy][dx], "vp8_put_%s", str)) {
+                         int mx, my;
+                         int i;
+                         if (type == 0) {
+                             mx = dx == 2 ? 2 + 2 * (rnd() % 3) : dx == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                             my = dy == 2 ? 2 + 2 * (rnd() % 3) : dy == 1 ? 1 + 2 * (rnd() % 4) : 0;
+                         } else {
+                             mx = dx ? 1 + (rnd() % 7) : 0;
+                             my = dy ? 1 + (rnd() % 7) : 0;
+                         }
+                         randomize_buffers();
+                         for (i = -2; i <= 3; i++) {
+                             int val = (i == -1 || i == 2) ? 0 : 0xff;
+                             // Set pixels in the first row and column to the maximum pattern,
+                             // to test for potential overflows in the filter.
+                             src[i                 ] = val;
+                             src[i * SRC_BUF_STRIDE] = val;
+                         }
+                         call_ref(dst0, size, src, SRC_BUF_STRIDE, size, mx, my);
+                         call_new(dst1, size, src, SRC_BUF_STRIDE, size, mx, my);
+                         if (memcmp(dst0, dst1, size * size))
+                             fail();
+                         bench_new(dst1, size, src, SRC_BUF_STRIDE, size, mx, my);
+                     }
+                 }
+             }
+         }
+     }
+ }
+ 
+ #undef randomize_buffers
+ 
+ #define setpx(a, b, c) buf[(a) + (b) * jstride] = av_clip_uint8(c)
+ // Set the pixel to c +/- [0,d]
+ #define setdx(a, b, c, d) setpx(a, b, c - (d) + (rnd() % ((d) * 2 + 1)))
+ // Set the pixel to c +/- [d,d+e] (making sure it won't be clipped)
+ #define setdx2(a, b, o, c, d, e) setpx(a, b, o = c + ((d) + (rnd() % (e))) * (c >= 128 ? -1 : 1))
+ 
+ static void randomize_loopfilter_buffers(int lineoff, int str,
+                                          int dir, int flim_E, int flim_I,
+                                          int hev_thresh, uint8_t *buf,
+                                          int force_hev)
+ {
+     uint32_t mask = 0xff;
+     int off = dir ? lineoff : lineoff * str;
+     int istride = dir ? 1 : str;
+     int jstride = dir ? str : 1;
+     int i;
+     for (i = 0; i < 8; i += 2) {
+         // Row 0 will trigger hev for q0/q1, row 2 will trigger hev for p0/p1,
+         // rows 4 and 6 will not trigger hev.
+         // force_hev 1 will make sure all rows trigger hev, while force_hev -1
+         // makes none of them trigger it.
+         int idx = off + i * istride, p2, p1, p0, q0, q1, q2;
+         setpx(idx,  0, q0 = rnd() & mask);
+         if (i == 0 && force_hev >= 0 || force_hev > 0)
+             setdx2(idx, 1, q1, q0, hev_thresh + 1, flim_I - hev_thresh - 1);
+         else
+             setdx(idx,  1, q1 = q0, hev_thresh);
+         setdx(idx,  2, q2 = q1, flim_I);
+         setdx(idx,  3, q2,      flim_I);
+         setdx(idx, -1, p0 = q0, flim_E >> 2);
+         if (i == 2 && force_hev >= 0 || force_hev > 0)
+             setdx2(idx, -2, p1, p0, hev_thresh + 1, flim_I - hev_thresh - 1);
+         else
+             setdx(idx, -2, p1 = p0, hev_thresh);
+         setdx(idx, -3, p2 = p1, flim_I);
+         setdx(idx, -4, p2,      flim_I);
+     }
+ }
+ 
+ // Fill the buffer with random pixels
+ static void fill_loopfilter_buffers(uint8_t *buf, int stride, int w, int h)
+ {
+     int x, y;
+     for (y = 0; y < h; y++)
+         for (x = 0; x < w; x++)
+             buf[y * stride + x] = rnd() & 0xff;
+ }
+ 
+ #define randomize_buffers(buf, lineoff, str, force_hev) \
+     randomize_loopfilter_buffers(lineoff, str, dir, flim_E, flim_I, hev_thresh, buf, force_hev)
+ 
+ static void check_loopfilter_16y(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+     VP8DSPContext d;
+     int dir, edge, force_hev;
+     int flim_E = 20, flim_I = 10, hev_thresh = 7;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int, int, int);
+ 
+     ff_vp8dsp_init(&d);
+ 
+     for (dir = 0; dir < 2; dir++) {
+         int midoff = dir ? 4 * 16 : 4;
+         int midoff_aligned = dir ? 4 * 16 : 16;
+         uint8_t *buf0 = base0 + midoff_aligned;
+         uint8_t *buf1 = base1 + midoff_aligned;
+         for (edge = 0; edge < 2; edge++) {
+             void (*func)(uint8_t *, ptrdiff_t, int, int, int) = NULL;
+             switch (dir << 1 | edge) {
+             case (0 << 1) | 0: func = d.vp8_h_loop_filter16y; break;
+             case (1 << 1) | 0: func = d.vp8_v_loop_filter16y; break;
+             case (0 << 1) | 1: func = d.vp8_h_loop_filter16y_inner; break;
+             case (1 << 1) | 1: func = d.vp8_v_loop_filter16y_inner; break;
+             }
+             if (check_func(func, "vp8_loop_filter16y%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                 for (force_hev = -1; force_hev <= 1; force_hev++) {
+                     fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                     randomize_buffers(buf0, 0, 16, force_hev);
+                     randomize_buffers(buf0, 8, 16, force_hev);
+                     memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+                     call_ref(buf0, 16, flim_E, flim_I, hev_thresh);
+                     call_new(buf1, 16, flim_E, flim_I, hev_thresh);
+                     if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                         fail();
+                 }
+                 fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+                 randomize_buffers(buf0, 0, 16, 0);
+                 randomize_buffers(buf0, 8, 16, 0);
+                 bench_new(buf0, 16, flim_E, flim_I, hev_thresh);
+             }
+         }
+     }
+ }
+ 
+ static void check_loopfilter_8uv(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, base0u, [32 + 16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, base0v, [32 + 16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, base1u, [32 + 16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, base1v, [32 + 16 * 16]);
+     VP8DSPContext d;
+     int dir, edge, force_hev;
+     int flim_E = 20, flim_I = 10, hev_thresh = 7;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, uint8_t *, ptrdiff_t, int, int, int);
+ 
+     ff_vp8dsp_init(&d);
+ 
+     for (dir = 0; dir < 2; dir++) {
+         int midoff = dir ? 4 * 16 : 4;
+         int midoff_aligned = dir ? 4 * 16 : 16;
+         uint8_t *buf0u = base0u + midoff_aligned;
+         uint8_t *buf0v = base0v + midoff_aligned;
+         uint8_t *buf1u = base1u + midoff_aligned;
+         uint8_t *buf1v = base1v + midoff_aligned;
+         for (edge = 0; edge < 2; edge++) {
+             void (*func)(uint8_t *, uint8_t *, ptrdiff_t, int, int, int) = NULL;
+             switch (dir << 1 | edge) {
+             case (0 << 1) | 0: func = d.vp8_h_loop_filter8uv; break;
+             case (1 << 1) | 0: func = d.vp8_v_loop_filter8uv; break;
+             case (0 << 1) | 1: func = d.vp8_h_loop_filter8uv_inner; break;
+             case (1 << 1) | 1: func = d.vp8_v_loop_filter8uv_inner; break;
+             }
+             if (check_func(func, "vp8_loop_filter8uv%s_%s", edge ? "_inner" : "", dir ? "v" : "h")) {
+                 for (force_hev = -1; force_hev <= 1; force_hev++) {
+                     fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                     fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                     randomize_buffers(buf0u, 0, 16, force_hev);
+                     randomize_buffers(buf0v, 0, 16, force_hev);
+                     memcpy(buf1u - midoff, buf0u - midoff, 16 * 16);
+                     memcpy(buf1v - midoff, buf0v - midoff, 16 * 16);
+ 
+                     call_ref(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+                     call_new(buf1u, buf1v, 16, flim_E, flim_I, hev_thresh);
+                     if (memcmp(buf0u - midoff, buf1u - midoff, 16 * 16) ||
+                         memcmp(buf0v - midoff, buf1v - midoff, 16 * 16))
+                         fail();
+                 }
+                 fill_loopfilter_buffers(buf0u - midoff, 16, 16, 16);
+                 fill_loopfilter_buffers(buf0v - midoff, 16, 16, 16);
+                 randomize_buffers(buf0u, 0, 16, 0);
+                 randomize_buffers(buf0v, 0, 16, 0);
+                 bench_new(buf0u, buf0v, 16, flim_E, flim_I, hev_thresh);
+             }
+         }
+     }
+ }
+ 
+ static void check_loopfilter_simple(void)
+ {
+     LOCAL_ALIGNED_16(uint8_t, base0, [32 + 16 * 16]);
+     LOCAL_ALIGNED_16(uint8_t, base1, [32 + 16 * 16]);
+     VP8DSPContext d;
+     int dir;
+     int flim_E = 20, flim_I = 30, hev_thresh = 0;
+     declare_func_emms(AV_CPU_FLAG_MMX, void, uint8_t *, ptrdiff_t, int);
+ 
+     ff_vp8dsp_init(&d);
+ 
+     for (dir = 0; dir < 2; dir++) {
+         int midoff = dir ? 4 * 16 : 4;
+         int midoff_aligned = dir ? 4 * 16 : 16;
+         uint8_t *buf0 = base0 + midoff_aligned;
+         uint8_t *buf1 = base1 + midoff_aligned;
+         void (*func)(uint8_t *, ptrdiff_t, int) = dir ? d.vp8_v_loop_filter_simple : d.vp8_h_loop_filter_simple;
+         if (check_func(func, "vp8_loop_filter_simple_%s", dir ? "v" : "h")) {
+             fill_loopfilter_buffers(buf0 - midoff, 16, 16, 16);
+             randomize_buffers(buf0, 0, 16, -1);
+             randomize_buffers(buf0, 8, 16, -1);
+             memcpy(buf1 - midoff, buf0 - midoff, 16 * 16);
+             call_ref(buf0, 16, flim_E);
+             call_new(buf1, 16, flim_E);
+             if (memcmp(buf0 - midoff, buf1 - midoff, 16 * 16))
+                 fail();
+             bench_new(buf0, 16, flim_E);
+         }
+     }
+ }
+ 
+ void checkasm_check_vp8dsp(void)
+ {
+     check_idct();
+     check_idct_dc4();
+     check_luma_dc_wht();
+     report("idct");
+     check_mc();
+     report("mc");
+     check_loopfilter_16y();
+     check_loopfilter_8uv();
+     check_loopfilter_simple();
+     report("loopfilter");
+ }



More information about the ffmpeg-cvslog mailing list