@@ -148,7 +148,7 @@ Alignment:

 Some instructions on some architectures have strict alignment restrictions,

 for example most SSE/SSE2 instructions on x86.

 The minimum guaranteed alignment is written in the .h files, for example:

-    void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, UINT8 *pixels/*align 8*/, int line_size);

+    void (*put_pixels_clamped)(const int16_t *block/*align 16*/, UINT8 *pixels/*align 8*/, int line_size);

 General Tips:

@@ -138,7 +138,7 @@ typedef struct FourXContext {

     int mv[256];

     VLC pre_vlc;

     int last_dc;

-    DECLARE_ALIGNED(16, DCTELEM, block)[6][64];

+    DECLARE_ALIGNED(16, int16_t, block)[6][64];

     void *bitstream_buffer;

     unsigned int bitstream_buffer_size;

     int version;

@@ -153,7 +153,7 @@ typedef struct FourXContext {

 #define MULTIPLY(var, const) (((var) * (const)) >> 16)

-static void idct(DCTELEM block[64])

+static void idct(int16_t block[64])

 {

     int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;

     int tmp10, tmp11, tmp12, tmp13;

@@ -471,7 +471,7 @@ static int decode_p_frame(FourXContext *f, const uint8_t *buf, int length)

  * decode block and dequantize.

  * Note this is almost identical to MJPEG.

  */

-static int decode_i_block(FourXContext *f, DCTELEM *block)

+static int decode_i_block(FourXContext *f, int16_t *block)

 {

     int code, i, j, level, val;

@@ -521,7 +521,7 @@ static int decode_i_block(FourXContext *f, DCTELEM *block)

 static inline void idct_put(FourXContext *f, int x, int y)

 {

-    DCTELEM (*block)[64] = f->block;

+    int16_t (*block)[64] = f->block;

     int stride           = f->current_picture->linesize[0] >> 1;

     int i;

     uint16_t *dst = ((uint16_t*)f->current_picture->data[0]) + y * stride + x;

@@ -542,7 +542,7 @@ static inline void idct_put(FourXContext *f, int x, int y)

      * cr = (-1b - 4g + 5r) / 14 */

     for (y = 0; y < 8; y++) {

         for (x = 0; x < 8; x++) {

-            DCTELEM *temp = block[(x >> 2) + 2 * (y >> 2)] +

+            int16_t *temp = block[(x >> 2) + 2 * (y >> 2)] +

                             2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize

             int cb = block[4][x + 8 * y];

             int cr = block[5][x + 8 * y];

@@ -23,15 +23,15 @@

 #include "dsputil_alpha.h"

 #include "asm.h"

-void (*put_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels,

+void (*put_pixels_clamped_axp_p)(const int16_t *block, uint8_t *pixels,

                                  int line_size);

-void (*add_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels,

+void (*add_pixels_clamped_axp_p)(const int16_t *block, uint8_t *pixels,

                                  int line_size);

 #if 0

 /* These functions were the base for the optimized assembler routines,

    and remain here for documentation purposes.  */

-static void put_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels,

+static void put_pixels_clamped_mvi(const int16_t *block, uint8_t *pixels,

                                    int line_size)

 {

     int i = 8;

@@ -55,7 +55,7 @@ static void put_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels,

     } while (--i);

 }

-void add_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels,

+void add_pixels_clamped_mvi(const int16_t *block, uint8_t *pixels,

                             int line_size)

 {

     int h = 8;

@@ -100,9 +100,9 @@ void add_pixels_clamped_mvi(const DCTELEM *block, uint8_t *pixels,

 }

 #endif

-static void clear_blocks_axp(DCTELEM *blocks) {

+static void clear_blocks_axp(int16_t *blocks) {

     uint64_t *p = (uint64_t *) blocks;

-    int n = sizeof(DCTELEM) * 6 * 64;

+    int n = sizeof(int16_t) * 6 * 64;

     do {

         p[0] = 0;

@@ -19,26 +19,26 @@

 #ifndef AVCODEC_ALPHA_DSPUTIL_ALPHA_H

 #define AVCODEC_ALPHA_DSPUTIL_ALPHA_H

-#include "libavcodec/dsputil.h"

+#include <stdint.h>

-void ff_simple_idct_axp(DCTELEM *block);

-void ff_simple_idct_put_axp(uint8_t *dest, int line_size, DCTELEM *block);

-void ff_simple_idct_add_axp(uint8_t *dest, int line_size, DCTELEM *block);

+void ff_simple_idct_axp(int16_t *block);

+void ff_simple_idct_put_axp(uint8_t *dest, int line_size, int16_t *block);

+void ff_simple_idct_add_axp(uint8_t *dest, int line_size, int16_t *block);

 void put_pixels_axp_asm(uint8_t *block, const uint8_t *pixels,

                         int line_size, int h);

-void put_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels,

+void put_pixels_clamped_mvi_asm(const int16_t *block, uint8_t *pixels,

                                 int line_size);

-void add_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels,

+void add_pixels_clamped_mvi_asm(const int16_t *block, uint8_t *pixels,

                                 int line_size);

-extern void (*put_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels,

+extern void (*put_pixels_clamped_axp_p)(const int16_t *block, uint8_t *pixels,

                                         int line_size);

-extern void (*add_pixels_clamped_axp_p)(const DCTELEM *block, uint8_t *pixels,

+extern void (*add_pixels_clamped_axp_p)(const int16_t *block, uint8_t *pixels,

                                         int line_size);

-void get_pixels_mvi(DCTELEM *av_restrict block,

-                    const uint8_t *av_restrict pixels, int line_size);

-void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2,

+void get_pixels_mvi(int16_t *restrict block,

+                    const uint8_t *restrict pixels, int line_size);

+void diff_pixels_mvi(int16_t *block, const uint8_t *s1, const uint8_t *s2,

                      int stride);

 int pix_abs8x8_mvi(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

 int pix_abs16x16_mvi_asm(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h);

@@ -135,7 +135,7 @@ $aligned:

         .end put_pixels_axp_asm

 /************************************************************************

- * void put_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels,

+ * void put_pixels_clamped_mvi_asm(const int16_t *block, uint8_t *pixels,

  *                                 int line_size)

  */

         .align 6

@@ -185,7 +185,7 @@ put_pixels_clamped_mvi_asm:

         .end put_pixels_clamped_mvi_asm

 /************************************************************************

- * void add_pixels_clamped_mvi_asm(const DCTELEM *block, uint8_t *pixels,

+ * void add_pixels_clamped_mvi_asm(const int16_t *block, uint8_t *pixels,

  *                                 int line_size)

  */

         .align 6

@@ -23,8 +23,8 @@

 #include "dsputil_alpha.h"

 #include "asm.h"

-void get_pixels_mvi(DCTELEM *av_restrict block,

-                    const uint8_t *av_restrict pixels, int line_size)

+void get_pixels_mvi(int16_t *restrict block,

+                    const uint8_t *restrict pixels, int line_size)

 {

     int h = 8;

@@ -40,7 +40,7 @@ void get_pixels_mvi(DCTELEM *av_restrict block,

     } while (--h);

 }

-void diff_pixels_mvi(DCTELEM *block, const uint8_t *s1, const uint8_t *s2,

+void diff_pixels_mvi(int16_t *block, const uint8_t *s1, const uint8_t *s2,

                      int stride) {

     int h = 8;

     uint64_t mask = 0x4040;

@@ -23,7 +23,7 @@

 #include "libavcodec/mpegvideo.h"

 #include "asm.h"

-static void dct_unquantize_h263_axp(DCTELEM *block, int n_coeffs,

+static void dct_unquantize_h263_axp(int16_t *block, int n_coeffs,

                                     uint64_t qscale, uint64_t qadd)

 {

     uint64_t qmul = qscale << 1;

@@ -69,12 +69,12 @@ static void dct_unquantize_h263_axp(DCTELEM *block, int n_coeffs,

     }

 }

-static void dct_unquantize_h263_intra_axp(MpegEncContext *s, DCTELEM *block,

+static void dct_unquantize_h263_intra_axp(MpegEncContext *s, int16_t *block,

                                     int n, int qscale)

 {

     int n_coeffs;

     uint64_t qadd;

-    DCTELEM block0 = block[0];

+    int16_t block0 = block[0];

     if (!s->h263_aic) {

         if (n < 4)

@@ -96,7 +96,7 @@ static void dct_unquantize_h263_intra_axp(MpegEncContext *s, DCTELEM *block,

     block[0] = block0;

 }

-static void dct_unquantize_h263_inter_axp(MpegEncContext *s, DCTELEM *block,

+static void dct_unquantize_h263_inter_axp(MpegEncContext *s, int16_t *block,

                                     int n, int qscale)

 {

     int n_coeffs = s->inter_scantable.raster_end[s->block_last_index[n]];

@@ -44,7 +44,7 @@

 #define COL_SHIFT 20

 /* 0: all entries 0, 1: only first entry nonzero, 2: otherwise  */

-static inline int idct_row(DCTELEM *row)

+static inline int idct_row(int16_t *row)

 {

     int a0, a1, a2, a3, b0, b1, b2, b3, t;

     uint64_t l, r, t2;

@@ -152,7 +152,7 @@ static inline int idct_row(DCTELEM *row)

     return 2;

 }

-static inline void idct_col(DCTELEM *col)

+static inline void idct_col(int16_t *col)

 {

     int a0, a1, a2, a3, b0, b1, b2, b3;

@@ -229,7 +229,7 @@ static inline void idct_col(DCTELEM *col)

 /* If all rows but the first one are zero after row transformation,

    all rows will be identical after column transformation.  */

-static inline void idct_col2(DCTELEM *col)

+static inline void idct_col2(int16_t *col)

 {

     int i;

     uint64_t l, r;

@@ -251,7 +251,7 @@ static inline void idct_col2(DCTELEM *col)

     stq(l, col + 14 * 4); stq(r, col + 15 * 4);

 }

-void ff_simple_idct_axp(DCTELEM *block)

+void ff_simple_idct_axp(int16_t *block)

 {

     int i;

@@ -291,13 +291,13 @@ void ff_simple_idct_axp(DCTELEM *block)

     }

 }

-void ff_simple_idct_put_axp(uint8_t *dest, int line_size, DCTELEM *block)

+void ff_simple_idct_put_axp(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_simple_idct_axp(block);

     put_pixels_clamped_axp_p(block, dest, line_size);

 }

-void ff_simple_idct_add_axp(uint8_t *dest, int line_size, DCTELEM *block)

+void ff_simple_idct_add_axp(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_simple_idct_axp(block);

     add_pixels_clamped_axp_p(block, dest, line_size);

@@ -23,12 +23,12 @@

 #include "libavcodec/dsputil.h"

 #include "dsputil_arm.h"

-void ff_j_rev_dct_arm(DCTELEM *data);

-void ff_simple_idct_arm(DCTELEM *data);

+void ff_j_rev_dct_arm(int16_t *data);

+void ff_simple_idct_arm(int16_t *data);

 /* XXX: local hack */

-static void (*ff_put_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);

-static void (*ff_add_pixels_clamped)(const DCTELEM *block, uint8_t *pixels, int line_size);

+static void (*ff_put_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);

+static void (*ff_add_pixels_clamped)(const int16_t *block, uint8_t *pixels, int line_size);

 void ff_put_pixels8_arm(uint8_t *block, const uint8_t *pixels, int line_size, int h);

 void ff_put_pixels8_x2_arm(uint8_t *block, const uint8_t *pixels, int line_size, int h);

@@ -48,27 +48,27 @@ CALL_2X_PIXELS(ff_put_no_rnd_pixels16_x2_arm,  ff_put_no_rnd_pixels8_x2_arm, 8)

 CALL_2X_PIXELS(ff_put_no_rnd_pixels16_y2_arm,  ff_put_no_rnd_pixels8_y2_arm, 8)

 CALL_2X_PIXELS(ff_put_no_rnd_pixels16_xy2_arm, ff_put_no_rnd_pixels8_xy2_arm,8)

-void ff_add_pixels_clamped_arm(const DCTELEM *block, uint8_t *dest,

+void ff_add_pixels_clamped_arm(const int16_t *block, uint8_t *dest,

                                int line_size);

 /* XXX: those functions should be suppressed ASAP when all IDCTs are

    converted */

-static void j_rev_dct_arm_put(uint8_t *dest, int line_size, DCTELEM *block)

+static void j_rev_dct_arm_put(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_j_rev_dct_arm (block);

     ff_put_pixels_clamped(block, dest, line_size);

 }

-static void j_rev_dct_arm_add(uint8_t *dest, int line_size, DCTELEM *block)

+static void j_rev_dct_arm_add(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_j_rev_dct_arm (block);

     ff_add_pixels_clamped(block, dest, line_size);

 }

-static void simple_idct_arm_put(uint8_t *dest, int line_size, DCTELEM *block)

+static void simple_idct_arm_put(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_simple_idct_arm (block);

     ff_put_pixels_clamped(block, dest, line_size);

 }

-static void simple_idct_arm_add(uint8_t *dest, int line_size, DCTELEM *block)

+static void simple_idct_arm_add(uint8_t *dest, int line_size, int16_t *block)

 {

     ff_simple_idct_arm (block);

     ff_add_pixels_clamped(block, dest, line_size);

@@ -21,9 +21,9 @@

 #include "libavcodec/dsputil.h"

 #include "dsputil_arm.h"

-void ff_simple_idct_armv5te(DCTELEM *data);

-void ff_simple_idct_put_armv5te(uint8_t *dest, int line_size, DCTELEM *data);

-void ff_simple_idct_add_armv5te(uint8_t *dest, int line_size, DCTELEM *data);

+void ff_simple_idct_armv5te(int16_t *data);

+void ff_simple_idct_put_armv5te(uint8_t *dest, int line_size, int16_t *data);

+void ff_simple_idct_add_armv5te(uint8_t *dest, int line_size, int16_t *data);

 av_cold void ff_dsputil_init_armv5te(DSPContext *c, AVCodecContext *avctx)

 {

@@ -24,9 +24,9 @@

 #include "libavcodec/dsputil.h"

 #include "dsputil_arm.h"

-void ff_simple_idct_armv6(DCTELEM *data);

-void ff_simple_idct_put_armv6(uint8_t *dest, int line_size, DCTELEM *data);

-void ff_simple_idct_add_armv6(uint8_t *dest, int line_size, DCTELEM *data);

+void ff_simple_idct_armv6(int16_t *data);

+void ff_simple_idct_put_armv6(uint8_t *dest, int line_size, int16_t *data);

+void ff_simple_idct_add_armv6(uint8_t *dest, int line_size, int16_t *data);

 void ff_put_pixels16_armv6(uint8_t *, const uint8_t *, int, int);

 void ff_put_pixels16_x2_armv6(uint8_t *, const uint8_t *, int, int);

@@ -46,12 +46,12 @@ void ff_put_pixels8_y2_no_rnd_armv6(uint8_t *, const uint8_t *, int, int);

 void ff_avg_pixels8_armv6(uint8_t *, const uint8_t *, int, int);

-void ff_add_pixels_clamped_armv6(const DCTELEM *block,

-                                 uint8_t *av_restrict pixels,

+void ff_add_pixels_clamped_armv6(const int16_t *block,

+                                 uint8_t *restrict pixels,

                                  int line_size);

-void ff_get_pixels_armv6(DCTELEM *block, const uint8_t *pixels, int stride);

-void ff_diff_pixels_armv6(DCTELEM *block, const uint8_t *s1,

+void ff_get_pixels_armv6(int16_t *block, const uint8_t *pixels, int stride);

+void ff_diff_pixels_armv6(int16_t *block, const uint8_t *s1,

                           const uint8_t *s2, int stride);

 int ff_pix_abs16_armv6(void *s, uint8_t *blk1, uint8_t *blk2,

@@ -25,12 +25,12 @@

 #include "libavcodec/dsputil.h"

 #include "dsputil_arm.h"

-void ff_simple_idct_neon(DCTELEM *data);

-void ff_simple_idct_put_neon(uint8_t *dest, int line_size, DCTELEM *data);

-void ff_simple_idct_add_neon(uint8_t *dest, int line_size, DCTELEM *data);

+void ff_simple_idct_neon(int16_t *data);

+void ff_simple_idct_put_neon(uint8_t *dest, int line_size, int16_t *data);

+void ff_simple_idct_add_neon(uint8_t *dest, int line_size, int16_t *data);

-void ff_clear_block_neon(DCTELEM *block);

-void ff_clear_blocks_neon(DCTELEM *blocks);

+void ff_clear_block_neon(int16_t *block);

+void ff_clear_blocks_neon(int16_t *blocks);

 void ff_put_pixels16_neon(uint8_t *, const uint8_t *, int, int);

 void ff_put_pixels16_x2_neon(uint8_t *, const uint8_t *, int, int);

@@ -62,9 +62,9 @@ void ff_avg_pixels8_x2_no_rnd_neon(uint8_t *, const uint8_t *, int, int);

 void ff_avg_pixels8_y2_no_rnd_neon(uint8_t *, const uint8_t *, int, int);

 void ff_avg_pixels8_xy2_no_rnd_neon(uint8_t *, const uint8_t *, int, int);

-void ff_add_pixels_clamped_neon(const DCTELEM *, uint8_t *, int);

-void ff_put_pixels_clamped_neon(const DCTELEM *, uint8_t *, int);

-void ff_put_signed_pixels_clamped_neon(const DCTELEM *, uint8_t *, int);

+void ff_add_pixels_clamped_neon(const int16_t *, uint8_t *, int);

+void ff_put_pixels_clamped_neon(const int16_t *, uint8_t *, int);

+void ff_put_signed_pixels_clamped_neon(const int16_t *, uint8_t *, int);

 void ff_put_h264_qpel16_mc00_neon(uint8_t *, uint8_t *, int);

 void ff_put_h264_qpel16_mc10_neon(uint8_t *, uint8_t *, int);

@@ -50,22 +50,22 @@ void ff_biweight_h264_pixels_4_neon(uint8_t *dst, uint8_t *src, int stride,

                                     int height, int log2_den, int weightd,

                                     int weights, int offset);

-void ff_h264_idct_add_neon(uint8_t *dst, DCTELEM *block, int stride);

-void ff_h264_idct_dc_add_neon(uint8_t *dst, DCTELEM *block, int stride);

+void ff_h264_idct_add_neon(uint8_t *dst, int16_t *block, int stride);

+void ff_h264_idct_dc_add_neon(uint8_t *dst, int16_t *block, int stride);

 void ff_h264_idct_add16_neon(uint8_t *dst, const int *block_offset,

-                             DCTELEM *block, int stride,

+                             int16_t *block, int stride,

                              const uint8_t nnzc[6*8]);

 void ff_h264_idct_add16intra_neon(uint8_t *dst, const int *block_offset,

-                                  DCTELEM *block, int stride,

+                                  int16_t *block, int stride,

                                   const uint8_t nnzc[6*8]);

 void ff_h264_idct_add8_neon(uint8_t **dest, const int *block_offset,

-                            DCTELEM *block, int stride,

+                            int16_t *block, int stride,

                             const uint8_t nnzc[6*8]);

-void ff_h264_idct8_add_neon(uint8_t *dst, DCTELEM *block, int stride);

-void ff_h264_idct8_dc_add_neon(uint8_t *dst, DCTELEM *block, int stride);

+void ff_h264_idct8_add_neon(uint8_t *dst, int16_t *block, int stride);

+void ff_h264_idct8_dc_add_neon(uint8_t *dst, int16_t *block, int stride);

 void ff_h264_idct8_add4_neon(uint8_t *dst, const int *block_offset,

-                             DCTELEM *block, int stride,

+                             int16_t *block, int stride,

                              const uint8_t nnzc[6*8]);

 static void ff_h264dsp_init_neon(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)

@@ -66,7 +66,7 @@ row_loop:

         ldrsh r2, [lr, # 2]             @ r2 = 'd2'

         @ Optimization for row that have all items except the first set to 0

-        @ (this works as the DCTELEMS are always 4-byte aligned)

+        @ (this works as the int16_t are always 4-byte aligned)

         ldr r5, [lr, # 0]

         ldr r6, [lr, # 4]

         ldr r3, [lr, # 8]

@@ -34,9 +34,9 @@ CHK_OFFS(MpegEncContext, inter_scantable.raster_end, INTER_SCANTAB_RASTER_END);

 CHK_OFFS(MpegEncContext, h263_aic,         H263_AIC);

 #endif

-void ff_dct_unquantize_h263_inter_neon(MpegEncContext *s, DCTELEM *block,

+void ff_dct_unquantize_h263_inter_neon(MpegEncContext *s, int16_t *block,

                                        int n, int qscale);

-void ff_dct_unquantize_h263_intra_neon(MpegEncContext *s, DCTELEM *block,

+void ff_dct_unquantize_h263_intra_neon(MpegEncContext *s, int16_t *block,

                                        int n, int qscale);

 void ff_MPV_common_init_arm(MpegEncContext *s)

@@ -25,7 +25,7 @@

 #include "libavcodec/mpegvideo.h"

 #include "mpegvideo_arm.h"

-void ff_dct_unquantize_h263_armv5te(DCTELEM *block, int qmul, int qadd, int count);

+void ff_dct_unquantize_h263_armv5te(int16_t *block, int qmul, int qadd, int count);

 #ifdef ENABLE_ARM_TESTS

 /**

@@ -33,7 +33,7 @@ void ff_dct_unquantize_h263_armv5te(DCTELEM *block, int qmul, int qadd, int coun

  * have optimized implementations for each architecture. Is also used as a reference

  * implementation in regression tests

  */

-static inline void dct_unquantize_h263_helper_c(DCTELEM *block, int qmul, int qadd, int count)

+static inline void dct_unquantize_h263_helper_c(int16_t *block, int qmul, int qadd, int count)

 {

     int i, level;

     for (i = 0; i < count; i++) {

@@ -51,7 +51,7 @@ static inline void dct_unquantize_h263_helper_c(DCTELEM *block, int qmul, int qa

 #endif

 static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s,

-                                  DCTELEM *block, int n, int qscale)

+                                  int16_t *block, int n, int qscale)

 {

     int level, qmul, qadd;

     int nCoeffs;

@@ -80,7 +80,7 @@ static void dct_unquantize_h263_intra_armv5te(MpegEncContext *s,

 }

 static void dct_unquantize_h263_inter_armv5te(MpegEncContext *s,

-                                  DCTELEM *block, int n, int qscale)

+                                  int16_t *block, int n, int qscale)

 {

     int qmul, qadd;

     int nCoeffs;

@@ -24,11 +24,11 @@

 #include "libavcodec/rv34dsp.h"

 #include "libavutil/arm/cpu.h"

-void ff_rv34_inv_transform_noround_neon(DCTELEM *block);

+void ff_rv34_inv_transform_noround_neon(int16_t *block);

-void ff_rv34_inv_transform_noround_dc_neon(DCTELEM *block);

+void ff_rv34_inv_transform_noround_dc_neon(int16_t *block);

-void ff_rv34_idct_add_neon(uint8_t *dst, ptrdiff_t stride, DCTELEM *block);

+void ff_rv34_idct_add_neon(uint8_t *dst, ptrdiff_t stride, int16_t *block);

 void ff_rv34_idct_dc_add_neon(uint8_t *dst, ptrdiff_t stride, int dc);

 void ff_rv34dsp_init_arm(RV34DSPContext *c, DSPContext* dsp)

@@ -67,7 +67,7 @@

         vsub.s32        q15, q14, q9    @ z0 - z3

 .endm

-/* void rv34_idct_add_c(uint8_t *dst, int stride, DCTELEM *block) */

+/* void rv34_idct_add_c(uint8_t *dst, int stride, int16_t *block) */

 function ff_rv34_idct_add_neon, export=1

         mov             r3,  r0

         rv34_inv_transform   r2

@@ -97,7 +97,7 @@ function ff_rv34_idct_add_neon, export=1

         bx              lr

 endfunc

-/* void rv34_inv_transform_noround_neon(DCTELEM *block); */

+/* void rv34_inv_transform_noround_neon(int16_t *block); */

 function ff_rv34_inv_transform_noround_neon, export=1

         rv34_inv_transform   r0

         vshl.s32        q11, q2,  #1

@@ -142,7 +142,7 @@ function ff_rv34_idct_dc_add_neon, export=1

         bx              lr

 endfunc

-/* void rv34_inv_transform_dc_noround_c(DCTELEM *block) */

+/* void rv34_inv_transform_dc_noround_c(int16_t *block) */

 function ff_rv34_inv_transform_noround_dc_neon, export=1

         vld1.16         {d28[]}, [r0,:16]       @ block[0]

         vmov.i16        d4,  #251

@@ -375,7 +375,7 @@ endfunc

         sub    r0, r0, #(16*7)

         .endm

-/* void ff_simple_idct_armv6(DCTELEM *data); */

+/* void ff_simple_idct_armv6(int16_t *data); */

 function ff_simple_idct_armv6, export=1

         push   {r4-r11, lr}

         sub    sp, sp, #128

@@ -390,7 +390,7 @@ function ff_simple_idct_armv6, export=1

         pop    {r4-r11, pc}

 endfunc

-/* ff_simple_idct_add_armv6(uint8_t *dest, int line_size, DCTELEM *data); */

+/* ff_simple_idct_add_armv6(uint8_t *dest, int line_size, int16_t *data); */

 function ff_simple_idct_add_armv6, export=1

         push   {r0, r1, r4-r11, lr}

         sub    sp, sp, #128

@@ -407,7 +407,7 @@ function ff_simple_idct_add_armv6, export=1

         pop    {r4-r11, pc}

 endfunc

-/* ff_simple_idct_put_armv6(uint8_t *dest, int line_size, DCTELEM *data); */

+/* ff_simple_idct_put_armv6(uint8_t *dest, int line_size, int16_t *data); */

 function ff_simple_idct_put_armv6, export=1

         push   {r0, r1, r4-r11, lr}

         sub    sp, sp, #128

@@ -261,7 +261,7 @@ endconst

         pop             {r4-r7, pc}

         .endm

-/* void ff_simple_idct_put_neon(uint8_t *dst, int line_size, DCTELEM *data); */

+/* void ff_simple_idct_put_neon(uint8_t *dst, int line_size, int16_t *data); */

 function ff_simple_idct_put_neon, export=1

         idct_start      r2

@@ -316,7 +316,7 @@ function idct_col4_add8_neon

         bx              lr

 endfunc

-/* void ff_simple_idct_add_neon(uint8_t *dst, int line_size, DCTELEM *data); */

+/* void ff_simple_idct_add_neon(uint8_t *dst, int line_size, int16_t *data); */

 function ff_simple_idct_add_neon, export=1

         idct_start      r2

@@ -355,7 +355,7 @@ function idct_col4_st16_neon

         bx              lr

 endfunc

-/* void ff_simple_idct_neon(DCTELEM *data); */

+/* void ff_simple_idct_neon(int16_t *data); */

 function ff_simple_idct_neon, export=1

         idct_start      r0

@@ -24,9 +24,9 @@

 #include "libavcodec/dsputil.h"

 #include "libavcodec/vp3dsp.h"

-void ff_vp3_idct_put_neon(uint8_t *dest, int line_size, DCTELEM *data);

-void ff_vp3_idct_add_neon(uint8_t *dest, int line_size, DCTELEM *data);

-void ff_vp3_idct_dc_add_neon(uint8_t *dest, int line_size, const DCTELEM *data);

+void ff_vp3_idct_put_neon(uint8_t *dest, int line_size, int16_t *data);

+void ff_vp3_idct_add_neon(uint8_t *dest, int line_size, int16_t *data);

+void ff_vp3_idct_dc_add_neon(uint8_t *dest, int line_size, const int16_t *data);

 void ff_vp3_v_loop_filter_neon(uint8_t *, int, int *);

 void ff_vp3_h_loop_filter_neon(uint8_t *, int, int *);

@@ -23,7 +23,7 @@

 #if HAVE_ARMV6_EXTERNAL

 #define decode_block_coeffs_internal ff_decode_block_coeffs_armv6

-int ff_decode_block_coeffs_armv6(VP56RangeCoder *rc, DCTELEM block[16],

+int ff_decode_block_coeffs_armv6(VP56RangeCoder *rc, int16_t block[16],

                                  uint8_t probs[8][3][NUM_DCT_TOKENS-1],

                                  int i, uint8_t *token_prob, int16_t qmul[2]);

 #endif

@@ -56,7 +56,7 @@

 @ idct

-@ void vp8_luma_dc_wht(DCTELEM block[4][4][16], DCTELEM dc[16])

+@ void vp8_luma_dc_wht(int16_t block[4][4][16], int16_t dc[16])

 function ff_vp8_luma_dc_wht_armv6, export=1

         push            {r4-r10, lr}

@@ -179,7 +179,7 @@ function ff_vp8_luma_dc_wht_armv6, export=1

         pop             {r4-r10, pc}

 endfunc

-@ void vp8_luma_dc_wht_dc(DCTELEM block[4][4][16], DCTELEM dc[16])

+@ void vp8_luma_dc_wht_dc(int16_t block[4][4][16], int16_t dc[16])

 function ff_vp8_luma_dc_wht_dc_armv6, export=1

         ldrsh           r2,  [r1]

         mov             r3,  #0

@@ -192,7 +192,7 @@ function ff_vp8_luma_dc_wht_dc_armv6, export=1

         bx              lr

 endfunc

-@ void vp8_idct_add(uint8_t *dst, DCTELEM block[16], int stride)

+@ void vp8_idct_add(uint8_t *dst, int16_t block[16], int stride)

 function ff_vp8_idct_add_armv6, export=1

         push            {r4-r12, lr}

         sub             sp,  sp,  #32

@@ -314,7 +314,7 @@ function ff_vp8_idct_add_armv6, export=1

         pop             {r4-r12, pc}

 endfunc

-@ void vp8_idct_dc_add(uint8_t *dst, DCTELEM block[16], int stride)

+@ void vp8_idct_dc_add(uint8_t *dst, int16_t block[16], int stride)

 function ff_vp8_idct_dc_add_armv6, export=1

         push            {r4-r6, lr}

         add             r6,  r0,  r2,  lsl #1

@@ -355,7 +355,7 @@ function ff_vp8_idct_dc_add_armv6, export=1

         pop             {r4-r6, pc}

 endfunc

-@ void vp8_idct_dc_add4uv(uint8_t *dst, DCTELEM block[4][16], int stride)

+@ void vp8_idct_dc_add4uv(uint8_t *dst, int16_t block[4][16], int stride)

 function ff_vp8_idct_dc_add4uv_armv6, export=1

         push            {r4, lr}

@@ -371,7 +371,7 @@ function ff_vp8_idct_dc_add4uv_armv6, export=1

         pop             {r4, pc}

 endfunc

-@ void vp8_idct_dc_add4y(uint8_t *dst, DCTELEM block[4][16], int stride)

+@ void vp8_idct_dc_add4y(uint8_t *dst, int16_t block[4][16], int stride)

 function ff_vp8_idct_dc_add4y_armv6, export=1

         push            {r4, lr}

@@ -22,13 +22,13 @@

 #include "libavcodec/vp8dsp.h"

 #include "vp8dsp.h"

-void ff_vp8_luma_dc_wht_armv6(DCTELEM block[4][4][16], DCTELEM dc[16]);

-void ff_vp8_luma_dc_wht_dc_armv6(DCTELEM block[4][4][16], DCTELEM dc[16]);

+void ff_vp8_luma_dc_wht_armv6(int16_t block[4][4][16], int16_t dc[16]);

+void ff_vp8_luma_dc_wht_dc_armv6(int16_t block[4][4][16], int16_t dc[16]);

-void ff_vp8_idct_add_armv6(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add_armv6(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add4y_armv6(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add4uv_armv6(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride);

+void ff_vp8_idct_add_armv6(uint8_t *dst, int16_t block[16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add_armv6(uint8_t *dst, int16_t block[16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add4y_armv6(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add4uv_armv6(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);

 VP8_LF(armv6);

@@ -22,12 +22,12 @@

 #include "libavcodec/vp8dsp.h"

 #include "vp8dsp.h"

-void ff_vp8_luma_dc_wht_neon(DCTELEM block[4][4][16], DCTELEM dc[16]);

+void ff_vp8_luma_dc_wht_neon(int16_t block[4][4][16], int16_t dc[16]);

-void ff_vp8_idct_add_neon(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add_neon(uint8_t *dst, DCTELEM block[16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add4y_neon(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride);

-void ff_vp8_idct_dc_add4uv_neon(uint8_t *dst, DCTELEM block[4][16], ptrdiff_t stride);

+void ff_vp8_idct_add_neon(uint8_t *dst, int16_t block[16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add_neon(uint8_t *dst, int16_t block[16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add4y_neon(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);

+void ff_vp8_idct_dc_add4uv_neon(uint8_t *dst, int16_t block[4][16], ptrdiff_t stride);

 VP8_LF(neon);

@@ -48,7 +48,7 @@ typedef struct ASV1Context{

     int mb_height;

     int mb_width2;

     int mb_height2;

-    DECLARE_ALIGNED(16, DCTELEM, block)[6][64];

+    DECLARE_ALIGNED(16, int16_t, block)[6][64];

     uint16_t intra_matrix[64];

     int q_intra_matrix[64];

     uint8_t *bitstream_buffer;

@@ -94,7 +94,7 @@ static inline int asv2_get_level(GetBitContext *gb)

         return code - 31;

 }

-static inline int asv1_decode_block(ASV1Context *a, DCTELEM block[64])

+static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])

 {

     int i;

@@ -125,7 +125,7 @@ static inline int asv1_decode_block(ASV1Context *a, DCTELEM block[64])

     return 0;

 }

-static inline int asv2_decode_block(ASV1Context *a, DCTELEM block[64])

+static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])

 {

     int i, count, ccp;

@@ -161,7 +161,7 @@ static inline int asv2_decode_block(ASV1Context *a, DCTELEM block[64])

     return 0;

 }

-static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64])

+static inline int decode_mb(ASV1Context *a, int16_t block[6][64])

 {

     int i;

@@ -183,7 +183,7 @@ static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64])

 static inline void idct_put(ASV1Context *a, int mb_x, int mb_y)

 {

-    DCTELEM (*block)[64] = a->block;

+    int16_t (*block)[64] = a->block;

     int linesize         = a->picture.linesize[0];

     uint8_t *dest_y  = a->picture.data[0] + (mb_y * 16* linesize              ) + mb_x * 16;

@@ -56,7 +56,7 @@ static inline void asv2_put_level(PutBitContext *pb, int level){

     }

 }

-static inline void asv1_encode_block(ASV1Context *a, DCTELEM block[64]){

+static inline void asv1_encode_block(ASV1Context *a, int16_t block[64]){

     int i;

     int nc_count=0;

@@ -89,7 +89,7 @@ static inline void asv1_encode_block(ASV1Context *a, DCTELEM block[64]){

     put_bits(&a->pb, ff_asv_ccp_tab[16][1], ff_asv_ccp_tab[16][0]);

 }

-static inline void asv2_encode_block(ASV1Context *a, DCTELEM block[64]){

+static inline void asv2_encode_block(ASV1Context *a, int16_t block[64]){

     int i;

     int count=0;

@@ -130,7 +130,7 @@ static inline void asv2_encode_block(ASV1Context *a, DCTELEM block[64]){

 #define MAX_MB_SIZE (30*16*16*3/2/8)

-static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){

+static inline int encode_mb(ASV1Context *a, int16_t block[6][64]){

     int i;

     if (a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb)>>3) < MAX_MB_SIZE) {

@@ -149,7 +149,7 @@ static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){

 }

 static inline void dct_get(ASV1Context *a, int mb_x, int mb_y){

-    DCTELEM (*block)[64]= a->block;

+    int16_t (*block)[64]= a->block;

     int linesize= a->picture.linesize[0];

     int i;

@@ -21,7 +21,7 @@

    low level assembler interface wrapper

 DEFUN(put_pixels_clamped,mL1,

-        (DCTELEM *block, uint8_t *dest, int line_size)):

+        (int16_t *block, uint8_t *dest, int line_size)):

       body

@@ -27,20 +27,20 @@

 int off;

-static void bfin_idct_add (uint8_t *dest, int line_size, DCTELEM *block)

+static void bfin_idct_add (uint8_t *dest, int line_size, int16_t *block)

 {

     ff_bfin_idct (block);

     ff_bfin_add_pixels_clamped (block, dest, line_size);

 }

-static void bfin_idct_put (uint8_t *dest, int line_size, DCTELEM *block)

+static void bfin_idct_put (uint8_t *dest, int line_size, int16_t *block)

 {

     ff_bfin_idct (block);

     ff_bfin_put_pixels_clamped (block, dest, line_size);

 }

-static void bfin_clear_blocks (DCTELEM *blocks)

+static void bfin_clear_blocks (int16_t *blocks)

 {

     // This is just a simple memset.