dsputil.h 31.1 KB
Newer Older
1 2
/*
 * DSP utils
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14 15 16 17 18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
19
 * License along with FFmpeg; if not, write to the Free Software
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
22 23

/**
24
 * @file
Michael Niedermayer's avatar
Michael Niedermayer committed
25
 * DSP utils.
26 27
 * note, many functions in here may use MMX which trashes the FPU state, it is
 * absolutely necessary to call emms_c() between dsp & float/double code
Michael Niedermayer's avatar
Michael Niedermayer committed
28 29
 */

30 31
#ifndef AVCODEC_DSPUTIL_H
#define AVCODEC_DSPUTIL_H
Fabrice Bellard's avatar
Fabrice Bellard committed
32

33
#include "libavutil/intreadwrite.h"
34
#include "avcodec.h"
Fabrice Bellard's avatar
Fabrice Bellard committed
35

Michael Niedermayer's avatar
Michael Niedermayer committed
36

Michael Niedermayer's avatar
Michael Niedermayer committed
37
//#define DEBUG
Fabrice Bellard's avatar
Fabrice Bellard committed
38 39 40
/* dct code */
typedef short DCTELEM;

41
void fdct_ifast (DCTELEM *data);
42
void fdct_ifast248 (DCTELEM *data);
43 44 45 46
void ff_jpeg_fdct_islow_8(DCTELEM *data);
void ff_jpeg_fdct_islow_10(DCTELEM *data);
void ff_fdct248_islow_8(DCTELEM *data);
void ff_fdct248_islow_10(DCTELEM *data);
Fabrice Bellard's avatar
Fabrice Bellard committed
47 48

void j_rev_dct (DCTELEM *data);
49
void j_rev_dct4 (DCTELEM *data);
50
void j_rev_dct2 (DCTELEM *data);
51
void j_rev_dct1 (DCTELEM *data);
52
void ff_wmv2_idct_c(DCTELEM *data);
Fabrice Bellard's avatar
Fabrice Bellard committed
53

54
void ff_fdct_mmx(DCTELEM *block);
55
void ff_fdct_mmx2(DCTELEM *block);
56
void ff_fdct_sse2(DCTELEM *block);
Fabrice Bellard's avatar
Fabrice Bellard committed
57

58 59 60 61 62 63 64 65
#define H264_IDCT(depth) \
void ff_h264_idct8_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
void ff_h264_idct_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
void ff_h264_idct8_dc_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
void ff_h264_idct_dc_add_ ## depth ## _c(uint8_t *dst, DCTELEM *block, int stride);\
void ff_h264_idct_add16_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
void ff_h264_idct_add16intra_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
void ff_h264_idct8_add4_ ## depth ## _c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
66
void ff_h264_idct_add8_422_ ## depth ## _c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
67 68
void ff_h264_idct_add8_ ## depth ## _c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);\
void ff_h264_luma_dc_dequant_idct_ ## depth ## _c(DCTELEM *output, DCTELEM *input, int qmul);\
69
void ff_h264_chroma422_dc_dequant_idct_ ## depth ## _c(DCTELEM *block, int qmul);\
70 71 72 73 74 75
void ff_h264_chroma_dc_dequant_idct_ ## depth ## _c(DCTELEM *block, int qmul);

H264_IDCT( 8)
H264_IDCT( 9)
H264_IDCT(10)

76
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp);
77 78
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, int dc);

79
/* encoding scans */
80 81 82
extern const uint8_t ff_alternate_horizontal_scan[64];
extern const uint8_t ff_alternate_vertical_scan[64];
extern const uint8_t ff_zigzag_direct[64];
83
extern const uint8_t ff_zigzag248_direct[64];
84

Fabrice Bellard's avatar
Fabrice Bellard committed
85
/* pixel operations */
86
#define MAX_NEG_CROP 1024
Fabrice Bellard's avatar
Fabrice Bellard committed
87 88

/* temporary */
89
extern uint32_t ff_squareTbl[512];
90
extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
Fabrice Bellard's avatar
Fabrice Bellard committed
91

92 93 94 95 96 97 98 99 100 101 102 103 104 105
#define PUTAVG_PIXELS(depth)\
void ff_put_pixels8x8_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
void ff_avg_pixels8x8_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
void ff_put_pixels16x16_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);\
void ff_avg_pixels16x16_ ## depth ## _c(uint8_t *dst, uint8_t *src, int stride);

