dsputil.h 34.3 KB
Newer Older
Fabrice Bellard's avatar
Fabrice Bellard committed
1 2
/*
 * DSP utils
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
Fabrice Bellard's avatar
Fabrice Bellard committed
5
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
Fabrice Bellard's avatar
Fabrice Bellard committed
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.
Fabrice Bellard's avatar
Fabrice Bellard committed
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
Fabrice Bellard's avatar
Fabrice Bellard committed
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
Fabrice Bellard's avatar
Fabrice Bellard committed
21
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
22 23

/**
24
 * @file libavcodec/dsputil.h
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
/* dct code */
typedef short DCTELEM;
40
typedef int DWTELEM;
41
typedef short IDWTELEM;
Fabrice Bellard's avatar
Fabrice Bellard committed
42

43
void fdct_ifast (DCTELEM *data);
44
void fdct_ifast248 (DCTELEM *data);
45
void ff_jpeg_fdct_islow (DCTELEM *data);
46
void ff_fdct248_islow (DCTELEM *data);
Fabrice Bellard's avatar
Fabrice Bellard committed
47 48

void j_rev_dct (DCTELEM *data);
Michael Niedermayer's avatar
Michael Niedermayer committed
49
void j_rev_dct4 (DCTELEM *data);
Michael Niedermayer's avatar
Michael Niedermayer committed
50
void j_rev_dct2 (DCTELEM *data);
Michael Niedermayer's avatar
Michael Niedermayer committed
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
void ff_h264_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride);
59
void ff_h264_idct_add_c(uint8_t *dst, DCTELEM *block, int stride);
60 61
void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
62 63
void ff_h264_lowres_idct_add_c(uint8_t *dst, int stride, DCTELEM *block);
void ff_h264_lowres_idct_put_c(uint8_t *dst, int stride, DCTELEM *block);
64 65 66 67
void ff_h264_idct_add16_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);
void ff_h264_idct_add16intra_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);
void ff_h264_idct8_add4_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);
void ff_h264_idct_add8_c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]);
68

69 70
void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1,
                              const float *src2, int src3, int blocksize, int step);
Loren Merritt's avatar
Loren Merritt committed
71 72
void ff_vector_fmul_window_c(float *dst, const float *src0, const float *src1,
                             const float *win, float add_bias, int len);
Michael Niedermayer's avatar
Michael Niedermayer committed
73
void ff_float_to_int16_c(int16_t *dst, const float *src, long len);
74
void ff_float_to_int16_interleave_c(int16_t *dst, const float **src, long len, int channels);
75

76
/* encoding scans */
77 78 79
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];
80
extern const uint8_t ff_zigzag248_direct[64];
81

Fabrice Bellard's avatar
Fabrice Bellard committed
82
/* pixel operations */
83
#define MAX_NEG_CROP 1024
Fabrice Bellard's avatar
Fabrice Bellard committed
84 85

/* temporary */
86
extern uint32_t ff_squareTbl[512];
Måns Rullgård's avatar
Måns Rullgård committed
87
extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
Fabrice Bellard's avatar
Fabrice Bellard committed
88

89
/* VP3 DSP functions */
90 91 92
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*/);
Fabrice Bellard's avatar
Fabrice Bellard committed
93

94 95 96
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);

97 98 99 100 101
/* 1/2^n downscaling functions from imgconvert.c */
void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
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);
102 103 104

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);
105

Michael Niedermayer's avatar
Michael Niedermayer committed
106
/* minimum alignment rules ;)
Diego Biurrun's avatar
Diego Biurrun committed
107 108 109 110 111 112
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
113
I (Michael) did not check them, these are just the alignments which I think
Diego Biurrun's avatar
Diego Biurrun committed
114
could be reached easily ...
Fabrice Bellard's avatar
Fabrice Bellard committed
115

Michael Niedermayer's avatar
Michael Niedermayer committed
116 117 118
!future video codecs might need functions with less strict alignment
*/

119
/*
120 121 122 123
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);
124
void clear_blocks_c(DCTELEM *blocks);
125
*/
Fabrice Bellard's avatar
Fabrice Bellard committed
126 127

