pngdec: decode and expose iCCP chunks as side data
[ffmpeg.git] / libavcodec / vp8dsp.c
index eec48ca..fed5c67 100644 (file)
 #include "mathops.h"
 #include "vp8dsp.h"
 
-#define MK_IDCT_DC_ADD4_C(name) \
-static void name ## _idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)\
-{\
-    name ## _idct_dc_add_c(dst + stride * 0 + 0, block[0], stride);\
-    name ## _idct_dc_add_c(dst + stride * 0 + 4, block[1], stride);\
-    name ## _idct_dc_add_c(dst + stride * 4 + 0, block[2], stride);\
-    name ## _idct_dc_add_c(dst + stride * 4 + 4, block[3], stride);\
-}\
-\
-static void name ## _idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride)\
-{\
-    name ## _idct_dc_add_c(dst + 0, block[0], stride);\
-    name ## _idct_dc_add_c(dst + 4, block[1], stride);\
-    name ## _idct_dc_add_c(dst + 8, block[2], stride);\
-    name ## _idct_dc_add_c(dst + 12, block[3], stride);\
+#define MK_IDCT_DC_ADD4_C(name)                                               \
+static void name ## _idct_dc_add4uv_c(uint8_t *dst, int16_t block[4][16],     \
+                                      ptrdiff_t stride)                       \
+{                                                                             \
+    name ## _idct_dc_add_c(dst + stride * 0 + 0, block[0], stride);           \
+    name ## _idct_dc_add_c(dst + stride * 0 + 4, block[1], stride);           \
+    name ## _idct_dc_add_c(dst + stride * 4 + 0, block[2], stride);           \
+    name ## _idct_dc_add_c(dst + stride * 4 + 4, block[3], stride);           \
+}                                                                             \
+                                                                              \
+static void name ## _idct_dc_add4y_c(uint8_t *dst, int16_t block[4][16],      \
+                                     ptrdiff_t stride)                        \
+{                                                                             \
+    name ## _idct_dc_add_c(dst +  0, block[0], stride);                       \
+    name ## _idct_dc_add_c(dst +  4, block[1], stride);                       \
+    name ## _idct_dc_add_c(dst +  8, block[2], stride);                       \
+    name ## _idct_dc_add_c(dst + 12, block[3], stride);                       \
 }
 
 #if CONFIG_VP7_DECODER
 static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
 {
-    int i, a1, b1, c1, d1;
+    int i;
+    unsigned a1, b1, c1, d1;
     int16_t tmp[16];
 
     for (i = 0; i < 4; i++) {
@@ -59,10 +62,10 @@ static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
         b1 = (dc[i * 4 + 0] - dc[i * 4 + 2]) * 23170;
         c1 = dc[i * 4 + 1] * 12540 - dc[i * 4 + 3] * 30274;
         d1 = dc[i * 4 + 1] * 30274 + dc[i * 4 + 3] * 12540;
-        tmp[i * 4 + 0] = (a1 + d1) >> 14;
-        tmp[i * 4 + 3] = (a1 - d1) >> 14;
-        tmp[i * 4 + 1] = (b1 + c1) >> 14;
-        tmp[i * 4 + 2] = (b1 - c1) >> 14;
+        tmp[i * 4 + 0] = (int)(a1 + d1) >> 14;
+        tmp[i * 4 + 3] = (int)(a1 - d1) >> 14;
+        tmp[i * 4 + 1] = (int)(b1 + c1) >> 14;
+        tmp[i * 4 + 2] = (int)(b1 - c1) >> 14;
     }
 
     for (i = 0; i < 4; i++) {
@@ -71,10 +74,10 @@ static void vp7_luma_dc_wht_c(int16_t block[4][4][16], int16_t dc[16])
         c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
         d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
         AV_ZERO64(dc + i * 4);
-        block[0][i][0] = (a1 + d1 + 0x20000) >> 18;
-        block[3][i][0] = (a1 - d1 + 0x20000) >> 18;
-        block[1][i][0] = (b1 + c1 + 0x20000) >> 18;
-        block[2][i][0] = (b1 - c1 + 0x20000) >> 18;
+        block[0][i][0] = (int)(a1 + d1 + 0x20000) >> 18;
+        block[3][i][0] = (int)(a1 - d1 + 0x20000) >> 18;
+        block[1][i][0] = (int)(b1 + c1 + 0x20000) >> 18;
+        block[2][i][0] = (int)(b1 - c1 + 0x20000) >> 18;
     }
 }
 
