vp9dsp: Deduplicate the subpel filters
[ffmpeg.git] / libavcodec / vp9dsp_template.c
index a8d056b..bb54561 100644 (file)
@@ -25,6 +25,8 @@
 #include "bit_depth_template.c"
 #include "vp9dsp.h"
 
 #include "bit_depth_template.c"
 #include "vp9dsp.h"
 
+#if BIT_DEPTH != 12
+
 // FIXME see whether we can merge parts of this (perhaps at least 4x4 and 8x8)
 // back with h264pred.[ch]
 
 // FIXME see whether we can merge parts of this (perhaps at least 4x4 and 8x8)
 // back with h264pred.[ch]
 
@@ -181,6 +183,8 @@ static void hor_32x32_c(uint8_t *_dst, ptrdiff_t stride,
     }
 }
 
     }
 }
 
+#endif /* BIT_DEPTH != 12 */
+
 static void tm_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                      const uint8_t *_left, const uint8_t *_top)
 {
 static void tm_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                      const uint8_t *_left, const uint8_t *_top)
 {
@@ -305,6 +309,8 @@ static void tm_32x32_c(uint8_t *_dst, ptrdiff_t stride,
     }
 }
 
     }
 }
 
+#if BIT_DEPTH != 12
+
 static void dc_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                      const uint8_t *_left, const uint8_t *_top)
 {
 static void dc_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                      const uint8_t *_left, const uint8_t *_top)
 {
@@ -560,6 +566,8 @@ static void dc_top_32x32_c(uint8_t *_dst, ptrdiff_t stride,
     }
 }
 
     }
 }
 
+#endif /* BIT_DEPTH != 12 */
+
 static void dc_128_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                          const uint8_t *left, const uint8_t *top)
 {
 static void dc_128_4x4_c(uint8_t *_dst, ptrdiff_t stride,
                          const uint8_t *left, const uint8_t *top)
 {
@@ -757,6 +765,8 @@ static void dc_129_32x32_c(uint8_t *_dst, ptrdiff_t stride,
     }
 }
 
     }
 }
 
+#if BIT_DEPTH != 12
+
 #if BIT_DEPTH == 8
 #define memset_bpc memset
 #else
 #if BIT_DEPTH == 8
 #define memset_bpc memset
 #else
@@ -1065,9 +1075,28 @@ def_hor_up(32)
 
 #undef DST
 
 
 #undef DST
 