PUTAVG_PIXELS( 8)
PUTAVG_PIXELS( 9)
PUTAVG_PIXELS(10)

#define ff_put_pixels8x8_c ff_put_pixels8x8_8_c
#define ff_avg_pixels8x8_c ff_avg_pixels8x8_8_c
#define ff_put_pixels16x16_c ff_put_pixels16x16_8_c
#define ff_avg_pixels16x16_c ff_avg_pixels16x16_8_c
106

107
/* VP3 DSP functions */
108 109 110
void ff_vp3_idct_c(DCTELEM *block/* align 16*/);
void ff_vp3_idct_put_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
void ff_vp3_idct_add_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
David Conrad's avatar
David Conrad committed
111
void ff_vp3_idct_dc_add_c(uint8_t *dest/*align 8*/, int line_size, const DCTELEM *block/*align 16*/);
Fabrice Bellard's avatar
Fabrice Bellard committed
112

113 114 115
void ff_vp3_v_loop_filter_c(uint8_t *src, int stride, int *bounding_values);
void ff_vp3_h_loop_filter_c(uint8_t *src, int stride, int *bounding_values);

116 117 118
/* EA functions */
void ff_ea_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block);

119 120 121 122 123 124
/* RV40 functions */
void ff_put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride);
void ff_avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride);
void ff_put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride);
void ff_avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride);

125 126 127 128
/* 1/2^n downscaling functions from imgconvert.c */
void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
129 130 131

void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
              int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
132

Michael Niedermayer's avatar
Michael Niedermayer committed
133
/* minimum alignment rules ;)
Diego Biurrun's avatar
Diego Biurrun committed
134 135 136 137 138 139
If you notice errors in the align stuff, need more alignment for some ASM code
for some CPU or need to use a function with less aligned data then send a mail
to the ffmpeg-devel mailing list, ...

!warning These alignments might not match reality, (missing attribute((align))
stuff somewhere possible).
Diego Biurrun's avatar
Diego Biurrun committed
140
I (Michael) did not check them, these are just the alignments which I think
Diego Biurrun's avatar
Diego Biurrun committed
141
could be reached easily ...
Fabrice Bellard's avatar
Fabrice Bellard committed
142

Michael Niedermayer's avatar
Michael Niedermayer committed
143 144 145
!future video codecs might need functions with less strict alignment
*/

146
/*
147 148 149 150
void get_pixels_c(DCTELEM *block, const uint8_t *pixels, int line_size);
void diff_pixels_c(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride);
void put_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
void add_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size);
151
void clear_blocks_c(DCTELEM *blocks);
152
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
153 154

/* add and put pixel (decoding) */
Michael Niedermayer's avatar
Michael Niedermayer committed
155
// blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16
156
//h for op_pixels_func is limited to {width/2, width} but never larger than 16 and never smaller than 4
157
typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
158
typedef void (*tpel_mc_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int w, int h);
159
typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
160
typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
Michael Niedermayer's avatar
Michael Niedermayer committed
161

Kostya Shishkov's avatar
Kostya Shishkov committed
162 163
typedef void (*op_fill_func)(uint8_t *block/*align width (8 or 16)*/, uint8_t value, int line_size, int h);

Michael Niedermayer's avatar
Michael Niedermayer committed
164
#define DEF_OLD_QPEL(name)\
165 166 167
void ff_put_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
void ff_put_no_rnd_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
void ff_avg_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
Michael Niedermayer's avatar
Michael Niedermayer committed
168 169 170 171 172 173 174 175 176 177 178 179 180

DEF_OLD_QPEL(qpel16_mc11_old_c)
DEF_OLD_QPEL(qpel16_mc31_old_c)
DEF_OLD_QPEL(qpel16_mc12_old_c)
DEF_OLD_QPEL(qpel16_mc32_old_c)
DEF_OLD_QPEL(qpel16_mc13_old_c)
DEF_OLD_QPEL(qpel16_mc33_old_c)
DEF_OLD_QPEL(qpel8_mc11_old_c)
DEF_OLD_QPEL(qpel8_mc31_old_c)
DEF_OLD_QPEL(qpel8_mc12_old_c)
DEF_OLD_QPEL(qpel8_mc32_old_c)
DEF_OLD_QPEL(qpel8_mc13_old_c)
DEF_OLD_QPEL(qpel8_mc33_old_c)
Michael Niedermayer's avatar
Michael Niedermayer committed
181 182 183 184 185 186