@@ -93,7 +96,8 @@ static void vp7_luma_dc_wht_dc_c(int16_t block[4][4][16], int16_t dc[16])
 
 static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 {
-    int i, a1, b1, c1, d1;
+    int i;
+    unsigned a1, b1, c1, d1;
     int16_t tmp[16];
 
     for (i = 0; i < 4; i++) {
@@ -102,10 +106,10 @@ static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
         c1 = block[i * 4 + 1] * 12540 - block[i * 4 + 3] * 30274;
         d1 = block[i * 4 + 1] * 30274 + block[i * 4 + 3] * 12540;
         AV_ZERO64(block + i * 4);
-        tmp[i * 4 + 0] = (a1 + d1) >> 14;
-        tmp[i * 4 + 3] = (a1 - d1) >> 14;
-        tmp[i * 4 + 1] = (b1 + c1) >> 14;
-        tmp[i * 4 + 2] = (b1 - c1) >> 14;
+        tmp[i * 4 + 0] = (int)(a1 + d1) >> 14;
+        tmp[i * 4 + 3] = (int)(a1 - d1) >> 14;
+        tmp[i * 4 + 1] = (int)(b1 + c1) >> 14;
+        tmp[i * 4 + 2] = (int)(b1 - c1) >> 14;
     }
 
     for (i = 0; i < 4; i++) {
@@ -113,10 +117,14 @@ static void vp7_idct_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
         b1 = (tmp[i + 0] - tmp[i + 8]) * 23170;
         c1 = tmp[i + 4] * 12540 - tmp[i + 12] * 30274;
         d1 = tmp[i + 4] * 30274 + tmp[i + 12] * 12540;
-        dst[0 * stride + i] = av_clip_uint8(dst[0 * stride + i] + ((a1 + d1 + 0x20000) >> 18));
-        dst[3 * stride + i] = av_clip_uint8(dst[3 * stride + i] + ((a1 - d1 + 0x20000) >> 18));
-        dst[1 * stride + i] = av_clip_uint8(dst[1 * stride + i] + ((b1 + c1 + 0x20000) >> 18));
-        dst[2 * stride + i] = av_clip_uint8(dst[2 * stride + i] + ((b1 - c1 + 0x20000) >> 18));
+        dst[0 * stride + i] = av_clip_uint8(dst[0 * stride + i] +
+                                            ((int)(a1 + d1 + 0x20000) >> 18));
+        dst[3 * stride + i] = av_clip_uint8(dst[3 * stride + i] +
+                                            ((int)(a1 - d1 + 0x20000) >> 18));
+        dst[1 * stride + i] = av_clip_uint8(dst[1 * stride + i] +
+                                            ((int)(b1 + c1 + 0x20000) >> 18));
+        dst[2 * stride + i] = av_clip_uint8(dst[2 * stride + i] +
+                                            ((int)(b1 - c1 + 0x20000) >> 18));
     }
 }
 
@@ -130,12 +138,12 @@ static void vp7_idct_dc_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
         dst[1] = av_clip_uint8(dst[1] + dc);
         dst[2] = av_clip_uint8(dst[2] + dc);
         dst[3] = av_clip_uint8(dst[3] + dc);
-        dst += stride;
+        dst   += stride;
     }
 }
 
 MK_IDCT_DC_ADD4_C(vp7)
-#endif
+#endif /* CONFIG_VP7_DECODER */
 
 // TODO: Maybe add dequant
 #if CONFIG_VP8_DECODER
@@ -235,7 +243,7 @@ static void vp8_idct_dc_add_c(uint8_t *dst, int16_t block[16], ptrdiff_t stride)
 }
 
 MK_IDCT_DC_ADD4_C(vp8)
-#endif
+#endif /* CONFIG_VP8_DECODER */
 
 // because I like only having two parameters to pass functions...
 #define LOAD_PIXELS                                                           \