-static av_cold void vp9dsp_intrapred_init(VP9DSPContext *dsp)
+#endif /* BIT_DEPTH != 12 */
+
+#if BIT_DEPTH != 8
+void ff_vp9dsp_intrapred_init_10(VP9DSPContext *dsp);
+#endif
+#if BIT_DEPTH != 10
+static
+#endif
+av_cold void FUNC(ff_vp9dsp_intrapred_init)(VP9DSPContext *dsp)
 {
 {
+#define init_intra_pred_bd_aware(tx, sz) \
+    dsp->intra_pred[tx][TM_VP8_PRED]          = tm_##sz##_c; \
+    dsp->intra_pred[tx][DC_128_PRED]          = dc_128_##sz##_c; \
+    dsp->intra_pred[tx][DC_127_PRED]          = dc_127_##sz##_c; \
+    dsp->intra_pred[tx][DC_129_PRED]          = dc_129_##sz##_c
+
+#if BIT_DEPTH == 12
+    ff_vp9dsp_intrapred_init_10(dsp);
 #define init_intra_pred(tx, sz) \
 #define init_intra_pred(tx, sz) \
+    init_intra_pred_bd_aware(tx, sz)
+#else
+    #define init_intra_pred(tx, sz) \
     dsp->intra_pred[tx][VERT_PRED]            = vert_##sz##_c; \
     dsp->intra_pred[tx][HOR_PRED]             = hor_##sz##_c; \
     dsp->intra_pred[tx][DC_PRED]              = dc_##sz##_c; \
     dsp->intra_pred[tx][VERT_PRED]            = vert_##sz##_c; \
     dsp->intra_pred[tx][HOR_PRED]             = hor_##sz##_c; \
     dsp->intra_pred[tx][DC_PRED]              = dc_##sz##_c; \
@@ -1077,12 +1106,10 @@ static av_cold void vp9dsp_intrapred_init(VP9DSPContext *dsp)
     dsp->intra_pred[tx][HOR_DOWN_PRED]        = hor_down_##sz##_c; \
     dsp->intra_pred[tx][VERT_LEFT_PRED]       = vert_left_##sz##_c; \
     dsp->intra_pred[tx][HOR_UP_PRED]          = hor_up_##sz##_c; \
     dsp->intra_pred[tx][HOR_DOWN_PRED]        = hor_down_##sz##_c; \
     dsp->intra_pred[tx][VERT_LEFT_PRED]       = vert_left_##sz##_c; \
     dsp->intra_pred[tx][HOR_UP_PRED]          = hor_up_##sz##_c; \
-    dsp->intra_pred[tx][TM_VP8_PRED]          = tm_##sz##_c; \
     dsp->intra_pred[tx][LEFT_DC_PRED]         = dc_left_##sz##_c; \
     dsp->intra_pred[tx][TOP_DC_PRED]          = dc_top_##sz##_c; \
     dsp->intra_pred[tx][LEFT_DC_PRED]         = dc_left_##sz##_c; \
     dsp->intra_pred[tx][TOP_DC_PRED]          = dc_top_##sz##_c; \
-    dsp->intra_pred[tx][DC_128_PRED]          = dc_128_##sz##_c; \
-    dsp->intra_pred[tx][DC_127_PRED]          = dc_127_##sz##_c; \
-    dsp->intra_pred[tx][DC_129_PRED]          = dc_129_##sz##_c
+    init_intra_pred_bd_aware(tx, sz)
+#endif
 
     init_intra_pred(TX_4X4,   4x4);
     init_intra_pred(TX_8X8,   8x8);
 
     init_intra_pred(TX_4X4,   4x4);
     init_intra_pred(TX_8X8,   8x8);
@@ -1090,6 +1117,7 @@ static av_cold void vp9dsp_intrapred_init(VP9DSPContext *dsp)
     init_intra_pred(TX_32X32, 32x32);
 
 #undef init_intra_pred
     init_intra_pred(TX_32X32, 32x32);
 
 #undef init_intra_pred
+#undef init_intra_pred_bd_aware
 }
 
 #define itxfm_wrapper(type_a, type_b, sz, bits, has_dconly) \
 }
 
 #define itxfm_wrapper(type_a, type_b, sz, bits, has_dconly) \