#define CALL_2X_PIXELS(a, b, n)\
static void a(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
    b(block  , pixels  , line_size, h);\
    b(block+n, pixels+n, line_size, h);\
}
Michael Niedermayer's avatar
Michael Niedermayer committed
187

Fabrice Bellard's avatar
Fabrice Bellard committed
188
/* motion estimation */
189
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller than 2
Diego Biurrun's avatar
Diego Biurrun committed
190
// although currently h<4 is not used as functions with width <8 are neither used nor implemented
191
typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size, int h)/* __attribute__ ((const))*/;
Michael Niedermayer's avatar
Michael Niedermayer committed
192

193 194 195 196 197 198 199
/**
 * Scantable.
 */
typedef struct ScanTable{
    const uint8_t *scantable;
    uint8_t permutated[64];
    uint8_t raster_end[64];
200
#if ARCH_PPC
201
                /** Used by dct_quantize_altivec to find last-non-zero */
202
    DECLARE_ALIGNED(16, uint8_t, inverse)[64];
203 204 205 206
#endif
} ScanTable;

void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable);
207 208
void ff_init_scantable_permutation(uint8_t *idct_permutation,
                                   int idct_permutation_type);
209

210 211 212
#define EMULATED_EDGE(depth) \
void ff_emulated_edge_mc_ ## depth (uint8_t *buf, const uint8_t *src, int linesize,\
                         int block_w, int block_h,\
213 214
                         int src_x, int src_y, int w, int h);

215 216 217 218
EMULATED_EDGE(8)
EMULATED_EDGE(9)
EMULATED_EDGE(10)

219 220 221 222
void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);
void ff_put_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);
void ff_put_signed_pixels_clamped_c(const DCTELEM *block, uint8_t *dest, int linesize);

Michael Niedermayer's avatar
Michael Niedermayer committed
223 224 225
/**
 * DSPContext.
 */
226
typedef struct DSPContext {
227 228 229 230 231
    /**
     * Size of DCT coefficients.
     */
    int dct_bits;

232
    /* pixel ops : interface with DCT */
233 234 235
    void (*get_pixels)(DCTELEM *block/*align 16*/, const uint8_t *pixels/*align 8*/, int line_size);
    void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride);
    void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
236
    void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
237
    void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
Loren Merritt's avatar
Loren Merritt committed
238 239
    void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
    void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
240
    int (*sum_abs_dctelem)(DCTELEM *block/*align 16*/);
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
    /**
     * Motion estimation with emulated edge values.
     * @param buf pointer to destination buffer (unaligned)
     * @param src pointer to pixel source (unaligned)
     * @param linesize width (in pixels) for src/buf
     * @param block_w number of pixels (per row) to copy to buf
     * @param block_h nummber of pixel rows to copy to buf
     * @param src_x offset of src to start of row - this may be negative
     * @param src_y offset of src to top of image - this may be negative
     * @param w width of src in pixels
     * @param h height of src in pixels
     */
    void (*emulated_edge_mc)(uint8_t *buf, const uint8_t *src, int linesize,
                             int block_w, int block_h,
                             int src_x, int src_y, int w, int h);
Michael Niedermayer's avatar
Michael Niedermayer committed
256 257 258
    /**
     * translational global motion compensation.
     */
259
    void (*gmc1)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x16, int y16, int rounder);
Michael Niedermayer's avatar
Michael Niedermayer committed
260 261 262
    /**
     * global motion compensation.
     */
263
    void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy,
264
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
Loren Merritt's avatar
Loren Merritt committed
265
    void (*clear_block)(DCTELEM *block/*align 16*/);
266
    void (*clear_blocks)(DCTELEM *blocks/*align 16*/);
267 268
    int (*pix_sum)(uint8_t * pix, int line_size);
    int (*pix_norm1)(uint8_t * pix, int line_size);
269
// 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4
270

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
    me_cmp_func sad[6]; /* identical to pix_absAxA except additional void * */
    me_cmp_func sse[6];
    me_cmp_func hadamard8_diff[6];
    me_cmp_func dct_sad[6];
    me_cmp_func quant_psnr[6];
    me_cmp_func bit[6];
    me_cmp_func rd[6];
    me_cmp_func vsad[6];
    me_cmp_func vsse[6];
    me_cmp_func nsse[6];
    me_cmp_func w53[6];
    me_cmp_func w97[6];
    me_cmp_func dct_max[6];
    me_cmp_func dct264_sad[6];

    me_cmp_func me_pre_cmp[6];
    me_cmp_func me_cmp[6];
    me_cmp_func me_sub_cmp[6];
    me_cmp_func mb_cmp[6];
    me_cmp_func ildct_cmp[6]; //only width 16 used
    me_cmp_func frame_skip_cmp[6]; //only width 8 used