/* add and put pixel (decoding) */
Michael Niedermayer's avatar
Michael Niedermayer committed
128
// blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16
Michael Niedermayer's avatar
Michael Niedermayer committed
129
//h for op_pixels_func is limited to {width/2, width} but never larger than 16 and never smaller then 4
130
typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
131
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);
132
typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
Michael Niedermayer's avatar
Michael Niedermayer committed
133
typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
Loren Merritt's avatar
Loren Merritt committed
134
typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset);
Loren Merritt's avatar
Loren Merritt committed
135
typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset);
Michael Niedermayer's avatar
Michael Niedermayer committed
136

Michael Niedermayer's avatar
Michael Niedermayer committed
137
#define DEF_OLD_QPEL(name)\
138 139 140
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
141 142 143 144 145 146 147 148 149 150 151 152 153

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
154 155 156 157 158 159

#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
160

Fabrice Bellard's avatar
Fabrice Bellard committed
161
/* motion estimation */
Michael Niedermayer's avatar
Michael Niedermayer committed
162
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller then 2
Diego Biurrun's avatar
Diego Biurrun committed
163
// although currently h<4 is not used as functions with width <8 are neither used nor implemented
164
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
165

Michael Niedermayer's avatar
Michael Niedermayer committed
166

167 168 169
// for snow slices
typedef struct slice_buffer_s slice_buffer;

170 171 172 173 174 175 176
/**
 * Scantable.
 */
typedef struct ScanTable{
    const uint8_t *scantable;
    uint8_t permutated[64];
    uint8_t raster_end[64];
177
#if ARCH_PPC
178
                /** Used by dct_quantize_altivec to find last-non-zero */
Aurelien Jacobs's avatar
Aurelien Jacobs committed
179
    DECLARE_ALIGNED(16, uint8_t, inverse[64]);
180 181 182 183 184
#endif
} ScanTable;

void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable);