@@ -248,10 +256,10 @@ MK_IDCT_DC_ADD4_C(vp8)
     int av_unused q2 = p[ 2 * stride];                                        \
     int av_unused q3 = p[ 3 * stride];
 
-#define clip_int8(n) (cm[n + 0x80] - 0x80)
+#define clip_int8(n) (cm[(n) + 0x80] - 0x80)
 
 static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride,
-                                           int is4tap, int vpn)
+                                           int is4tap, int is_vp7)
 {
     LOAD_PIXELS
     int a, f1, f2;
@@ -268,7 +276,7 @@ static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride,
     // since that's what libvpx does.
     f1 = FFMIN(a + 4, 127) >> 3;
 
-    if (vpn == 7)
+    if (is_vp7)
         f2 = f1 - ((a & 7) == 4);
     else
         f2 = FFMIN(a + 3, 127) >> 3;
@@ -280,19 +288,33 @@ static av_always_inline void filter_common(uint8_t *p, ptrdiff_t stride,
 
     // only used for _inner on blocks without high edge variance
     if (!is4tap) {
-        a = (f1 + 1) >> 1;
+        a              = (f1 + 1) >> 1;
         p[-2 * stride] = cm[p1 + a];
         p[ 1 * stride] = cm[q1 - a];
     }
 }
 
-static av_always_inline int vp7_simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
+static av_always_inline void vp7_filter_common(uint8_t *p, ptrdiff_t stride,
+                                               int is4tap)
+{
+    filter_common(p, stride, is4tap, IS_VP7);
+}
+
+static av_always_inline void vp8_filter_common(uint8_t *p, ptrdiff_t stride,
+                                               int is4tap)
+{
+    filter_common(p, stride, is4tap, IS_VP8);
+}
+
+static av_always_inline int vp7_simple_limit(uint8_t *p, ptrdiff_t stride,
+                                             int flim)
 {
     LOAD_PIXELS
-    return FFABS(p0-q0) <= flim;
+    return FFABS(p0 - q0) <= flim;
 }
 
-static av_always_inline int vp8_simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
+static av_always_inline int vp8_simple_limit(uint8_t *p, ptrdiff_t stride,
+                                             int flim)
 {
     LOAD_PIXELS
     return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
@@ -302,18 +324,16 @@ static av_always_inline int vp8_simple_limit(uint8_t *p, ptrdiff_t stride, int f
  * E - limit at the macroblock edge
  * I - limit for interior difference
  */
-#define NORMAL_LIMIT(vpn) \
-static av_always_inline int vp ## vpn ## _normal_limit(uint8_t *p, ptrdiff_t stride, \
-                                                       int E, int I)\
-{                                                      \
-    LOAD_PIXELS                                        \
-    return vp ## vpn ## _simple_limit(p, stride, E) && \
-           FFABS(p3 - p2) <= I &&                      \
-           FFABS(p2 - p1) <= I &&                      \
-           FFABS(p1 - p0) <= I &&                      \
-           FFABS(q3 - q2) <= I &&                      \
-           FFABS(q2 - q1) <= I &&                      \
-           FFABS(q1 - q0) <= I;                        \
+#define NORMAL_LIMIT(vpn)                                                     \
+static av_always_inline int vp ## vpn ## _normal_limit(uint8_t *p,            \
+                                                       ptrdiff_t stride,      \
+                                                       int E, int I)          \
+{                                                                             \
+    LOAD_PIXELS                                                               \
+    return vp ## vpn ## _simple_limit(p, stride, E) &&                        \
+           FFABS(p3 - p2) <= I && FFABS(p2 - p1) <= I &&                      \
+           FFABS(p1 - p0) <= I && FFABS(q3 - q2) <= I &&                      \
+           FFABS(q2 - q1) <= I && FFABS(q1 - q0) <= I;                        \
 }
 
 NORMAL_LIMIT(7)
@@ -350,90 +370,89 @@ static av_always_inline void filter_mbedge(uint8_t *p, ptrdiff_t stride)
 
 #define LOOP_FILTER(vpn, dir, size, stridea, strideb, maybe_inline)           \
 static maybe_inline                                                           \
-void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _c(uint8_t *dst,        \
-                                               ptrdiff_t stride,              \
-                                               int flim_E, int flim_I,        \
-                                               int hev_thresh)                \
+void vpn ## _ ## dir ## _loop_filter ## size ## _c(uint8_t *dst,              \
+                                                   ptrdiff_t stride,          \
+                                                   int flim_E, int flim_I,    \
+                                                   int hev_thresh)            \
 {                                                                             \
     int i;                                                                    \
     for (i = 0; i < size; i++)                                                \
-        if (vp ## vpn ## _normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
+        if (vpn ## _normal_limit(dst + i * stridea, strideb,                  \
+                                 flim_E, flim_I)) {                           \
             if (hev(dst + i * stridea, strideb, hev_thresh))                  \
-                filter_common(dst + i * stridea, strideb, 1, vpn);            \
+                vpn ## _filter_common(dst + i * stridea, strideb, 1);         \
             else                                                              \
                 filter_mbedge(dst + i * stridea, strideb);                    \
         }                                                                     \
 }                                                                             \
                                                                               \
 static maybe_inline                                                           \
-void vp ## vpn ## _ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst,  \
-                                                     ptrdiff_t stride,        \
-                                                     int flim_E, int flim_I,  \
-                                                     int hev_thresh)          \
+void vpn ## _ ## dir ## _loop_filter ## size ## _inner_c(uint8_t *dst,        \
+                                                         ptrdiff_t stride,    \
+                                                         int flim_E,          \
+                                                         int flim_I,          \
+                                                         int hev_thresh)      \
 {                                                                             \
     int i;                                                                    \
     for (i = 0; i < size; i++)                                                \
-        if (vp ## vpn ## _normal_limit(dst + i * stridea, strideb, flim_E, flim_I)) {       \
+        if (vpn ## _normal_limit(dst + i * stridea, strideb,                  \
+                                 flim_E, flim_I)) {                           \
             int hv = hev(dst + i * stridea, strideb, hev_thresh);             \
             if (hv)                                                           \
-                filter_common(dst + i * stridea, strideb, 1, vpn);            \
+                vpn ## _filter_common(dst + i * stridea, strideb, 1);         \
             else                                                              \
-                filter_common(dst + i * stridea, strideb, 0, vpn);            \
+                vpn ## _filter_common(dst + i * stridea, strideb, 0);         \
         }                                                                     \
 }
 