292

293 294
    int (*ssd_int8_vs_int16)(const int8_t *pix1, const int16_t *pix2,
                             int size);
295

Michael Niedermayer's avatar
Michael Niedermayer committed
296 297
    /**
     * Halfpel motion compensation with rounding (a+b+1)>>1.
Luca Barbato's avatar
Luca Barbato committed
298
     * this is an array[4][4] of motion compensation functions for 4
299
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
300
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
301 302 303 304 305
     * @param block destination where the result is stored
     * @param pixels source
     * @param line_size number of bytes in a horizontal line of block
     * @param h height
     */
306
    op_pixels_func put_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
307 308 309

    /**
     * Halfpel motion compensation with rounding (a+b+1)>>1.
310
     * This is an array[4][4] of motion compensation functions for 4
311
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
312
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
313 314 315 316 317
     * @param block destination into which the result is averaged (a+b+1)>>1
     * @param pixels source
     * @param line_size number of bytes in a horizontal line of block
     * @param h height
     */
318
    op_pixels_func avg_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
319 320 321

    /**
     * Halfpel motion compensation with no rounding (a+b)>>1.
Luca Barbato's avatar
Luca Barbato committed
322
     * this is an array[2][4] of motion compensation functions for 2
Michael Niedermayer's avatar
Michael Niedermayer committed
323
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
324
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
325 326 327 328 329
     * @param block destination where the result is stored
     * @param pixels source
     * @param line_size number of bytes in a horizontal line of block
     * @param h height
     */
Michael Niedermayer's avatar
Michael Niedermayer committed
330
    op_pixels_func put_no_rnd_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
331 332 333

    /**
     * Halfpel motion compensation with no rounding (a+b)>>1.
Luca Barbato's avatar
Luca Barbato committed
334
     * this is an array[2][4] of motion compensation functions for 2
Michael Niedermayer's avatar
Michael Niedermayer committed
335
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
336
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
337 338 339 340 341
     * @param block destination into which the result is averaged (a+b)>>1
     * @param pixels source
     * @param line_size number of bytes in a horizontal line of block
     * @param h height
     */
Michael Niedermayer's avatar
Michael Niedermayer committed
342
    op_pixels_func avg_no_rnd_pixels_tab[4][4];
343

344
    void (*put_no_rnd_pixels_l2[2])(uint8_t *block/*align width (8 or 16)*/, const uint8_t *a/*align 1*/, const uint8_t *b/*align 1*/, int line_size, int h);
345

346 347
    /**
     * Thirdpel motion compensation with rounding (a+b+1)>>1.
Luca Barbato's avatar
Luca Barbato committed
348 349
     * this is an array[12] of motion compensation functions for the 9 thirdpe
     * positions<br>
350 351 352 353 354 355 356
     * *pixels_tab[ xthirdpel + 4*ythirdpel ]
     * @param block destination where the result is stored
     * @param pixels source
     * @param line_size number of bytes in a horizontal line of block
     * @param h height
     */
    tpel_mc_func put_tpel_pixels_tab[11]; //FIXME individual func ptr per width?
357 358
    tpel_mc_func avg_tpel_pixels_tab[11]; //FIXME individual func ptr per width?

359 360 361 362
    qpel_mc_func put_qpel_pixels_tab[2][16];
    qpel_mc_func avg_qpel_pixels_tab[2][16];
    qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16];
    qpel_mc_func avg_no_rnd_qpel_pixels_tab[2][16];
Michael Niedermayer's avatar
Michael Niedermayer committed
363
    qpel_mc_func put_mspel_pixels_tab[8];
364

365
    /**
Luca Barbato's avatar
Luca Barbato committed
366
     * h264 Chroma MC
367 368 369
     */
    h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
    h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
370

371 372
    qpel_mc_func put_h264_qpel_pixels_tab[4][16];
    qpel_mc_func avg_h264_qpel_pixels_tab[4][16];
373