@@ -1103,8 +1131,8 @@ static void type_a##_##type_b##_##sz##x##sz##_add_c(uint8_t *_dst, \
 \
     stride /= sizeof(pixel); \
     if (has_dconly && eob == 1) { \
 \
     stride /= sizeof(pixel); \
     if (has_dconly && eob == 1) { \
-        const int t  = (((block[0] * 11585 + (1 << 13)) >> 14) \
-                                   * 11585 + (1 << 13)) >> 14; \
+        const int t  = ((((dctint) block[0] * 11585 + (1 << 13)) >> 14) \
+                                            * 11585 + (1 << 13)) >> 14; \
         block[0] = 0; \
         for (i = 0; i < sz; i++) { \
             for (j = 0; j < sz; j++) \
         block[0] = 0; \
         for (i = 0; i < sz; i++) { \
             for (j = 0; j < sz; j++) \
@@ -1158,7 +1186,7 @@ static av_always_inline void idct4_1d(const dctcoef *in, ptrdiff_t stride,
 static av_always_inline void iadst4_1d(const dctcoef *in, ptrdiff_t stride,
                                        dctcoef *out, int pass)
 {
 static av_always_inline void iadst4_1d(const dctcoef *in, ptrdiff_t stride,
                                        dctcoef *out, int pass)
 {
-    int t0, t1, t2, t3;
+    dctint t0, t1, t2, t3;
 
     t0 =  5283 * IN(0) + 15212 * IN(2) +  9929 * IN(3);
     t1 =  9929 * IN(0) -  5283 * IN(2) - 15212 * IN(3);
 
     t0 =  5283 * IN(0) + 15212 * IN(2) +  9929 * IN(3);
     t1 =  9929 * IN(0) -  5283 * IN(2) - 15212 * IN(3);
@@ -1906,27 +1934,34 @@ static av_cold void vp9dsp_loopfilter_init(VP9DSPContext *dsp)
     dsp->loop_filter_mix2[1][1][1] = loop_filter_v_88_16_c;
 }
 
     dsp->loop_filter_mix2[1][1][1] = loop_filter_v_88_16_c;
 }
 
+#if BIT_DEPTH != 12
+
 static av_always_inline void copy_c(uint8_t *dst, ptrdiff_t dst_stride,
                                     const uint8_t *src, ptrdiff_t src_stride,
                                     int w, int h)
 {
     do {
 static av_always_inline void copy_c(uint8_t *dst, ptrdiff_t dst_stride,
                                     const uint8_t *src, ptrdiff_t src_stride,
                                     int w, int h)
 {
     do {
-        memcpy(dst, src, w);
+        memcpy(dst, src, w * sizeof(pixel));
 
         dst += dst_stride;
         src += src_stride;
     } while (--h);
 }
 
 
         dst += dst_stride;
         src += src_stride;
     } while (--h);
 }
 
-static av_always_inline void avg_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                   const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void avg_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                   const uint8_t *_src, ptrdiff_t src_stride,
                                    int w, int h)
 {
                                    int w, int h)
 {
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
+
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     do {
         int x;
 
         for (x = 0; x < w; x += 4)
     do {
         int x;
 
         for (x = 0; x < w; x += 4)
-            AV_WN32A(&dst[x], rnd_avg32(AV_RN32A(&dst[x]), AV_RN32(&src[x])));
+            AV_WN4PA(&dst[x], rnd_avg_pixel4(AV_RN4PA(&dst[x]), AV_RN4P(&src[x])));
 
         dst += dst_stride;
         src += src_stride;
 
         dst += dst_stride;
         src += src_stride;
@@ -1954,63 +1989,10 @@ copy_avg_fn(4)
 #undef fpel_fn
 #undef copy_avg_fn
 
 #undef fpel_fn
 #undef copy_avg_fn
 
-static const int16_t vp9_subpel_filters[3][16][8] = {
-    [FILTER_8TAP_REGULAR] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        {  0,  1,  -5, 126,   8,  -3,  1,  0 },
-        { -1,  3, -10, 122,  18,  -6,  2,  0 },
-        { -1,  4, -13, 118,  27,  -9,  3, -1 },
-        { -1,  4, -16, 112,  37, -11,  4, -1 },
-        { -1,  5, -18, 105,  48, -14,  4, -1 },
-        { -1,  5, -19,  97,  58, -16,  5, -1 },
-        { -1,  6, -19,  88,  68, -18,  5, -1 },
-        { -1,  6, -19,  78,  78, -19,  6, -1 },
-        { -1,  5, -18,  68,  88, -19,  6, -1 },
-        { -1,  5, -16,  58,  97, -19,  5, -1 },
-        { -1,  4, -14,  48, 105, -18,  5, -1 },
-        { -1,  4, -11,  37, 112, -16,  4, -1 },
-        { -1,  3,  -9,  27, 118, -13,  4, -1 },
-        {  0,  2,  -6,  18, 122, -10,  3, -1 },
-        {  0,  1,  -3,   8, 126,  -5,  1,  0 },
-    }, [FILTER_8TAP_SHARP] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        { -1,  3,  -7, 127,   8,  -3,  1,  0 },
-        { -2,  5, -13, 125,  17,  -6,  3, -1 },
-        { -3,  7, -17, 121,  27, -10,  5, -2 },
-        { -4,  9, -20, 115,  37, -13,  6, -2 },
-        { -4, 10, -23, 108,  48, -16,  8, -3 },
-        { -4, 10, -24, 100,  59, -19,  9, -3 },
-        { -4, 11, -24,  90,  70, -21, 10, -4 },
-        { -4, 11, -23,  80,  80, -23, 11, -4 },
-        { -4, 10, -21,  70,  90, -24, 11, -4 },
-        { -3,  9, -19,  59, 100, -24, 10, -4 },
-        { -3,  8, -16,  48, 108, -23, 10, -4 },
-        { -2,  6, -13,  37, 115, -20,  9, -4 },
-        { -2,  5, -10,  27, 121, -17,  7, -3 },
-        { -1,  3,  -6,  17, 125, -13,  5, -2 },
-        {  0,  1,  -3,   8, 127,  -7,  3, -1 },
-    }, [FILTER_8TAP_SMOOTH] = {
-        {  0,  0,   0, 128,   0,   0,  0,  0 },
-        { -3, -1,  32,  64,  38,   1, -3,  0 },
-        { -2, -2,  29,  63,  41,   2, -3,  0 },
-        { -2, -2,  26,  63,  43,   4, -4,  0 },
-        { -2, -3,  24,  62,  46,   5, -4,  0 },
-        { -2, -3,  21,  60,  49,   7, -4,  0 },
-        { -1, -4,  18,  59,  51,   9, -4,  0 },
-        { -1, -4,  16,  57,  53,  12, -4, -1 },
-        { -1, -4,  14,  55,  55,  14, -4, -1 },
-        { -1, -4,  12,  53,  57,  16, -4, -1 },
-        {  0, -4,   9,  51,  59,  18, -4, -1 },
-        {  0, -4,   7,  49,  60,  21, -3, -2 },
-        {  0, -4,   5,  46,  62,  24, -3, -2 },
-        {  0, -4,   4,  43,  63,  26, -2, -2 },
-        {  0, -3,   2,  41,  63,  29, -2, -2 },
-        {  0, -3,   1,  38,  64,  32, -1, -3 },
-    }
-};
+#endif /* BIT_DEPTH != 12 */
 
 #define FILTER_8TAP(src, x, F, stride) \
 
 #define FILTER_8TAP(src, x, F, stride) \
-    av_clip_uint8((F[0] * src[x + -3 * stride] + \
+    av_clip_pixel((F[0] * src[x + -3 * stride] + \
                    F[1] * src[x + -2 * stride] + \
                    F[2] * src[x + -1 * stride] + \
                    F[3] * src[x + +0 * stride] + \
                    F[1] * src[x + -2 * stride] + \
                    F[2] * src[x + -1 * stride] + \
                    F[3] * src[x + +0 * stride] + \
@@ -2019,11 +2001,16 @@ static const int16_t vp9_subpel_filters[3][16][8] = {
                    F[6] * src[x + +3 * stride] + \
                    F[7] * src[x + +4 * stride] + 64) >> 7)
 
                    F[6] * src[x + +3 * stride] + \
                    F[7] * src[x + +4 * stride] + 64) >> 7)
 
-static av_always_inline void do_8tap_1d_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                          const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void do_8tap_1d_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                          const uint8_t *_src, ptrdiff_t src_stride,
                                           int w, int h, ptrdiff_t ds,
                                           const int16_t *filter, int avg)
 {
                                           int w, int h, ptrdiff_t ds,
                                           const int16_t *filter, int avg)
 {
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
+
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     do {
         int x;
 
     do {
         int x;
 
@@ -2047,21 +2034,25 @@ static av_noinline void opn##_8tap_1d_##dir##_c(uint8_t *dst, ptrdiff_t dst_stri
     do_8tap_1d_c(dst, dst_stride, src, src_stride, w, h, ds, filter, opa); \
 }
 
     do_8tap_1d_c(dst, dst_stride, src, src_stride, w, h, ds, filter, opa); \
 }
 
-filter_8tap_1d_fn(put, 0, v, src_stride)
+filter_8tap_1d_fn(put, 0, v, src_stride / sizeof(pixel))
 filter_8tap_1d_fn(put, 0, h, 1)
 filter_8tap_1d_fn(put, 0, h, 1)
-filter_8tap_1d_fn(avg, 1, v, src_stride)
+filter_8tap_1d_fn(avg, 1, v, src_stride / sizeof(pixel))
 filter_8tap_1d_fn(avg, 1, h, 1)
 
 #undef filter_8tap_1d_fn
 
 filter_8tap_1d_fn(avg, 1, h, 1)
 
 #undef filter_8tap_1d_fn
 
-static av_always_inline void do_8tap_2d_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                          const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void do_8tap_2d_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                          const uint8_t *_src, ptrdiff_t src_stride,
                                           int w, int h, const int16_t *filterx,
                                           const int16_t *filtery, int avg)
 {
     int tmp_h = h + 7;
                                           int w, int h, const int16_t *filterx,
                                           const int16_t *filtery, int avg)
 {
     int tmp_h = h + 7;
-    uint8_t tmp[64 * 71], *tmp_ptr = tmp;
+    pixel tmp[64 * 71], *tmp_ptr = tmp;
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
 
 
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     src -= src_stride * 3;
     do {
         int x;
     src -= src_stride * 3;
     do {
         int x;
@@ -2109,7 +2100,7 @@ static void avg##_8tap_##type##_##sz##dir##_c(uint8_t *dst, ptrdiff_t dst_stride
                                               int h, int mx, int my) \
 { \
     avg##_8tap_1d_##dir##_c(dst, dst_stride, src, src_stride, sz, h, \
                                               int h, int mx, int my) \
 { \
     avg##_8tap_1d_##dir##_c(dst, dst_stride, src, src_stride, sz, h, \
-                            vp9_subpel_filters[type_idx][dir_m]); \
+                            ff_vp9_subpel_filters[type_idx][dir_m]); \
 }
 
 #define filter_fn_2d(sz, type, type_idx, avg) \
 }
 
 #define filter_fn_2d(sz, type, type_idx, avg) \
@@ -2118,17 +2109,24 @@ static void avg##_8tap_##type##_##sz##hv_c(uint8_t *dst, ptrdiff_t dst_stride, \
                                            int h, int mx, int my) \
 { \
     avg##_8tap_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, \
                                            int h, int mx, int my) \
 { \
     avg##_8tap_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, \
-                       vp9_subpel_filters[type_idx][mx], \
-                       vp9_subpel_filters[type_idx][my]); \
+                       ff_vp9_subpel_filters[type_idx][mx], \
+                       ff_vp9_subpel_filters[type_idx][my]); \
 }
 
 }
 