-#define UV_LOOP_FILTER(vpn, dir, stridea, strideb) \
-LOOP_FILTER(vpn, dir, 8, stridea, strideb, av_always_inline) \
-static void vp ## vpn ## _ ## dir ## _loop_filter8uv_c(uint8_t *dstU, uint8_t *dstV, \
-                                                       ptrdiff_t stride, int fE, \
-                                                       int fI, int hev_thresh)\
-{\
-  vp ## vpn ## _ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh);\
-  vp ## vpn ## _ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh);\
-}\
-static void vp ## vpn ## _ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU, \
-                                                             uint8_t *dstV, \
-                                                             ptrdiff_t stride, int fE, \
-                                                             int fI, int hev_thresh) \
-{\
-  vp ## vpn ## _ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI, hev_thresh);\
-  vp ## vpn ## _ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI, hev_thresh);\
+#define UV_LOOP_FILTER(vpn, dir, stridea, strideb)                            \
+LOOP_FILTER(vpn, dir, 8, stridea, strideb, av_always_inline)                  \
+static void vpn ## _ ## dir ## _loop_filter8uv_c(uint8_t *dstU,               \
+                                                 uint8_t *dstV,               \
+                                                 ptrdiff_t stride, int fE,    \
+                                                 int fI, int hev_thresh)      \
+{                                                                             \
+    vpn ## _ ## dir ## _loop_filter8_c(dstU, stride, fE, fI, hev_thresh);     \
+    vpn ## _ ## dir ## _loop_filter8_c(dstV, stride, fE, fI, hev_thresh);     \
+}                                                                             \
+                                                                              \
+static void vpn ## _ ## dir ## _loop_filter8uv_inner_c(uint8_t *dstU,         \
+                                                       uint8_t *dstV,         \
+                                                       ptrdiff_t stride,      \
+                                                       int fE, int fI,        \
+                                                       int hev_thresh)        \
+{                                                                             \
+    vpn ## _ ## dir ## _loop_filter8_inner_c(dstU, stride, fE, fI,            \
+                                             hev_thresh);                     \
+    vpn ## _ ## dir ## _loop_filter8_inner_c(dstV, stride, fE, fI,            \
+                                             hev_thresh);                     \
 }
 