374 375 376
    qpel_mc_func put_2tap_qpel_pixels_tab[4][16];
    qpel_mc_func avg_2tap_qpel_pixels_tab[4][16];

377
    me_cmp_func pix_abs[2][4];
378

Michael Niedermayer's avatar
Michael Niedermayer committed
379 380
    /* huffyuv specific */
    void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);
Michael Niedermayer's avatar
Michael Niedermayer committed
381
    void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w);
382 383 384 385
    /**
     * subtract huffyuv's variant of median prediction
     * note, this might read from src1[-1], src2[-1]
     */
386 387
    void (*sub_hfyu_median_prediction)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top);
    void (*add_hfyu_median_prediction)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top);
388
    int  (*add_hfyu_left_prediction)(uint8_t *dst, const uint8_t *src, int w, int left);
389
    void (*add_hfyu_left_prediction_bgr32)(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha);
390
    /* this might write to dst[w] */
391
    void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w);
392
    void (*bswap16_buf)(uint16_t *dst, const uint16_t *src, int len);
393

Michael Niedermayer's avatar
Michael Niedermayer committed
394 395 396
    void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale);
    void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale);

397
    void (*h261_loop_filter)(uint8_t *src, int stride);
398

399 400 401
    void (*x8_v_loop_filter)(uint8_t *src, int stride, int qscale);
    void (*x8_h_loop_filter)(uint8_t *src, int stride, int qscale);

David Conrad's avatar
David Conrad committed
402
    void (*vp3_idct_dc_add)(uint8_t *dest/*align 8*/, int line_size, const DCTELEM *block/*align 16*/);
403 404 405
    void (*vp3_v_loop_filter)(uint8_t *src, int stride, int *bounding_values);
    void (*vp3_h_loop_filter)(uint8_t *src, int stride, int *bounding_values);

406
    /* assume len is a multiple of 4, and arrays are 16-byte aligned */
407
    void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
Loren Merritt's avatar
Loren Merritt committed
408
    void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);
409
    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
410
    void (*vector_fmul)(float *dst, const float *src0, const float *src1, int len);
411 412
    void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);
    /* assume len is a multiple of 8, and src arrays are 16-byte aligned */
413
    void (*vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len);
414
    /* assume len is a multiple of 4, and arrays are 16-byte aligned */
415
    void (*vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len);
Loren Merritt's avatar
Loren Merritt committed
416
    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
417
    void (*vector_clipf)(float *dst /* align 16 */, const float *src /* align 16 */, float min, float max, int len /* align 16 */);
418 419 420 421 422 423 424 425 426 427
    /**
     * Multiply a vector of floats by a scalar float.  Source and
     * destination vectors must overlap exactly or not at all.
     * @param dst result vector, 16-byte aligned
     * @param src input vector, 16-byte aligned
     * @param mul scalar value
     * @param len length of vector, multiple of 4
     */
    void (*vector_fmul_scalar)(float *dst, const float *src, float mul,
                               int len);
428 429 430 431 432 433 434 435 436 437 438
    /**
     * Multiply a vector of floats by a scalar float and add to
     * destination vector.  Source and destination vectors must
     * overlap exactly or not at all.
     * @param dst result vector, 16-byte aligned
     * @param src input vector, 16-byte aligned
     * @param mul scalar value
     * @param len length of vector, multiple of 4
     */
    void (*vector_fmac_scalar)(float *dst, const float *src, float mul,
                               int len);
439 440 441 442 443 444 445 446 447 448 449 450 451 452
    /**
     * Calculate the scalar product of two vectors of floats.
     * @param v1  first vector, 16-byte aligned
     * @param v2  second vector, 16-byte aligned
     * @param len length of vectors, multiple of 4
     */
    float (*scalarproduct_float)(const float *v1, const float *v2, int len);
    /**
     * Calculate the sum and difference of two vectors of floats.
     * @param v1  first input vector, sum output, 16-byte aligned
     * @param v2  second input vector, difference output, 16-byte aligned
     * @param len length of vectors, multiple of 4
     */
    void (*butterflies_float)(float *restrict v1, float *restrict v2, int len);
453

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470
    /**
     * Calculate the sum and difference of two vectors of floats and interleave
     * results into a separate output vector of floats, with each sum
     * positioned before the corresponding difference.
     *
     * @param dst  output vector
     *             constraints: 16-byte aligned
     * @param src0 first input vector
     *             constraints: 32-byte aligned
     * @param src1 second input vector
     *             constraints: 32-byte aligned
     * @param len  number of elements in the input
     *             constraints: multiple of 8
     */
    void (*butterflies_float_interleave)(float *dst, const float *src0,
                                         const float *src1, int len);