185 186 187 188
void ff_emulated_edge_mc(uint8_t *buf, 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
189 190 191
/**
 * DSPContext.
 */
192 193
typedef struct DSPContext {
    /* pixel ops : interface with DCT */
194 195 196
    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);
197
    void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
198
    void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
Loren Merritt's avatar
Loren Merritt committed
199 200
    void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
    void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
201
    int (*sum_abs_dctelem)(DCTELEM *block/*align 16*/);
Michael Niedermayer's avatar
Michael Niedermayer committed
202 203 204
    /**
     * translational global motion compensation.
     */
205
    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
206 207 208
    /**
     * global motion compensation.
     */
209
    void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy,
210
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
Loren Merritt's avatar
Loren Merritt committed
211
    void (*clear_block)(DCTELEM *block/*align 16*/);
212
    void (*clear_blocks)(DCTELEM *blocks/*align 16*/);
213 214
    int (*pix_sum)(uint8_t * pix, int line_size);
    int (*pix_norm1)(uint8_t * pix, int line_size);
215
// 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4
216

217 218 219 220 221 222 223 224 225
    me_cmp_func sad[5]; /* identical to pix_absAxA except additional void * */
    me_cmp_func sse[5];
    me_cmp_func hadamard8_diff[5];
    me_cmp_func dct_sad[5];
    me_cmp_func quant_psnr[5];
    me_cmp_func bit[5];
    me_cmp_func rd[5];
    me_cmp_func vsad[5];
    me_cmp_func vsse[5];
226
    me_cmp_func nsse[5];
Michael Niedermayer's avatar
Michael Niedermayer committed
227 228
    me_cmp_func w53[5];
    me_cmp_func w97[5];
229
    me_cmp_func dct_max[5];
230
    me_cmp_func dct264_sad[5];
Michael Niedermayer's avatar
Michael Niedermayer committed
231

232 233 234 235
    me_cmp_func me_pre_cmp[5];
    me_cmp_func me_cmp[5];
    me_cmp_func me_sub_cmp[5];
    me_cmp_func mb_cmp[5];
236
    me_cmp_func ildct_cmp[5]; //only width 16 used
237
    me_cmp_func frame_skip_cmp[5]; //only width 8 used
238

239 240
    int (*ssd_int8_vs_int16)(const int8_t *pix1, const int16_t *pix2,
                             int size);
241

Michael Niedermayer's avatar
Michael Niedermayer committed
242 243
    /**
     * Halfpel motion compensation with rounding (a+b+1)>>1.
Luca Barbato's avatar
Luca Barbato committed
244
     * this is an array[4][4] of motion compensation functions for 4
245
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
246
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
247 248 249 250 251
     * @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
     */
252
    op_pixels_func put_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
253 254 255

    /**
     * Halfpel motion compensation with rounding (a+b+1)>>1.
256
     * This is an array[4][4] of motion compensation functions for 4
257
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
258
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
259 260 261 262 263
     * @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
     */
264
    op_pixels_func avg_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
265 266 267

    /**
     * Halfpel motion compensation with no rounding (a+b)>>1.
Luca Barbato's avatar
Luca Barbato committed
268
     * this is an array[2][4] of motion compensation functions for 2
Michael Niedermayer's avatar
doxy  
Michael Niedermayer committed
269
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
270
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
271 272 273 274 275
     * @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
276
    op_pixels_func put_no_rnd_pixels_tab[4][4];
Michael Niedermayer's avatar
Michael Niedermayer committed
277 278 279

    /**
     * Halfpel motion compensation with no rounding (a+b)>>1.
Luca Barbato's avatar
Luca Barbato committed
280
     * this is an array[2][4] of motion compensation functions for 2
Michael Niedermayer's avatar
doxy  
Michael Niedermayer committed
281
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
282
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
Michael Niedermayer's avatar
Michael Niedermayer committed
283 284 285 286 287
     * @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
288
    op_pixels_func avg_no_rnd_pixels_tab[4][4];
289

290
    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);
291

292 293
    /**
     * Thirdpel motion compensation with rounding (a+b+1)>>1.
Luca Barbato's avatar
Luca Barbato committed
294 295
     * this is an array[12] of motion compensation functions for the 9 thirdpe
     * positions<br>
296 297 298 299 300 301 302
     * *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?
303 304
    tpel_mc_func avg_tpel_pixels_tab[11]; //FIXME individual func ptr per width?

305 306 307 308
    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
309
    qpel_mc_func put_mspel_pixels_tab[8];
310

Michael Niedermayer's avatar
Michael Niedermayer committed
311
    /**
Luca Barbato's avatar
Luca Barbato committed
312
     * h264 Chroma MC
Michael Niedermayer's avatar
Michael Niedermayer committed
313 314
     */
    h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
315 316
    /* This is really one func used in VC-1 decoding */
    h264_chroma_mc_func put_no_rnd_h264_chroma_pixels_tab[3];
Michael Niedermayer's avatar
Michael Niedermayer committed
317
    h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
318

319 320
    qpel_mc_func put_h264_qpel_pixels_tab[4][16];
    qpel_mc_func avg_h264_qpel_pixels_tab[4][16];
321

322 323 324
    qpel_mc_func put_2tap_qpel_pixels_tab[4][16];
    qpel_mc_func avg_2tap_qpel_pixels_tab[4][16];

Loren Merritt's avatar
Loren Merritt committed
325 326
    h264_weight_func weight_h264_pixels_tab[10];
    h264_biweight_func biweight_h264_pixels_tab[10];
327

328 329 330 331 332 333 334 335 336
    /* AVS specific */
    qpel_mc_func put_cavs_qpel_pixels_tab[2][16];
    qpel_mc_func avg_cavs_qpel_pixels_tab[2][16];
    void (*cavs_filter_lv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
    void (*cavs_filter_lh)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
    void (*cavs_filter_cv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
    void (*cavs_filter_ch)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
    void (*cavs_idct8_add)(uint8_t *dst, DCTELEM *block, int stride);

337
    me_cmp_func pix_abs[2][4];
338

Michael Niedermayer's avatar
huffyuv  
Michael Niedermayer committed
339 340
    /* huffyuv specific */
    void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);
Loren Merritt's avatar
Loren Merritt committed
341
    void (*add_bytes_l2)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 16*/, int w);
Michael Niedermayer's avatar
Michael Niedermayer committed
342
    void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w);