-#define LOOP_FILTER_SIMPLE(vpn) \
-static void vp ## vpn ## _v_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)\
-{\
-    int i;\
-\
-    for (i = 0; i < 16; i++)\
-        if (vp ## vpn ## _simple_limit(dst + i, stride, flim))\
-            filter_common(dst + i, stride, 1, vpn);\
-}\
-\
-static void vp ## vpn ## _h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride, int flim)\
-{\
-    int i;\
-\
-    for (i = 0; i < 16; i++)\
-        if (vp ## vpn ## _simple_limit(dst + i * stride, 1, flim))\
-            filter_common(dst + i * stride, 1, 1, vpn);\
+#define LOOP_FILTER_SIMPLE(vpn)                                               \
+static void vpn ## _v_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride,    \
+                                           int flim)                          \
+{                                                                             \
+    int i;                                                                    \
+    for (i = 0; i < 16; i++)                                                  \
+        if (vpn ## _simple_limit(dst + i, stride, flim))                      \
+            vpn ## _filter_common(dst + i, stride, 1);                        \
+}                                                                             \
+                                                                              \
+static void vpn ## _h_loop_filter_simple_c(uint8_t *dst, ptrdiff_t stride,    \
+                                           int flim)                          \
+{                                                                             \
+    int i;                                                                    \
+    for (i = 0; i < 16; i++)                                                  \
+        if (vpn ## _simple_limit(dst + i * stride, 1, flim))                  \
+            vpn ## _filter_common(dst + i * stride, 1, 1);                    \
 }
 
-#if CONFIG_VP7_DECODER
-LOOP_FILTER(7, v, 16, 1, stride,)
-LOOP_FILTER(7, h, 16, stride, 1,)
-UV_LOOP_FILTER(7, v, 1, stride)
-UV_LOOP_FILTER(7, h, stride, 1)
-LOOP_FILTER_SIMPLE(7)
-#endif
-
-#if CONFIG_VP8_DECODER
-LOOP_FILTER(8, v, 16, 1, stride,)
-LOOP_FILTER(8, h, 16, stride, 1,)
-UV_LOOP_FILTER(8, v, 1, stride)
-UV_LOOP_FILTER(8, h, stride, 1)
-LOOP_FILTER_SIMPLE(8)
-#endif
+#define LOOP_FILTERS(vpn)                \
+    LOOP_FILTER(vpn, v, 16, 1, stride, ) \
+    LOOP_FILTER(vpn, h, 16, stride, 1, ) \
+    UV_LOOP_FILTER(vpn, v, 1, stride)    \
+    UV_LOOP_FILTER(vpn, h, stride, 1)    \
+    LOOP_FILTER_SIMPLE(vpn)              \
 
 static const uint8_t subpel_filters[7][6] = {
     { 0,  6, 123,  12,  1, 0 },
@@ -622,7 +641,7 @@ VP8_BILINEAR(16)
 VP8_BILINEAR(8)
 VP8_BILINEAR(4)
 
-#define VP8_MC_FUNC(IDX, SIZE)                                                \
+#define VP78_MC_FUNC(IDX, SIZE)                                               \
     dsp->put_vp8_epel_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c;   \
     dsp->put_vp8_epel_pixels_tab[IDX][0][1] = put_vp8_epel ## SIZE ## _h4_c;  \
     dsp->put_vp8_epel_pixels_tab[IDX][0][2] = put_vp8_epel ## SIZE ## _h6_c;  \
@@ -633,8 +652,8 @@ VP8_BILINEAR(4)
     dsp->put_vp8_epel_pixels_tab[IDX][2][1] = put_vp8_epel ## SIZE ## _h4v6_c; \
     dsp->put_vp8_epel_pixels_tab[IDX][2][2] = put_vp8_epel ## SIZE ## _h6v6_c
 
-#define VP8_BILINEAR_MC_FUNC(IDX, SIZE)                                       \
-    dsp->put_vp8_bilinear_pixels_tab[IDX][0][0] = put_vp8_pixels ## SIZE ## _c; \
+#define VP78_BILINEAR_MC_FUNC(IDX, SIZE)                                      \
+    dsp->put_vp8_bilinear_pixels_tab[IDX][0][0] = put_vp8_pixels   ## SIZE ## _c; \
     dsp->put_vp8_bilinear_pixels_tab[IDX][0][1] = put_vp8_bilinear ## SIZE ## _h_c; \
     dsp->put_vp8_bilinear_pixels_tab[IDX][0][2] = put_vp8_bilinear ## SIZE ## _h_c; \
     dsp->put_vp8_bilinear_pixels_tab[IDX][1][0] = put_vp8_bilinear ## SIZE ## _v_c; \
@@ -644,48 +663,81 @@ VP8_BILINEAR(4)
     dsp->put_vp8_bilinear_pixels_tab[IDX][2][1] = put_vp8_bilinear ## SIZE ## _hv_c; \
     dsp->put_vp8_bilinear_pixels_tab[IDX][2][2] = put_vp8_bilinear ## SIZE ## _hv_c
 
-av_cold void ff_vp8dsp_init(VP8DSPContext *dsp, int vp7)
+av_cold void ff_vp78dsp_init(VP8DSPContext *dsp)
 {
-#if CONFIG_VP7_DECODER && CONFIG_VP8_DECODER
-#define VPX(f) vp7 ? vp7_ ## f : vp8_ ## f
-#elif CONFIG_VP7_DECODER
-#define VPX(f) vp7_ ## f
-#else // CONFIG_VP8_DECODER
-#define VPX(f) vp8_ ## f
-#endif
-
-    dsp->vp8_luma_dc_wht    = VPX(luma_dc_wht_c);
-    dsp->vp8_luma_dc_wht_dc = VPX(luma_dc_wht_dc_c);
-    dsp->vp8_idct_add       = VPX(idct_add_c);
-    dsp->vp8_idct_dc_add    = VPX(idct_dc_add_c);
-    dsp->vp8_idct_dc_add4y  = VPX(idct_dc_add4y_c);
-    dsp->vp8_idct_dc_add4uv = VPX(idct_dc_add4uv_c);
-
-    dsp->vp8_v_loop_filter16y = VPX(v_loop_filter16_c);
-    dsp->vp8_h_loop_filter16y = VPX(h_loop_filter16_c);
-    dsp->vp8_v_loop_filter8uv = VPX(v_loop_filter8uv_c);
-    dsp->vp8_h_loop_filter8uv = VPX(h_loop_filter8uv_c);
-
-    dsp->vp8_v_loop_filter16y_inner = VPX(v_loop_filter16_inner_c);
-    dsp->vp8_h_loop_filter16y_inner = VPX(h_loop_filter16_inner_c);
-    dsp->vp8_v_loop_filter8uv_inner = VPX(v_loop_filter8uv_inner_c);
-    dsp->vp8_h_loop_filter8uv_inner = VPX(h_loop_filter8uv_inner_c);
-
-    dsp->vp8_v_loop_filter_simple = VPX(v_loop_filter_simple_c);
-    dsp->vp8_h_loop_filter_simple = VPX(h_loop_filter_simple_c);
-
-    VP8_MC_FUNC(0, 16);
-    VP8_MC_FUNC(1, 8);
-    VP8_MC_FUNC(2, 4);
-
-    VP8_BILINEAR_MC_FUNC(0, 16);
-    VP8_BILINEAR_MC_FUNC(1, 8);
-    VP8_BILINEAR_MC_FUNC(2, 4);
+    VP78_MC_FUNC(0, 16);
+    VP78_MC_FUNC(1, 8);
+    VP78_MC_FUNC(2, 4);
+
+    VP78_BILINEAR_MC_FUNC(0, 16);
+    VP78_BILINEAR_MC_FUNC(1, 8);
+    VP78_BILINEAR_MC_FUNC(2, 4);
 
     if (ARCH_ARM)
-        ff_vp8dsp_init_arm(dsp, vp7);
+        ff_vp78dsp_init_arm(dsp);
     if (ARCH_PPC)
-        ff_vp8dsp_init_ppc(dsp);
+        ff_vp78dsp_init_ppc(dsp);
+    if (ARCH_X86)
+        ff_vp78dsp_init_x86(dsp);
+}
+
+#if CONFIG_VP7_DECODER
+LOOP_FILTERS(vp7)
+
+av_cold void ff_vp7dsp_init(VP8DSPContext *dsp)
+{
+    dsp->vp8_luma_dc_wht    = vp7_luma_dc_wht_c;
+    dsp->vp8_luma_dc_wht_dc = vp7_luma_dc_wht_dc_c;
+    dsp->vp8_idct_add       = vp7_idct_add_c;
+    dsp->vp8_idct_dc_add    = vp7_idct_dc_add_c;
+    dsp->vp8_idct_dc_add4y  = vp7_idct_dc_add4y_c;
+    dsp->vp8_idct_dc_add4uv = vp7_idct_dc_add4uv_c;
+
+    dsp->vp8_v_loop_filter16y = vp7_v_loop_filter16_c;
+    dsp->vp8_h_loop_filter16y = vp7_h_loop_filter16_c;
+    dsp->vp8_v_loop_filter8uv = vp7_v_loop_filter8uv_c;
+    dsp->vp8_h_loop_filter8uv = vp7_h_loop_filter8uv_c;
+
+    dsp->vp8_v_loop_filter16y_inner = vp7_v_loop_filter16_inner_c;
+    dsp->vp8_h_loop_filter16y_inner = vp7_h_loop_filter16_inner_c;
+    dsp->vp8_v_loop_filter8uv_inner = vp7_v_loop_filter8uv_inner_c;
+    dsp->vp8_h_loop_filter8uv_inner = vp7_h_loop_filter8uv_inner_c;
+
+    dsp->vp8_v_loop_filter_simple = vp7_v_loop_filter_simple_c;
+    dsp->vp8_h_loop_filter_simple = vp7_h_loop_filter_simple_c;
+}
+#endif /* CONFIG_VP7_DECODER */
+
+#if CONFIG_VP8_DECODER
+LOOP_FILTERS(vp8)
+
+av_cold void ff_vp8dsp_init(VP8DSPContext *dsp)
+{
+    dsp->vp8_luma_dc_wht    = vp8_luma_dc_wht_c;
+    dsp->vp8_luma_dc_wht_dc = vp8_luma_dc_wht_dc_c;
+    dsp->vp8_idct_add       = vp8_idct_add_c;
+    dsp->vp8_idct_dc_add    = vp8_idct_dc_add_c;
+    dsp->vp8_idct_dc_add4y  = vp8_idct_dc_add4y_c;
+    dsp->vp8_idct_dc_add4uv = vp8_idct_dc_add4uv_c;
+
+    dsp->vp8_v_loop_filter16y = vp8_v_loop_filter16_c;
+    dsp->vp8_h_loop_filter16y = vp8_h_loop_filter16_c;
+    dsp->vp8_v_loop_filter8uv = vp8_v_loop_filter8uv_c;
+    dsp->vp8_h_loop_filter8uv = vp8_h_loop_filter8uv_c;
+
+    dsp->vp8_v_loop_filter16y_inner = vp8_v_loop_filter16_inner_c;
+    dsp->vp8_h_loop_filter16y_inner = vp8_h_loop_filter16_inner_c;
+    dsp->vp8_v_loop_filter8uv_inner = vp8_v_loop_filter8uv_inner_c;
+    dsp->vp8_h_loop_filter8uv_inner = vp8_h_loop_filter8uv_inner_c;
+
+    dsp->vp8_v_loop_filter_simple = vp8_v_loop_filter_simple_c;
+    dsp->vp8_h_loop_filter_simple = vp8_h_loop_filter_simple_c;
+
+    if (ARCH_ARM)
+        ff_vp8dsp_init_arm(dsp);
     if (ARCH_X86)
-        ff_vp8dsp_init_x86(dsp, vp7);
+        ff_vp8dsp_init_x86(dsp);
+    if (ARCH_MIPS)
+        ff_vp8dsp_init_mips(dsp);
 }
+#endif /* CONFIG_VP8_DECODER */