471 472
    /* (I)DCT */
    void (*fdct)(DCTELEM *block/* align 16*/);
473
    void (*fdct248)(DCTELEM *block/* align 16*/);
474

475 476
    /* IDCT really*/
    void (*idct)(DCTELEM *block/* align 16*/);
477

Michael Niedermayer's avatar
Michael Niedermayer committed
478
    /**
Michael Niedermayer's avatar
Michael Niedermayer committed
479
     * block -> idct -> clip to unsigned 8 bit -> dest.
Michael Niedermayer's avatar
Michael Niedermayer committed
480
     * (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
Panagiotis Issaris's avatar
Panagiotis Issaris committed
481
     * @param line_size size in bytes of a horizontal line of dest
Michael Niedermayer's avatar
Michael Niedermayer committed
482
     */
483
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
484

Michael Niedermayer's avatar
Michael Niedermayer committed
485 486
    /**
     * block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
Panagiotis Issaris's avatar
Panagiotis Issaris committed
487
     * @param line_size size in bytes of a horizontal line of dest
Michael Niedermayer's avatar
Michael Niedermayer committed
488
     */
489
    void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
490

Michael Niedermayer's avatar
Michael Niedermayer committed
491
    /**
Michael Niedermayer's avatar
Michael Niedermayer committed
492
     * idct input permutation.
493 494 495 496
     * several optimized IDCTs need a permutated input (relative to the normal order of the reference
     * IDCT)
     * this permutation must be performed before the idct_put/add, note, normally this can be merged
     * with the zigzag/alternate scan<br>
Michael Niedermayer's avatar
Michael Niedermayer committed
497 498
     * an example to avoid confusion:
     * - (->decode coeffs -> zigzag reorder -> dequant -> reference idct ->...)
499 500
     * - (x -> reference dct -> reference idct -> x)
     * - (x -> reference dct -> simple_mmx_perm = idct_permutation -> simple_idct_mmx -> x)
Michael Niedermayer's avatar
Michael Niedermayer committed
501 502
     * - (->decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant -> simple_idct_mmx ->...)
     */
503 504 505 506 507 508
    uint8_t idct_permutation[64];
    int idct_permutation_type;
#define FF_NO_IDCT_PERM 1
#define FF_LIBMPEG2_IDCT_PERM 2
#define FF_SIMPLE_IDCT_PERM 3
#define FF_TRANSPOSE_IDCT_PERM 4
509
#define FF_PARTTRANS_IDCT_PERM 5
510
#define FF_SSE2_IDCT_PERM 6
511

512 513 514 515
    int (*try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale);
    void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);
#define BASIS_SHIFT 16
#define RECON_SHIFT 6
516

517
    void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w, int h, int sides);
518
#define EDGE_WIDTH 16
519 520
#define EDGE_TOP    1
#define EDGE_BOTTOM 2
521

522
    void (*prefetch)(void *mem, int stride, int h);