+#if BIT_DEPTH != 12
+
 #define FILTER_BILIN(src, x, mxy, stride) \
     (src[x] + ((mxy * (src[x + stride] - src[x]) + 8) >> 4))
 
 #define FILTER_BILIN(src, x, mxy, stride) \
     (src[x] + ((mxy * (src[x + stride] - src[x]) + 8) >> 4))
 
-static av_always_inline void do_bilin_1d_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                           const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void do_bilin_1d_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                           const uint8_t *_src, ptrdiff_t src_stride,
                                            int w, int h, ptrdiff_t ds, int mxy, int avg)
 {
                                            int w, int h, ptrdiff_t ds, int mxy, int avg)
 {
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
+
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     do {
         int x;
 
     do {
         int x;
 
@@ -2152,20 +2150,24 @@ static av_noinline void opn##_bilin_1d_##dir##_c(uint8_t *dst, ptrdiff_t dst_str
     do_bilin_1d_c(dst, dst_stride, src, src_stride, w, h, ds, mxy, opa); \
 }
 
     do_bilin_1d_c(dst, dst_stride, src, src_stride, w, h, ds, mxy, opa); \
 }
 
-bilin_1d_fn(put, 0, v, src_stride)
+bilin_1d_fn(put, 0, v, src_stride / sizeof(pixel))
 bilin_1d_fn(put, 0, h, 1)
 bilin_1d_fn(put, 0, h, 1)
-bilin_1d_fn(avg, 1, v, src_stride)
+bilin_1d_fn(avg, 1, v, src_stride / sizeof(pixel))
 bilin_1d_fn(avg, 1, h, 1)
 
 #undef bilin_1d_fn
 
 bilin_1d_fn(avg, 1, h, 1)
 
 #undef bilin_1d_fn
 
-static av_always_inline void do_bilin_2d_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                           const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void do_bilin_2d_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                           const uint8_t *_src, ptrdiff_t src_stride,
                                            int w, int h, int mx, int my, int avg)
 {
                                            int w, int h, int mx, int my, int avg)
 {
-    uint8_t tmp[64 * 65], *tmp_ptr = tmp;
+    pixel tmp[64 * 65], *tmp_ptr = tmp;
     int tmp_h = h + 1;
     int tmp_h = h + 1;
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
 
 
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     do {
         int x;
 
     do {
         int x;
 
@@ -2221,6 +2223,13 @@ static void avg##_bilin_##sz##hv_c(uint8_t *dst, ptrdiff_t dst_stride, \
     avg##_bilin_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, mx, my); \
 }
 
     avg##_bilin_2d_hv_c(dst, dst_stride, src, src_stride, sz, h, mx, my); \
 }
 
+#else
+
+#define bilinf_fn_1d(a, b, c, d)
+#define bilinf_fn_2d(a, b)
+
+#endif
+
 #define filter_fn(sz, avg) \
 filter_fn_1d(sz, h, mx, regular, FILTER_8TAP_REGULAR, avg) \
 filter_fn_1d(sz, v, my, regular, FILTER_8TAP_REGULAR, avg) \
 #define filter_fn(sz, avg) \
 filter_fn_1d(sz, h, mx, regular, FILTER_8TAP_REGULAR, avg) \
 filter_fn_1d(sz, v, my, regular, FILTER_8TAP_REGULAR, avg) \
@@ -2252,8 +2261,18 @@ filter_fn_set(avg)
 #undef bilinf_fn_1d
 #undef bilinf_fn_2d
 
 #undef bilinf_fn_1d
 #undef bilinf_fn_2d
 
-static av_cold void vp9dsp_mc_init(VP9DSPContext *dsp)
+#if BIT_DEPTH != 8
+void ff_vp9dsp_mc_init_10(VP9DSPContext *dsp);
+#endif
+#if BIT_DEPTH != 10
+static
+#endif
+av_cold void FUNC(ff_vp9dsp_mc_init)(VP9DSPContext *dsp)
 {
 {
+#if BIT_DEPTH == 12
+    ff_vp9dsp_mc_init_10(dsp);
+#else /* BIT_DEPTH == 12 */
+
 #define init_fpel(idx1, idx2, sz, type) \
     dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = type##sz##_c; \
     dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = type##sz##_c; \
 #define init_fpel(idx1, idx2, sz, type) \
     dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][0][0] = type##sz##_c; \
     dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][0][0] = type##sz##_c; \
@@ -2273,11 +2292,20 @@ static av_cold void vp9dsp_mc_init(VP9DSPContext *dsp)
 #undef init_copy_avg
 #undef init_fpel
 
 #undef init_copy_avg
 #undef init_fpel
 
-#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type) \
+#endif /* BIT_DEPTH == 12 */
+
+#define init_subpel1_bd_aware(idx1, idx2, idxh, idxv, sz, dir, type) \
     dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_c; \
     dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_c; \
     dsp->mc[idx1][FILTER_8TAP_SMOOTH ][idx2][idxh][idxv] = type##_8tap_smooth_##sz##dir##_c; \
     dsp->mc[idx1][FILTER_8TAP_REGULAR][idx2][idxh][idxv] = type##_8tap_regular_##sz##dir##_c; \
-    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_c; \
+    dsp->mc[idx1][FILTER_8TAP_SHARP  ][idx2][idxh][idxv] = type##_8tap_sharp_##sz##dir##_c
+
+#if BIT_DEPTH == 12
+#define init_subpel1 init_subpel1_bd_aware
+#else
+#define init_subpel1(idx1, idx2, idxh, idxv, sz, dir, type) \
+    init_subpel1_bd_aware(idx1, idx2, idxh, idxv, sz, dir, type); \
     dsp->mc[idx1][FILTER_BILINEAR    ][idx2][idxh][idxv] = type##_bilin_##sz##dir##_c
     dsp->mc[idx1][FILTER_BILINEAR    ][idx2][idxh][idxv] = type##_bilin_##sz##dir##_c
+#endif
 
 #define init_subpel2(idx, idxh, idxv, dir, type) \
     init_subpel1(0, idx, idxh, idxv, 64, dir, type); \
 
 #define init_subpel2(idx, idxh, idxv, dir, type) \
     init_subpel1(0, idx, idxh, idxv, 64, dir, type); \
@@ -2297,17 +2325,22 @@ static av_cold void vp9dsp_mc_init(VP9DSPContext *dsp)
 #undef init_subpel1
 #undef init_subpel2
 #undef init_subpel3
 #undef init_subpel1
 #undef init_subpel2
 #undef init_subpel3
+#undef init_subpel1_bd_aware
 }
 
 }
 