343 344 345 346 347
    /**
     * subtract huffyuv's variant of median prediction
     * note, this might read from src1[-1], src2[-1]
     */
    void (*sub_hfyu_median_prediction)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top);
Loren Merritt's avatar
Loren Merritt committed
348 349
    /* this might write to dst[w] */
    void (*add_png_paeth_prediction)(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp);
Michael Niedermayer's avatar
Michael Niedermayer committed
350
    void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w);
351

Loren Merritt's avatar
Loren Merritt committed
352 353 354
    void (*h264_v_loop_filter_luma)(uint8_t *pix/*align 16*/, int stride, int alpha, int beta, int8_t *tc0);
    void (*h264_h_loop_filter_luma)(uint8_t *pix/*align 4 */, int stride, int alpha, int beta, int8_t *tc0);
    /* v/h_loop_filter_luma_intra: align 16 */
355 356
    void (*h264_v_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta);
    void (*h264_h_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta);
Loren Merritt's avatar
Loren Merritt committed
357 358 359 360
    void (*h264_v_loop_filter_chroma)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta, int8_t *tc0);
    void (*h264_h_loop_filter_chroma)(uint8_t *pix/*align 4*/, int stride, int alpha, int beta, int8_t *tc0);
    void (*h264_v_loop_filter_chroma_intra)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta);
    void (*h264_h_loop_filter_chroma_intra)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta);
361 362
    // h264_loop_filter_strength: simd only. the C version is inlined in h264.c
    void (*h264_loop_filter_strength)(int16_t bS[2][4][4], uint8_t nnz[40], int8_t ref[2][40], int16_t mv[2][40][2],
363
                                      int bidir, int edges, int step, int mask_mv0, int mask_mv1, int field);
364

Michael Niedermayer's avatar
Michael Niedermayer committed
365 366 367
    void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale);
    void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale);

Michael Niedermayer's avatar
Michael Niedermayer committed
368
    void (*h261_loop_filter)(uint8_t *src, int stride);
369

370 371 372
    void (*x8_v_loop_filter)(uint8_t *src, int stride, int qscale);
    void (*x8_h_loop_filter)(uint8_t *src, int stride, int qscale);

373 374 375
    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);

376
    /* assume len is a multiple of 4, and arrays are 16-byte aligned */
377
    void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
Loren Merritt's avatar
Loren Merritt committed
378
    void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);
379 380
    /* no alignment needed */
    void (*flac_compute_autocorr)(const int32_t *data, int len, int lag, double *autoc);
381
    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
Loren Merritt's avatar
Loren Merritt committed
382
    void (*vector_fmul)(float *dst, const float *src, int len);
383 384 385
    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 */
    void (*vector_fmul_add_add)(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step);
Loren Merritt's avatar
Loren Merritt committed
386 387
    /* assume len is a multiple of 4, and arrays are 16-byte aligned */
    void (*vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, float add_bias, int len);
Loren Merritt's avatar
Loren Merritt committed
388 389
    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
    void (*int32_to_float_fmul_scalar)(float *dst, const int *src, float mul, int len);
390 391

    /* C version: convert floats from the range [384.0,386.0] to ints in [-32768,32767]
392
     * simd versions: convert floats from [-32768.0,32767.0] without rescaling and arrays are 16byte aligned */
Michael Niedermayer's avatar
Michael Niedermayer committed
393
    void (*float_to_int16)(int16_t *dst, const float *src, long len);
394
    void (*float_to_int16_interleave)(int16_t *dst, const float **src, long len, int channels);
395

396 397
    /* (I)DCT */
    void (*fdct)(DCTELEM *block/* align 16*/);
398
    void (*fdct248)(DCTELEM *block/* align 16*/);
399

400 401
    /* IDCT really*/
    void (*idct)(DCTELEM *block/* align 16*/);
402

Michael Niedermayer's avatar
Michael Niedermayer committed
403
    /**
Michael Niedermayer's avatar
Michael Niedermayer committed
404
     * block -> idct -> clip to unsigned 8 bit -> dest.
Michael Niedermayer's avatar
Michael Niedermayer committed
405
     * (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
Panagiotis Issaris's avatar
Panagiotis Issaris committed
406
     * @param line_size size in bytes of a horizontal line of dest
Michael Niedermayer's avatar
Michael Niedermayer committed
407
     */