523 524

    void (*shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
525

526
    /* mlp/truehd functions */
527 528
    void (*mlp_filter_channel)(int32_t *state, const int32_t *coeff,
                               int firorder, int iirorder,
529 530 531
                               unsigned int filter_shift, int32_t mask, int blocksize,
                               int32_t *sample_buffer);

532
    /* intrax8 functions */
533 534
    void (*x8_spatial_compensation[12])(uint8_t *src , uint8_t *dst, int linesize);
    void (*x8_setup_spatial_compensation)(uint8_t *src, uint8_t *dst, int linesize,
535 536
           int * range, int * sum,  int edges);

537 538
    /**
     * Calculate scalar product of two vectors.
539
     * @param len length of vectors, should be multiple of 16
540 541
     * @param shift number of bits to discard from product
     */
542
    int32_t (*scalarproduct_int16)(const int16_t *v1, const int16_t *v2/*align 16*/, int len, int shift);
543 544 545 546 547 548
    /* ape functions */
    /**
     * Calculate scalar product of v1 and v2,
     * and v1[i] += v3[i] * mul
     * @param len length of vectors, should be multiple of 16
     */
549
    int32_t (*scalarproduct_and_madd_int16)(int16_t *v1/*align 16*/, const int16_t *v2, const int16_t *v3, int len, int mul);
Kostya Shishkov's avatar
Kostya Shishkov committed
550

551 552 553 554 555 556 557 558 559 560 561 562 563 564
    /**
     * Apply symmetric window in 16-bit fixed-point.
     * @param output destination array
     *               constraints: 16-byte aligned
     * @param input  source array
     *               constraints: 16-byte aligned
     * @param window window array
     *               constraints: 16-byte aligned, at least len/2 elements
     * @param len    full window length
     *               constraints: multiple of ? greater than zero
     */
    void (*apply_window_int16)(int16_t *output, const int16_t *input,
                               const int16_t *window, unsigned int len);

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    /**
     * Clip each element in an array of int32_t to a given minimum and maximum value.
     * @param dst  destination array
     *             constraints: 16-byte aligned
     * @param src  source array
     *             constraints: 16-byte aligned
     * @param min  minimum value
     *             constraints: must in the the range [-(1<<24), 1<<24]
     * @param max  maximum value
     *             constraints: must in the the range [-(1<<24), 1<<24]
     * @param len  number of elements in the array
     *             constraints: multiple of 32 greater than zero
     */
    void (*vector_clip_int32)(int32_t *dst, const int32_t *src, int32_t min,
                              int32_t max, unsigned int len);

Kostya Shishkov's avatar
Kostya Shishkov committed
581
    op_fill_func fill_block_tab[2];
582 583
} DSPContext;

Måns Rullgård's avatar
Måns Rullgård committed
584
void dsputil_static_init(void);
585
void dsputil_init(DSPContext* p, AVCodecContext *avctx);
Fabrice Bellard's avatar
Fabrice Bellard committed
586

587 588
int ff_check_alignment(void);

589 590 591 592
/**
 * permute block according to permuatation.
 * @param last last non zero element in scantable order
 */
593
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
594

595 596
void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type);

597
#define         BYTE_VEC32(c)   ((c)*0x01010101UL)
598
#define         BYTE_VEC64(c)   ((c)*0x0001000100010001UL)
Michael Niedermayer's avatar
Michael Niedermayer committed
599 600 601 602 603 604 605 606 607 608 609

static inline uint32_t rnd_avg32(uint32_t a, uint32_t b)
{
    return (a | b) - (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1);
}

static inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b)
{
    return (a & b) + (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1);
}

610 611 612 613 614 615 616 617 618 619
static inline uint64_t rnd_avg64(uint64_t a, uint64_t b)
{
    return (a | b) - (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1);
}

static inline uint64_t no_rnd_avg64(uint64_t a, uint64_t b)
{
    return (a & b) + (((a ^ b) & ~BYTE_VEC64(0x01)) >> 1);
}

620 621 622 623 624 625 626 627 628 629 630 631
static inline int get_penalty_factor(int lambda, int lambda2, int type){
    switch(type&0xFF){
    default:
    case FF_CMP_SAD:
        return lambda>>FF_LAMBDA_SHIFT;
    case FF_CMP_DCT:
        return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
    case FF_CMP_W53:
        return (4*lambda)>>(FF_LAMBDA_SHIFT);
    case FF_CMP_W97:
        return (2*lambda)>>(FF_LAMBDA_SHIFT);
    case FF_CMP_SATD:
632
    case FF_CMP_DCT264:
633 634 635 636 637 638 639 640 641 642 643
        return (2*lambda)>>FF_LAMBDA_SHIFT;
    case FF_CMP_RD:
    case FF_CMP_PSNR:
    case FF_CMP_SSE:
    case FF_CMP_NSSE:
        return lambda2>>FF_LAMBDA_SHIFT;
    case FF_CMP_BIT:
        return 1;
    }
}

644
void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);
645
void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx);
646 647 648 649 650 651 652 653
void dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx);
void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx);

654
void ff_dsputil_init_dwt(DSPContext *c);
655 656 657 658
void ff_intrax8dsp_init(DSPContext* c, AVCodecContext *avctx);
void ff_mlp_init(DSPContext* c, AVCodecContext *avctx);
void ff_mlp_init_x86(DSPContext* c, AVCodecContext *avctx);

659

660
#if ARCH_ARM
Fabrice Bellard's avatar
Fabrice Bellard committed
661

Fabrice Bellard's avatar
Fabrice Bellard committed
662

663
#if HAVE_NEON
664 665 666
#   define STRIDE_ALIGN 16
#endif