-static av_always_inline void do_scaled_8tap_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                              const uint8_t *src, ptrdiff_t src_stride,
+static av_always_inline void do_scaled_8tap_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                              const uint8_t *_src, ptrdiff_t src_stride,
                                               int w, int h, int mx, int my,
                                               int dx, int dy, int avg,
                                               const int16_t (*filters)[8])
 {
     int tmp_h = (((h - 1) * dy + my) >> 4) + 8;
                                               int w, int h, int mx, int my,
                                               int dx, int dy, int avg,
                                               const int16_t (*filters)[8])
 {
     int tmp_h = (((h - 1) * dy + my) >> 4) + 8;
-    uint8_t tmp[64 * 135], *tmp_ptr = tmp;
+    pixel tmp[64 * 135], *tmp_ptr = tmp;
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
 
 
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     src -= src_stride * 3;
     do {
         int x;
     src -= src_stride * 3;
     do {
         int x;
@@ -2366,17 +2399,23 @@ static void avg##_scaled_##type##_##sz##_c(uint8_t *dst, ptrdiff_t dst_stride, \
                                            int h, int mx, int my, int dx, int dy) \
 { \
     avg##_scaled_8tap_c(dst, dst_stride, src, src_stride, sz, h, mx, my, dx, dy, \
                                            int h, int mx, int my, int dx, int dy) \
 { \
     avg##_scaled_8tap_c(dst, dst_stride, src, src_stride, sz, h, mx, my, dx, dy, \
-                        vp9_subpel_filters[type_idx]); \
+                        ff_vp9_subpel_filters[type_idx]); \
 }
 
 }
 