408
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
409

Michael Niedermayer's avatar
Michael Niedermayer committed
410 411
    /**
     * block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
Panagiotis Issaris's avatar
Panagiotis Issaris committed
412
     * @param line_size size in bytes of a horizontal line of dest
Michael Niedermayer's avatar
Michael Niedermayer committed
413
     */
414
    void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
415

Michael Niedermayer's avatar
Michael Niedermayer committed
416
    /**
Michael Niedermayer's avatar
Michael Niedermayer committed
417
     * idct input permutation.
Michael Niedermayer's avatar
Michael Niedermayer committed
418 419 420 421
     * 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
422 423 424 425 426 427
     * an example to avoid confusion:
     * - (->decode coeffs -> zigzag reorder -> dequant -> reference idct ->...)
     * - (x -> referece dct -> reference idct -> x)
     * - (x -> referece dct -> simple_mmx_perm = idct_permutation -> simple_idct_mmx -> x)
     * - (->decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant -> simple_idct_mmx ->...)
     */
428 429 430 431 432 433
    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
434
#define FF_PARTTRANS_IDCT_PERM 5
435
#define FF_SSE2_IDCT_PERM 6
436

437 438 439 440
    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
441

442
    void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w);
443
#define EDGE_WIDTH 16
444

445
    /* h264 functions */
446 447 448 449
    /* NOTE!!! if you implement any of h264_idct8_add, h264_idct8_add4 then you must implement all of them
       NOTE!!! if you implement any of h264_idct_add, h264_idct_add16, h264_idct_add16intra, h264_idct_add8 then you must implement all of them
        The reason for above, is that no 2 out of one list may use a different permutation.
    */
Loren Merritt's avatar
Loren Merritt committed
450 451 452 453
    void (*h264_idct_add)(uint8_t *dst/*align 4*/, DCTELEM *block/*align 16*/, int stride);
    void (*h264_idct8_add)(uint8_t *dst/*align 8*/, DCTELEM *block/*align 16*/, int stride);
    void (*h264_idct_dc_add)(uint8_t *dst/*align 4*/, DCTELEM *block/*align 16*/, int stride);
    void (*h264_idct8_dc_add)(uint8_t *dst/*align 8*/, DCTELEM *block/*align 16*/, int stride);
454
    void (*h264_dct)(DCTELEM block[4][4]);
455 456 457 458
    void (*h264_idct_add16)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]);
    void (*h264_idct8_add4)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]);
    void (*h264_idct_add8)(uint8_t **dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]);
    void (*h264_idct_add16intra)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]);
459 460

    /* snow wavelet */
461 462
    void (*vertical_compose97i)(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width);
    void (*horizontal_compose97i)(IDWTELEM *b, int width);
463
    void (*inner_add_yblock)(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h, int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8);
464 465

    void (*prefetch)(void *mem, int stride, int h);
466 467

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

    /* vc1 functions */
    void (*vc1_inv_trans_8x8)(DCTELEM *b);
471 472 473
    void (*vc1_inv_trans_8x4)(uint8_t *dest, int line_size, DCTELEM *block);
    void (*vc1_inv_trans_4x8)(uint8_t *dest, int line_size, DCTELEM *block);
    void (*vc1_inv_trans_4x4)(uint8_t *dest, int line_size, DCTELEM *block);
474 475
    void (*vc1_v_overlap)(uint8_t* src, int stride);
    void (*vc1_h_overlap)(uint8_t* src, int stride);
476 477 478 479
    /* put 8x8 block with bicubic interpolation and quarterpel precision
     * last argument is actually round value instead of height
     */
    op_pixels_func put_vc1_mspel_pixels_tab[16];
480 481

    /* intrax8 functions */
482 483
    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,
484 485
           int * range, int * sum,  int edges);