667
#elif ARCH_PPC
668

669
#define STRIDE_ALIGN 16
670

671
#elif HAVE_MMI
672

673
#define STRIDE_ALIGN 16
674

675
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
676

677 678
#ifndef STRIDE_ALIGN
#   define STRIDE_ALIGN 8
Fabrice Bellard's avatar
Fabrice Bellard committed
679 680
#endif

681 682 683 684 685 686 687
#define LOCAL_ALIGNED_A(a, t, v, s, o, ...)             \
    uint8_t la_##v[sizeof(t s o) + (a)];                \
    t (*v) o = (void *)FFALIGN((uintptr_t)la_##v, a)

#define LOCAL_ALIGNED_D(a, t, v, s, o, ...) DECLARE_ALIGNED(a, t, v) s o

#define LOCAL_ALIGNED(a, t, v, ...) LOCAL_ALIGNED_A(a, t, v, __VA_ARGS__,,)
688 689

#if HAVE_LOCAL_ALIGNED_8
690
#   define LOCAL_ALIGNED_8(t, v, ...) LOCAL_ALIGNED_D(8, t, v, __VA_ARGS__,,)
691
#else
692
#   define LOCAL_ALIGNED_8(t, v, ...) LOCAL_ALIGNED(8, t, v, __VA_ARGS__)
693 694 695
#endif

#if HAVE_LOCAL_ALIGNED_16
696
#   define LOCAL_ALIGNED_16(t, v, ...) LOCAL_ALIGNED_D(16, t, v, __VA_ARGS__,,)
697
#else
698
#   define LOCAL_ALIGNED_16(t, v, ...) LOCAL_ALIGNED(16, t, v, __VA_ARGS__)
699 700
#endif

701
#define WRAPPER8_16(name8, name16)\
702 703 704 705 706
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
    return name8(s, dst           , src           , stride, h)\
          +name8(s, dst+8         , src+8         , stride, h);\
}

707
#define WRAPPER8_16_SQ(name8, name16)\
708 709 710 711 712 713 714 715 716 717 718
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
    int score=0;\
    score +=name8(s, dst           , src           , stride, 8);\
    score +=name8(s, dst+8         , src+8         , stride, 8);\
    if(h==16){\
        dst += 8*stride;\
        src += 8*stride;\
        score +=name8(s, dst           , src           , stride, 8);\
        score +=name8(s, dst+8         , src+8         , stride, 8);\
    }\
    return score;\
Michael Niedermayer's avatar
Michael Niedermayer committed
719 720
}

721

722
static inline void copy_block2(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
723 724 725 726
{
    int i;
    for(i=0; i<h; i++)
    {
727
        AV_WN16(dst   , AV_RN16(src   ));
728 729 730 731 732
        dst+=dstStride;
        src+=srcStride;
    }
}

733
static inline void copy_block4(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
734 735 736 737
{
    int i;
    for(i=0; i<h; i++)
    {
738
        AV_WN32(dst   , AV_RN32(src   ));
739 740 741 742 743
        dst+=dstStride;
        src+=srcStride;
    }
}

744
static inline void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
745 746 747 748
{
    int i;
    for(i=0; i<h; i++)
    {
749 750
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
751 752 753 754 755
        dst+=dstStride;
        src+=srcStride;
    }
}

756
static inline void copy_block9(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
757 758 759 760
{
    int i;
    for(i=0; i<h; i++)
    {
761 762
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
763 764 765 766 767 768
        dst[8]= src[8];
        dst+=dstStride;
        src+=srcStride;
    }
}

769
static inline void copy_block16(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
770 771 772 773
{
    int i;
    for(i=0; i<h; i++)
    {
774 775 776 777
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
        AV_WN32(dst+8 , AV_RN32(src+8 ));
        AV_WN32(dst+12, AV_RN32(src+12));
778 779 780 781 782
        dst+=dstStride;
        src+=srcStride;
    }
}

783
static inline void copy_block17(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
784 785 786 787
{
    int i;
    for(i=0; i<h; i++)
    {
788 789 790 791
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
        AV_WN32(dst+8 , AV_RN32(src+8 ));
        AV_WN32(dst+12, AV_RN32(src+12));
792 793 794 795 796 797
        dst[16]= src[16];
        dst+=dstStride;
        src+=srcStride;
    }
}

798
#endif /* AVCODEC_DSPUTIL_H */