-static av_always_inline void do_scaled_bilin_c(uint8_t *dst, ptrdiff_t dst_stride,
-                                               const uint8_t *src, ptrdiff_t src_stride,
+#if BIT_DEPTH != 12
+
+static av_always_inline void do_scaled_bilin_c(uint8_t *_dst, ptrdiff_t dst_stride,
+                                               const uint8_t *_src, ptrdiff_t src_stride,
                                                int w, int h, int mx, int my,
                                                int dx, int dy, int avg)
 {
                                                int w, int h, int mx, int my,
                                                int dx, int dy, int avg)
 {
-    uint8_t tmp[64 * 129], *tmp_ptr = tmp;
+    pixel tmp[64 * 129], *tmp_ptr = tmp;
     int tmp_h = (((h - 1) * dy + my) >> 4) + 2;
     int tmp_h = (((h - 1) * dy + my) >> 4) + 2;
+    pixel *dst = (pixel *) _dst;
+    const pixel *src = (const pixel *) _src;
 
 
+    dst_stride /= sizeof(pixel);
+    src_stride /= sizeof(pixel);
     do {
         int x;
         int imx = mx, ioff = 0;
     do {
         int x;
         int imx = mx, ioff = 0;
@@ -2433,6 +2472,12 @@ static void avg##_scaled_bilin_##sz##_c(uint8_t *dst, ptrdiff_t dst_stride, \
     avg##_scaled_bilin_c(dst, dst_stride, src, src_stride, sz, h, mx, my, dx, dy); \
 }
 
     avg##_scaled_bilin_c(dst, dst_stride, src, src_stride, sz, h, mx, my, dx, dy); \
 }
 
+#else
+
+#define scaled_bilinf_fn(a, b)
+
+#endif
+
 #define scaled_filter_fns(sz, avg) \
 scaled_filter_fn(sz,        regular, FILTER_8TAP_REGULAR, avg) \
 scaled_filter_fn(sz,        smooth,  FILTER_8TAP_SMOOTH,  avg) \
 #define scaled_filter_fns(sz, avg) \
 scaled_filter_fn(sz,        regular, FILTER_8TAP_REGULAR, avg) \
 scaled_filter_fn(sz,        smooth,  FILTER_8TAP_SMOOTH,  avg) \
@@ -2454,13 +2499,27 @@ scaled_filter_fn_set(avg)
 #undef scaled_filter_fn
 #undef scaled_bilinf_fn
 
 #undef scaled_filter_fn
 #undef scaled_bilinf_fn
 
-static av_cold void vp9dsp_scaled_mc_init(VP9DSPContext *dsp)
+#if BIT_DEPTH != 8
+void ff_vp9dsp_scaled_mc_init_10(VP9DSPContext *dsp);
+#endif
+#if BIT_DEPTH != 10
+static
+#endif
+av_cold void FUNC(ff_vp9dsp_scaled_mc_init)(VP9DSPContext *dsp)
 {
 {
-#define init_scaled(idx1, idx2, sz, type) \
+#define init_scaled_bd_aware(idx1, idx2, sz, type) \
     dsp->smc[idx1][FILTER_8TAP_SMOOTH ][idx2] = type##_scaled_smooth_##sz##_c; \
     dsp->smc[idx1][FILTER_8TAP_REGULAR][idx2] = type##_scaled_regular_##sz##_c; \
     dsp->smc[idx1][FILTER_8TAP_SMOOTH ][idx2] = type##_scaled_smooth_##sz##_c; \
     dsp->smc[idx1][FILTER_8TAP_REGULAR][idx2] = type##_scaled_regular_##sz##_c; \
-    dsp->smc[idx1][FILTER_8TAP_SHARP  ][idx2] = type##_scaled_sharp_##sz##_c; \
+    dsp->smc[idx1][FILTER_8TAP_SHARP  ][idx2] = type##_scaled_sharp_##sz##_c
+
+#if BIT_DEPTH == 12
+    ff_vp9dsp_scaled_mc_init_10(dsp);
+#define init_scaled(a,b,c,d) init_scaled_bd_aware(a,b,c,d)
+#else
+#define init_scaled(idx1, idx2, sz, type) \
+    init_scaled_bd_aware(idx1, idx2, sz, type); \
     dsp->smc[idx1][FILTER_BILINEAR    ][idx2] = type##_scaled_bilin_##sz##_c
     dsp->smc[idx1][FILTER_BILINEAR    ][idx2] = type##_scaled_bilin_##sz##_c
+#endif
 
 #define init_scaled_put_avg(idx, sz) \
     init_scaled(idx, 0, sz, put); \
 
 #define init_scaled_put_avg(idx, sz) \
     init_scaled(idx, 0, sz, put); \
@@ -2474,13 +2533,14 @@ static av_cold void vp9dsp_scaled_mc_init(VP9DSPContext *dsp)
 
 #undef init_scaled_put_avg
 #undef init_scaled
 
 #undef init_scaled_put_avg
 #undef init_scaled
+#undef init_scaled_bd_aware
 }
 
 av_cold void FUNC(ff_vp9dsp_init)(VP9DSPContext *dsp)
 {
 }
 
 av_cold void FUNC(ff_vp9dsp_init)(VP9DSPContext *dsp)
 {
-    vp9dsp_intrapred_init(dsp);
+    FUNC(ff_vp9dsp_intrapred_init)(dsp);
     vp9dsp_itxfm_init(dsp);
     vp9dsp_loopfilter_init(dsp);
     vp9dsp_itxfm_init(dsp);
     vp9dsp_loopfilter_init(dsp);
-    vp9dsp_mc_init(dsp);
-    vp9dsp_scaled_mc_init(dsp);
+    FUNC(ff_vp9dsp_mc_init)(dsp);
+    FUNC(ff_vp9dsp_scaled_mc_init)(dsp);
 }
 }