486 487 488
    /* ape functions */
    /**
     * Add contents of the second vector to the first one.
489
     * @param len length of vectors, should be multiple of 16
490 491 492 493
     */
    void (*add_int16)(int16_t *v1/*align 16*/, int16_t *v2, int len);
    /**
     * Add contents of the second vector to the first one.
494
     * @param len length of vectors, should be multiple of 16
495 496 497 498
     */
    void (*sub_int16)(int16_t *v1/*align 16*/, int16_t *v2, int len);
    /**
     * Calculate scalar product of two vectors.
499
     * @param len length of vectors, should be multiple of 16
500 501 502
     * @param shift number of bits to discard from product
     */
    int32_t (*scalarproduct_int16)(int16_t *v1, int16_t *v2/*align 16*/, int len, int shift);
Kostya Shishkov's avatar
Kostya Shishkov committed
503

Kostya Shishkov's avatar
Kostya Shishkov committed
504 505 506 507
    /* rv30 functions */
    qpel_mc_func put_rv30_tpel_pixels_tab[4][16];
    qpel_mc_func avg_rv30_tpel_pixels_tab[4][16];

Kostya Shishkov's avatar
Kostya Shishkov committed
508 509 510 511 512
    /* rv40 functions */
    qpel_mc_func put_rv40_qpel_pixels_tab[4][16];
    qpel_mc_func avg_rv40_qpel_pixels_tab[4][16];
    h264_chroma_mc_func put_rv40_chroma_pixels_tab[3];
    h264_chroma_mc_func avg_rv40_chroma_pixels_tab[3];
513 514
} DSPContext;

Måns Rullgård's avatar
Måns Rullgård committed
515
void dsputil_static_init(void);
516
void dsputil_init(DSPContext* p, AVCodecContext *avctx);
Fabrice Bellard's avatar
Fabrice Bellard committed
517

518 519
int ff_check_alignment(void);

Michael Niedermayer's avatar
Michael Niedermayer committed
520 521 522 523
/**
 * permute block according to permuatation.
 * @param last last non zero element in scantable order
 */
524
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
525

526 527
void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type);

528
#define         BYTE_VEC32(c)   ((c)*0x01010101UL)
Michael Niedermayer's avatar
cleanup  
Michael Niedermayer committed
529 530 531 532 533 534 535 536 537 538 539

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);
}

Michael Niedermayer's avatar
Michael Niedermayer committed
540 541 542 543 544 545 546 547 548 549 550 551
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:
552
    case FF_CMP_DCT264:
Michael Niedermayer's avatar
Michael Niedermayer committed
553 554 555 556 557 558 559 560 561 562 563
        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;
    }
}

Michael Niedermayer's avatar
Michael Niedermayer committed
564
/**
Michael Niedermayer's avatar
Michael Niedermayer committed
565
 * Empty mmx state.
Michael Niedermayer's avatar
Michael Niedermayer committed
566 567 568
 * this must be called between any dsp function and float/double code.
 * for example sin(); dsp->idct_put(); emms_c(); cos()
 */
569 570
#define emms_c()

571 572 573 574
/* should be defined by architectures supporting
   one or more MultiMedia extension */
int mm_support(void);

575
void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);
576
void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx);
577 578 579 580 581 582 583 584
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);

585
#define DECLARE_ALIGNED_16(t, v) DECLARE_ALIGNED(16, t, v)
586

587
#if HAVE_MMX
Fabrice Bellard's avatar
Fabrice Bellard committed
588

589
#undef emms_c
590

Måns Rullgård's avatar
Måns Rullgård committed
591 592
extern int mm_flags;

593 594
void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
595
void put_signed_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
Fabrice Bellard's avatar
Fabrice Bellard committed
596 597 598

static inline void emms(void)
{
599
    __asm__ volatile ("emms;":::"memory");
600 601
}

Michael Niedermayer's avatar
Michael Niedermayer committed
602

603 604
#define emms_c() \
{\
605
    if (mm_flags & FF_MM_MMX)\
606
        emms();\
Fabrice Bellard's avatar
Fabrice Bellard committed
607 608
}

609
void dsputil_init_pix_mmx(DSPContext* c, AVCodecContext *avctx);
Zdenek Kabelac's avatar
Zdenek Kabelac committed
610

611
#elif ARCH_ARM
Fabrice Bellard's avatar
Fabrice Bellard committed
612

Måns Rullgård's avatar
Måns Rullgård committed
613 614
extern int mm_flags;

615
#if HAVE_NEON
616 617 618 619
#   define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v)
#   define STRIDE_ALIGN 16
#endif

620
#elif ARCH_PPC
621

Måns Rullgård's avatar
Måns Rullgård committed
622 623
extern int mm_flags;

624
#define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v)
Michael Niedermayer's avatar
Michael Niedermayer committed
625
#define STRIDE_ALIGN 16
626

627
#elif HAVE_MMI
628

629
#define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v)
Michael Niedermayer's avatar
Michael Niedermayer committed
630
#define STRIDE_ALIGN 16
631

632 633 634 635 636
#else

#define mm_flags 0
#define mm_support() 0

637
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
638

639 640 641
#ifndef DECLARE_ALIGNED_8
#   define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(8, t, v)
#endif
Fabrice Bellard's avatar
Fabrice Bellard committed
642

643 644
#ifndef STRIDE_ALIGN
#   define STRIDE_ALIGN 8
Fabrice Bellard's avatar
Fabrice Bellard committed
645 646
#endif

647
/* PSNR */
648
void get_psnr(uint8_t *orig_image[3], uint8_t *coded_image[3],
649 650
              int orig_linesize[3], int coded_linesize,
              AVCodecContext *avctx);
651 652 653 654 655 656 657

/* FFT computation */

/* NOTE: soon integer code will be added, so you must use the
   FFTSample type */
typedef float FFTSample;

658 659
struct MDCTContext;

660 661 662 663 664 665 666 667 668 669
typedef struct FFTComplex {
    FFTSample re, im;
} FFTComplex;

typedef struct FFTContext {
    int nbits;
    int inverse;
    uint16_t *revtab;
    FFTComplex *exptab;
    FFTComplex *exptab1; /* only used by SSE code */
Loren Merritt's avatar
Loren Merritt committed
670 671
    FFTComplex *tmp_buf;
    void (*fft_permute)(struct FFTContext *s, FFTComplex *z);
672
    void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
Loren Merritt's avatar
Loren Merritt committed
673 674
    void (*imdct_calc)(struct MDCTContext *s, FFTSample *output, const FFTSample *input);
    void (*imdct_half)(struct MDCTContext *s, FFTSample *output, const FFTSample *input);
675 676
} FFTContext;

677 678
extern FFTSample* ff_cos_tabs[13];

Alex Converse's avatar
Alex Converse committed
679 680 681 682 683
/**
 * Sets up a complex FFT.
 * @param nbits           log2 of the length of the input array
 * @param inverse         if 0 perform the forward transform, if 1 perform the inverse
 */
684
int ff_fft_init(FFTContext *s, int nbits, int inverse);
Loren Merritt's avatar
Loren Merritt committed
685 686
void ff_fft_permute_c(FFTContext *s, FFTComplex *z);
void ff_fft_permute_sse(FFTContext *s, FFTComplex *z);
687 688
void ff_fft_calc_c(FFTContext *s, FFTComplex *z);
void ff_fft_calc_sse(FFTContext *s, FFTComplex *z);
689 690
void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z);
void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z);
691
void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z);
692

Alex Converse's avatar
Alex Converse committed
693 694 695
/**
 * Do the permutation needed BEFORE calling ff_fft_calc().
 */
Loren Merritt's avatar
Loren Merritt committed
696 697 698 699
static inline void ff_fft_permute(FFTContext *s, FFTComplex *z)
{
    s->fft_permute(s, z);
}
Alex Converse's avatar
Alex Converse committed
700 701 702 703
/**
 * Do a complex FFT with the parameters defined in ff_fft_init(). The
 * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
 */
704
static inline void ff_fft_calc(FFTContext *s, FFTComplex *z)
705 706 707
{
    s->fft_calc(s, z);
}
708
void ff_fft_end(FFTContext *s);
709 710 711 712 713 714 715 716 717 718 719 720

/* MDCT computation */

typedef struct MDCTContext {
    int n;  /* size of MDCT (i.e. number of input data * 2) */
    int nbits; /* n = 2^nbits */
    /* pre/post rotation tables */
    FFTSample *tcos;
    FFTSample *tsin;
    FFTContext fft;
} MDCTContext;

721 722 723 724 725 726 727 728 729
static inline void ff_imdct_calc(MDCTContext *s, FFTSample *output, const FFTSample *input)
{
    s->fft.imdct_calc(s, output, input);
}
static inline void ff_imdct_half(MDCTContext *s, FFTSample *output, const FFTSample *input)
{
    s->fft.imdct_half(s, output, input);
}

730 731 732
/**
 * Generate a Kaiser-Bessel Derived Window.
 * @param   window  pointer to half window
733 734
 * @param   alpha   determines window shape
 * @param   n       size of half window
735
 */
736
void ff_kbd_window_init(float *window, float alpha, int n);
737

738 739 740 741 742 743
/**
 * Generate a sine window.
 * @param   window  pointer to half window
 * @param   n       size of half window
 */
void ff_sine_window_init(float *window, int n);
744 745 746 747 748
extern float ff_sine_128 [ 128];
extern float ff_sine_256 [ 256];
extern float ff_sine_512 [ 512];
extern float ff_sine_1024[1024];
extern float ff_sine_2048[2048];
749 750
extern float ff_sine_4096[4096];
extern float *ff_sine_windows[6];
751

Fabrice Bellard's avatar
Fabrice Bellard committed
752
int ff_mdct_init(MDCTContext *s, int nbits, int inverse);
753 754
void ff_imdct_calc_c(MDCTContext *s, FFTSample *output, const FFTSample *input);
void ff_imdct_half_c(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
755
void ff_imdct_calc_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
756
void ff_imdct_half_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
757
void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
758
void ff_imdct_half_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
759
void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
760
void ff_imdct_half_sse(MDCTContext *s, FFTSample *output, const FFTSample *input);
Loren Merritt's avatar
Loren Merritt committed
761
void ff_mdct_calc(MDCTContext *s, FFTSample *out, const FFTSample *input);
Fabrice Bellard's avatar
Fabrice Bellard committed
762
void ff_mdct_end(MDCTContext *s);
763

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
/* Real Discrete Fourier Transform */

enum RDFTransformType {
    RDFT,
    IRDFT,
    RIDFT,
    IRIDFT,
};

typedef struct {
    int nbits;
    int inverse;
    int sign_convention;

    /* pre/post rotation tables */
    FFTSample *tcos;
    FFTSample *tsin;
    FFTContext fft;
} RDFTContext;

/**
 * Sets up a real FFT.
 * @param nbits           log2 of the length of the input array
 * @param trans           the type of transform
 */
int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans);
void ff_rdft_calc(RDFTContext *s, FFTSample *data);
void ff_rdft_end(RDFTContext *s);

793
#define WRAPPER8_16(name8, name16)\
794 795 796 797 798
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);\
}

799
#define WRAPPER8_16_SQ(name8, name16)\
800 801 802 803 804 805 806 807 808 809 810
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
811 812
}

813 814 815 816 817 818

static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {
819
        AV_WN16(dst   , AV_RN16(src   ));
820 821 822 823 824 825 826 827 828 829
        dst+=dstStride;
        src+=srcStride;
    }
}

static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {
830
        AV_WN32(dst   , AV_RN32(src   ));
831 832 833 834 835 836 837 838 839 840
        dst+=dstStride;
        src+=srcStride;
    }
}

static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {
841 842
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
843 844 845 846 847 848 849 850 851 852
        dst+=dstStride;
        src+=srcStride;
    }
}

static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {
853 854
        AV_WN32(dst   , AV_RN32(src   ));
        AV_WN32(dst+4 , AV_RN32(src+4 ));
855 856 857 858 859 860 861 862 863 864 865
        dst[8]= src[8];
        dst+=dstStride;
        src+=srcStride;
    }
}

static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {
866 867 868 869
        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));
870 871 872 873 874 875 876 877 878 879
        dst+=dstStride;
        src+=srcStride;
    }
}

static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
{
    int i;
    for(i=0; i<h; i++)
    {