← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/dsputil.h

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-25 15:47:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080225154712-qvr11ekcea4c9ry8
Tags: 1.1.6-0.1ubuntu1
https://launchpad.net/bugs/120003
* Merge from debian-multimedia (LP: #120003), Ubuntu Changes:
 - For ffmpeg-related build-deps, remove cvs from package names.
 - Standards-Version 3.7.3
 - Maintainer Spec

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/dsputil.h
1
1
/*
2
2
 * DSP utils
3
3
 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard.
4
 
 *
5
 
 * This library is free software; you can redistribute it and/or
 
4
 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
 
5
 *
 
6
 * This file is part of FFmpeg.
 
7
 *
 
8
 * FFmpeg is free software; you can redistribute it and/or
6
9
 * modify it under the terms of the GNU Lesser General Public
7
10
 * License as published by the Free Software Foundation; either
8
 
 * version 2 of the License, or (at your option) any later version.
 
11
 * version 2.1 of the License, or (at your option) any later version.
9
12
 *
10
 
 * This library is distributed in the hope that it will be useful,
 
13
 * FFmpeg is distributed in the hope that it will be useful,
11
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
16
 * Lesser General Public License for more details.
14
17
 *
15
18
 * You should have received a copy of the GNU Lesser General Public
16
 
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
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
18
21
 */
19
22
 
20
23
/**
34
37
//#define DEBUG
35
38
/* dct code */
36
39
typedef short DCTELEM;
 
40
typedef int DWTELEM;
37
41
 
38
42
void fdct_ifast (DCTELEM *data);
 
43
void fdct_ifast248 (DCTELEM *data);
39
44
void ff_jpeg_fdct_islow (DCTELEM *data);
 
45
void ff_fdct248_islow (DCTELEM *data);
40
46
 
41
47
void j_rev_dct (DCTELEM *data);
 
48
void j_rev_dct4 (DCTELEM *data);
 
49
void j_rev_dct2 (DCTELEM *data);
 
50
void j_rev_dct1 (DCTELEM *data);
42
51
 
43
52
void ff_fdct_mmx(DCTELEM *block);
 
53
void ff_fdct_mmx2(DCTELEM *block);
 
54
void ff_fdct_sse2(DCTELEM *block);
 
55
 
 
56
void ff_h264_idct8_add_c(uint8_t *dst, DCTELEM *block, int stride);
 
57
void ff_h264_idct_add_c(uint8_t *dst, DCTELEM *block, int stride);
 
58
void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
 
59
void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride);
 
60
void ff_h264_lowres_idct_add_c(uint8_t *dst, int stride, DCTELEM *block);
 
61
void ff_h264_lowres_idct_put_c(uint8_t *dst, int stride, DCTELEM *block);
 
62
 
 
63
void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1,
 
64
                              const float *src2, int src3, int blocksize, int step);
 
65
void ff_float_to_int16_c(int16_t *dst, const float *src, int len);
44
66
 
45
67
/* encoding scans */
46
68
extern const uint8_t ff_alternate_horizontal_scan[64];
47
69
extern const uint8_t ff_alternate_vertical_scan[64];
48
70
extern const uint8_t ff_zigzag_direct[64];
 
71
extern const uint8_t ff_zigzag248_direct[64];
49
72
 
50
73
/* pixel operations */
51
 
#define MAX_NEG_CROP 384
 
74
#define MAX_NEG_CROP 1024
52
75
 
53
76
/* temporary */
54
 
extern uint32_t squareTbl[512];
55
 
extern uint8_t cropTbl[256 + 2 * MAX_NEG_CROP];
56
 
 
 
77
extern uint32_t ff_squareTbl[512];
 
78
extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP];
 
79
 
 
80
/* VP3 DSP functions */
 
81
void ff_vp3_idct_c(DCTELEM *block/* align 16*/);
 
82
void ff_vp3_idct_put_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 
83
void ff_vp3_idct_add_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
 
84
 
 
85
/* 1/2^n downscaling functions from imgconvert.c */
 
86
void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
 
87
void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
 
88
void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
 
89
void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
 
90
 
 
91
void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
 
92
              int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
57
93
 
58
94
/* minimum alignment rules ;)
59
95
if u notice errors in the align stuff, need more alignment for some asm code for some cpu
75
111
 
76
112
/* add and put pixel (decoding) */
77
113
// blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16
 
114
//h for op_pixels_func is limited to {width/2, width} but never larger than 16 and never smaller then 4
78
115
typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
79
116
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);
80
117
typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);
81
118
typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
 
119
typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset);
 
120
typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset);
82
121
 
83
122
#define DEF_OLD_QPEL(name)\
84
123
void ff_put_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
105
144
}
106
145
 
107
146
/* motion estimation */
108
 
 
109
 
typedef int (*op_pixels_abs_func)(uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
110
 
 
111
 
typedef int (*me_cmp_func)(void /*MpegEncContext*/ *s, uint8_t *blk1/*align width (8 or 16)*/, uint8_t *blk2/*align 1*/, int line_size)/* __attribute__ ((const))*/;
112
 
 
 
147
// h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller then 2
 
148
// allthough currently h<4 is not used as functions with width <8 are not used and neither implemented
 
149
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))*/;
 
150
 
 
151
 
 
152
// for snow slices
 
153
typedef struct slice_buffer_s slice_buffer;
113
154
 
114
155
/**
115
156
 * DSPContext.
119
160
    void (*get_pixels)(DCTELEM *block/*align 16*/, const uint8_t *pixels/*align 8*/, int line_size);
120
161
    void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride);
121
162
    void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
 
163
    void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
122
164
    void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
 
165
    void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
 
166
    void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
123
167
    /**
124
168
     * translational global motion compensation.
125
169
     */
128
172
     * global motion compensation.
129
173
     */
130
174
    void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy,
131
 
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
 
175
                    int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height);
132
176
    void (*clear_blocks)(DCTELEM *blocks/*align 16*/);
133
177
    int (*pix_sum)(uint8_t * pix, int line_size);
134
178
    int (*pix_norm1)(uint8_t * pix, int line_size);
135
 
    me_cmp_func sad[2]; /* identical to pix_absAxA except additional void * */
136
 
    me_cmp_func sse[2];
137
 
    me_cmp_func hadamard8_diff[2];
138
 
    me_cmp_func dct_sad[2];
139
 
    me_cmp_func quant_psnr[2];
140
 
    me_cmp_func bit[2];
141
 
    me_cmp_func rd[2];
142
 
    int (*hadamard8_abs )(uint8_t *src, int stride, int mean);
143
 
 
144
 
    me_cmp_func me_pre_cmp[11];
145
 
    me_cmp_func me_cmp[11];
146
 
    me_cmp_func me_sub_cmp[11];
147
 
    me_cmp_func mb_cmp[11];
148
 
 
149
 
    /* maybe create an array for 16/8/4/2 functions */
 
179
// 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4
 
180
 
 
181
    me_cmp_func sad[5]; /* identical to pix_absAxA except additional void * */
 
182
    me_cmp_func sse[5];
 
183
    me_cmp_func hadamard8_diff[5];
 
184
    me_cmp_func dct_sad[5];
 
185
    me_cmp_func quant_psnr[5];
 
186
    me_cmp_func bit[5];
 
187
    me_cmp_func rd[5];
 
188
    me_cmp_func vsad[5];
 
189
    me_cmp_func vsse[5];
 
190
    me_cmp_func nsse[5];
 
191
    me_cmp_func w53[5];
 
192
    me_cmp_func w97[5];
 
193
    me_cmp_func dct_max[5];
 
194
    me_cmp_func dct264_sad[5];
 
195
 
 
196
    me_cmp_func me_pre_cmp[5];
 
197
    me_cmp_func me_cmp[5];
 
198
    me_cmp_func me_sub_cmp[5];
 
199
    me_cmp_func mb_cmp[5];
 
200
    me_cmp_func ildct_cmp[5]; //only width 16 used
 
201
    me_cmp_func frame_skip_cmp[5]; //only width 8 used
 
202
 
150
203
    /**
151
204
     * Halfpel motion compensation with rounding (a+b+1)>>1.
152
 
     * this is an array[4][4] of motion compensation funcions for 4 
153
 
     * horizontal blocksizes (2,4,8,16) and the 4 halfpel positions<br>
 
205
     * this is an array[4][4] of motion compensation funcions for 4
 
206
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
154
207
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
155
208
     * @param block destination where the result is stored
156
209
     * @param pixels source
161
214
 
162
215
    /**
163
216
     * Halfpel motion compensation with rounding (a+b+1)>>1.
164
 
     * This is an array[4][4] of motion compensation functions for 4 
165
 
     * horizontal blocksizes (2,4,8,16) and the 4 halfpel positions<br>
 
217
     * This is an array[4][4] of motion compensation functions for 4
 
218
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
166
219
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
167
220
     * @param block destination into which the result is averaged (a+b+1)>>1
168
221
     * @param pixels source
173
226
 
174
227
    /**
175
228
     * Halfpel motion compensation with no rounding (a+b)>>1.
176
 
     * this is an array[2][4] of motion compensation funcions for 2 
 
229
     * this is an array[2][4] of motion compensation funcions for 2
177
230
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
178
231
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
179
232
     * @param block destination where the result is stored
181
234
     * @param line_size number of bytes in a horizontal line of block
182
235
     * @param h height
183
236
     */
184
 
    op_pixels_func put_no_rnd_pixels_tab[2][4];
 
237
    op_pixels_func put_no_rnd_pixels_tab[4][4];
185
238
 
186
239
    /**
187
240
     * Halfpel motion compensation with no rounding (a+b)>>1.
188
 
     * this is an array[2][4] of motion compensation funcions for 2 
 
241
     * this is an array[2][4] of motion compensation funcions for 2
189
242
     * horizontal blocksizes (8,16) and the 4 halfpel positions<br>
190
243
     * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ]
191
244
     * @param block destination into which the result is averaged (a+b)>>1
193
246
     * @param line_size number of bytes in a horizontal line of block
194
247
     * @param h height
195
248
     */
196
 
    op_pixels_func avg_no_rnd_pixels_tab[2][4];
197
 
    
 
249
    op_pixels_func avg_no_rnd_pixels_tab[4][4];
 
250
 
 
251
    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);
 
252
 
198
253
    /**
199
254
     * Thirdpel motion compensation with rounding (a+b+1)>>1.
200
255
     * this is an array[12] of motion compensation funcions for the 9 thirdpel positions<br>
212
267
    qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16];
213
268
    qpel_mc_func avg_no_rnd_qpel_pixels_tab[2][16];
214
269
    qpel_mc_func put_mspel_pixels_tab[8];
215
 
    
 
270
 
216
271
    /**
217
272
     * h264 Chram MC
218
273
     */
219
274
    h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
 
275
    /* This is really one func used in VC-1 decoding */
 
276
    h264_chroma_mc_func put_no_rnd_h264_chroma_pixels_tab[3];
220
277
    h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
221
278
 
222
 
    qpel_mc_func put_h264_qpel_pixels_tab[3][16];
223
 
    qpel_mc_func avg_h264_qpel_pixels_tab[3][16];
224
 
    
225
 
    op_pixels_abs_func pix_abs16x16;
226
 
    op_pixels_abs_func pix_abs16x16_x2;
227
 
    op_pixels_abs_func pix_abs16x16_y2;
228
 
    op_pixels_abs_func pix_abs16x16_xy2;
229
 
    op_pixels_abs_func pix_abs8x8;
230
 
    op_pixels_abs_func pix_abs8x8_x2;
231
 
    op_pixels_abs_func pix_abs8x8_y2;
232
 
    op_pixels_abs_func pix_abs8x8_xy2;
233
 
    
 
279
    qpel_mc_func put_h264_qpel_pixels_tab[4][16];
 
280
    qpel_mc_func avg_h264_qpel_pixels_tab[4][16];
 
281
 
 
282
    qpel_mc_func put_2tap_qpel_pixels_tab[4][16];
 
283
    qpel_mc_func avg_2tap_qpel_pixels_tab[4][16];
 
284
 
 
285
    h264_weight_func weight_h264_pixels_tab[10];
 
286
    h264_biweight_func biweight_h264_pixels_tab[10];
 
287
 
 
288
    /* AVS specific */
 
289
    qpel_mc_func put_cavs_qpel_pixels_tab[2][16];
 
290
    qpel_mc_func avg_cavs_qpel_pixels_tab[2][16];
 
291
    void (*cavs_filter_lv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
 
292
    void (*cavs_filter_lh)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
 
293
    void (*cavs_filter_cv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
 
294
    void (*cavs_filter_ch)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2);
 
295
    void (*cavs_idct8_add)(uint8_t *dst, DCTELEM *block, int stride);
 
296
 
 
297
    me_cmp_func pix_abs[2][4];
 
298
 
234
299
    /* huffyuv specific */
235
300
    void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w);
236
301
    void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w);
 
302
    /**
 
303
     * subtract huffyuv's variant of median prediction
 
304
     * note, this might read from src1[-1], src2[-1]
 
305
     */
 
306
    void (*sub_hfyu_median_prediction)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top);
237
307
    void (*bswap_buf)(uint32_t *dst, uint32_t *src, int w);
238
 
    
 
308
 
 
309
    void (*h264_v_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
 
310
    void (*h264_h_loop_filter_luma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
 
311
    void (*h264_v_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
 
312
    void (*h264_h_loop_filter_chroma)(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0);
 
313
    void (*h264_v_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta);
 
314
    void (*h264_h_loop_filter_chroma_intra)(uint8_t *pix, int stride, int alpha, int beta);
 
315
    // h264_loop_filter_strength: simd only. the C version is inlined in h264.c
 
316
    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],
 
317
                                      int bidir, int edges, int step, int mask_mv0, int mask_mv1);
 
318
 
 
319
    void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale);
 
320
    void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale);
 
321
 
 
322
    void (*h261_loop_filter)(uint8_t *src, int stride);
 
323
 
 
324
    /* assume len is a multiple of 4, and arrays are 16-byte aligned */
 
325
    void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize);
 
326
    /* assume len is a multiple of 8, and arrays are 16-byte aligned */
 
327
    void (*vector_fmul)(float *dst, const float *src, int len);
 
328
    void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len);
 
329
    /* assume len is a multiple of 8, and src arrays are 16-byte aligned */
 
330
    void (*vector_fmul_add_add)(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step);
 
331
 
 
332
    /* C version: convert floats from the range [384.0,386.0] to ints in [-32768,32767]
 
333
     * simd versions: convert floats from [-32768.0,32767.0] without rescaling and arrays are 16byte aligned */
 
334
    void (*float_to_int16)(int16_t *dst, const float *src, int len);
 
335
 
239
336
    /* (I)DCT */
240
337
    void (*fdct)(DCTELEM *block/* align 16*/);
241
 
    
 
338
    void (*fdct248)(DCTELEM *block/* align 16*/);
 
339
 
242
340
    /* IDCT really*/
243
341
    void (*idct)(DCTELEM *block/* align 16*/);
244
 
    
 
342
 
245
343
    /**
246
344
     * block -> idct -> clip to unsigned 8 bit -> dest.
247
345
     * (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...)
248
346
     * @param line_size size in bytes of a horizotal line of dest
249
347
     */
250
348
    void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
251
 
    
 
349
 
252
350
    /**
253
351
     * block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
254
352
     * @param line_size size in bytes of a horizotal line of dest
255
353
     */
256
354
    void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/);
257
 
    
 
355
 
258
356
    /**
259
357
     * idct input permutation.
260
358
     * several optimized IDCTs need a permutated input (relative to the normal order of the reference
273
371
#define FF_LIBMPEG2_IDCT_PERM 2
274
372
#define FF_SIMPLE_IDCT_PERM 3
275
373
#define FF_TRANSPOSE_IDCT_PERM 4
276
 
 
 
374
#define FF_PARTTRANS_IDCT_PERM 5
 
375
 
 
376
    int (*try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale);
 
377
    void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale);
 
378
#define BASIS_SHIFT 16
 
379
#define RECON_SHIFT 6
 
380
 
 
381
    /* h264 functions */
 
382
    void (*h264_idct_add)(uint8_t *dst, DCTELEM *block, int stride);
 
383
    void (*h264_idct8_add)(uint8_t *dst, DCTELEM *block, int stride);
 
384
    void (*h264_idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
 
385
    void (*h264_idct8_dc_add)(uint8_t *dst, DCTELEM *block, int stride);
 
386
    void (*h264_dct)(DCTELEM block[4][4]);
 
387
 
 
388
    /* snow wavelet */
 
389
    void (*vertical_compose97i)(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, DWTELEM *b3, DWTELEM *b4, DWTELEM *b5, int width);
 
390
    void (*horizontal_compose97i)(DWTELEM *b, int width);
 
391
    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);
 
392
 
 
393
    void (*prefetch)(void *mem, int stride, int h);
 
394
 
 
395
    void (*shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height);
 
396
 
 
397
    /* vc1 functions */
 
398
    void (*vc1_inv_trans_8x8)(DCTELEM *b);
 
399
    void (*vc1_inv_trans_8x4)(DCTELEM *b, int n);
 
400
    void (*vc1_inv_trans_4x8)(DCTELEM *b, int n);
 
401
    void (*vc1_inv_trans_4x4)(DCTELEM *b, int n);
 
402
    void (*vc1_v_overlap)(uint8_t* src, int stride);
 
403
    void (*vc1_h_overlap)(uint8_t* src, int stride);
 
404
    /* put 8x8 block with bicubic interpolation and quarterpel precision
 
405
     * last argument is actually round value instead of height
 
406
     */
 
407
    op_pixels_func put_vc1_mspel_pixels_tab[16];
277
408
} DSPContext;
278
409
 
279
410
void dsputil_static_init(void);
280
411
void dsputil_init(DSPContext* p, AVCodecContext *avctx);
281
412
 
 
413
int ff_check_alignment(void);
 
414
 
282
415
/**
283
416
 * permute block according to permuatation.
284
417
 * @param last last non zero element in scantable order
285
418
 */
286
419
void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last);
287
420
 
288
 
#define BYTE_VEC32(c)   ((c)*0x01010101UL)
 
421
void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type);
 
422
 
 
423
#define         BYTE_VEC32(c)   ((c)*0x01010101UL)
289
424
 
290
425
static inline uint32_t rnd_avg32(uint32_t a, uint32_t b)
291
426
{
297
432
    return (a & b) + (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1);
298
433
}
299
434
 
 
435
static inline int get_penalty_factor(int lambda, int lambda2, int type){
 
436
    switch(type&0xFF){
 
437
    default:
 
438
    case FF_CMP_SAD:
 
439
        return lambda>>FF_LAMBDA_SHIFT;
 
440
    case FF_CMP_DCT:
 
441
        return (3*lambda)>>(FF_LAMBDA_SHIFT+1);
 
442
    case FF_CMP_W53:
 
443
        return (4*lambda)>>(FF_LAMBDA_SHIFT);
 
444
    case FF_CMP_W97:
 
445
        return (2*lambda)>>(FF_LAMBDA_SHIFT);
 
446
    case FF_CMP_SATD:
 
447
    case FF_CMP_DCT264:
 
448
        return (2*lambda)>>FF_LAMBDA_SHIFT;
 
449
    case FF_CMP_RD:
 
450
    case FF_CMP_PSNR:
 
451
    case FF_CMP_SSE:
 
452
    case FF_CMP_NSSE:
 
453
        return lambda2>>FF_LAMBDA_SHIFT;
 
454
    case FF_CMP_BIT:
 
455
        return 1;
 
456
    }
 
457
}
 
458
 
300
459
/**
301
460
 * Empty mmx state.
302
461
 * this must be called between any dsp function and float/double code.
308
467
   one or more MultiMedia extension */
309
468
int mm_support(void);
310
469
 
 
470
#ifdef __GNUC__
 
471
  #define DECLARE_ALIGNED_16(t,v)       t v __attribute__ ((aligned (16)))
 
472
#else
 
473
  #define DECLARE_ALIGNED_16(t,v)      __declspec(align(16)) t v
 
474
#endif
 
475
 
311
476
#if defined(HAVE_MMX)
312
477
 
313
478
#undef emms_c
317
482
#define MM_MMXEXT 0x0002 /* SSE integer functions or AMD MMX ext */
318
483
#define MM_SSE    0x0008 /* SSE functions */
319
484
#define MM_SSE2   0x0010 /* PIV SSE2 functions */
 
485
#define MM_3DNOWEXT  0x0020 /* AMD 3DNowExt */
 
486
#define MM_SSE3   0x0040 /* Prescott SSE3 functions */
 
487
#define MM_SSSE3  0x0080 /* Conroe SSSE3 functions */
320
488
 
321
489
extern int mm_flags;
322
490
 
323
491
void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
324
492
void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
 
493
void put_signed_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size);
325
494
 
326
495
static inline void emms(void)
327
496
{
335
504
        emms();\
336
505
}
337
506
 
338
 
#define __align8 __attribute__ ((aligned (8)))
 
507
#ifdef __GNUC__
 
508
  #define DECLARE_ALIGNED_8(t,v)       t v __attribute__ ((aligned (8)))
 
509
#else
 
510
  #define DECLARE_ALIGNED_8(t,v)      __declspec(align(8)) t v
 
511
#endif
 
512
 
 
513
#define STRIDE_ALIGN 8
339
514
 
340
515
void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx);
341
516
void dsputil_init_pix_mmx(DSPContext* c, AVCodecContext *avctx);
343
518
#elif defined(ARCH_ARMV4L)
344
519
 
345
520
/* This is to use 4 bytes read to the IDCT pointers for some 'zero'
346
 
   line ptimizations */
347
 
#define __align8 __attribute__ ((aligned (4)))
 
521
   line optimizations */
 
522
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (4)))
 
523
#define STRIDE_ALIGN 4
 
524
 
 
525
#define MM_IWMMXT    0x0100 /* XScale IWMMXT */
 
526
 
 
527
extern int mm_flags;
348
528
 
349
529
void dsputil_init_armv4l(DSPContext* c, AVCodecContext *avctx);
350
530
 
351
531
#elif defined(HAVE_MLIB)
352
532
 
353
533
/* SPARC/VIS IDCT needs 8-byte aligned DCT blocks */
354
 
#define __align8 __attribute__ ((aligned (8)))
 
534
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
535
#define STRIDE_ALIGN 8
355
536
 
356
537
void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx);
357
538
 
 
539
#elif defined(ARCH_SPARC)
 
540
 
 
541
/* SPARC/VIS IDCT needs 8-byte aligned DCT blocks */
 
542
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
543
#define STRIDE_ALIGN 8
 
544
void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx);
 
545
 
358
546
#elif defined(ARCH_ALPHA)
359
547
 
360
 
#define __align8 __attribute__ ((aligned (8)))
 
548
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
549
#define STRIDE_ALIGN 8
361
550
 
362
551
void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx);
363
552
 
368
557
extern int mm_flags;
369
558
 
370
559
#if defined(HAVE_ALTIVEC) && !defined(CONFIG_DARWIN)
 
560
#define pixel altivec_pixel
371
561
#include <altivec.h>
 
562
#undef pixel
372
563
#endif
373
564
 
374
 
#define __align8 __attribute__ ((aligned (16)))
 
565
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (16)))
 
566
#define STRIDE_ALIGN 16
375
567
 
376
568
void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx);
377
569
 
378
570
#elif defined(HAVE_MMI)
379
571
 
380
 
#define __align8 __attribute__ ((aligned (16)))
 
572
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (16)))
 
573
#define STRIDE_ALIGN 16
381
574
 
382
575
void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx);
383
576
 
384
577
#elif defined(ARCH_SH4)
385
578
 
386
 
#define __align8 __attribute__ ((aligned (8)))
 
579
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
580
#define STRIDE_ALIGN 8
387
581
 
388
582
void dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx);
389
583
 
 
584
#elif defined(ARCH_BFIN)
 
585
 
 
586
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
587
#define STRIDE_ALIGN 8
 
588
 
 
589
void dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx);
 
590
 
390
591
#else
391
592
 
392
 
#define __align8
 
593
#define DECLARE_ALIGNED_8(t,v)    t v __attribute__ ((aligned (8)))
 
594
#define STRIDE_ALIGN 8
393
595
 
394
596
#endif
395
597
 
396
 
#ifdef __GNUC__
397
 
 
398
 
struct unaligned_64 { uint64_t l; } __attribute__((packed));
399
 
struct unaligned_32 { uint32_t l; } __attribute__((packed));
400
 
struct unaligned_16 { uint16_t l; } __attribute__((packed));
401
 
 
402
 
#define LD16(a) (((const struct unaligned_16 *) (a))->l)
403
 
#define LD32(a) (((const struct unaligned_32 *) (a))->l)
404
 
#define LD64(a) (((const struct unaligned_64 *) (a))->l)
405
 
 
406
 
#define ST32(a, b) (((struct unaligned_32 *) (a))->l) = (b)
407
 
 
408
 
#else /* __GNUC__ */
409
 
 
410
 
#define LD16(a) (*((uint16_t*)(a)))
411
 
#define LD32(a) (*((uint32_t*)(a)))
412
 
#define LD64(a) (*((uint64_t*)(a)))
413
 
 
414
 
#define ST32(a, b) *((uint32_t*)(a)) = (b)
415
 
 
416
 
#endif /* !__GNUC__ */
417
 
 
418
598
/* PSNR */
419
599
void get_psnr(uint8_t *orig_image[3], uint8_t *coded_image[3],
420
600
              int orig_linesize[3], int coded_linesize,
426
606
   FFTSample type */
427
607
typedef float FFTSample;
428
608
 
 
609
struct MDCTContext;
 
610
 
429
611
typedef struct FFTComplex {
430
612
    FFTSample re, im;
431
613
} FFTComplex;
437
619
    FFTComplex *exptab;
438
620
    FFTComplex *exptab1; /* only used by SSE code */
439
621
    void (*fft_calc)(struct FFTContext *s, FFTComplex *z);
 
622
    void (*imdct_calc)(struct MDCTContext *s, FFTSample *output,
 
623
                       const FFTSample *input, FFTSample *tmp);
440
624
} FFTContext;
441
625
 
442
 
int fft_init(FFTContext *s, int nbits, int inverse);
443
 
void fft_permute(FFTContext *s, FFTComplex *z);
444
 
void fft_calc_c(FFTContext *s, FFTComplex *z);
445
 
void fft_calc_sse(FFTContext *s, FFTComplex *z);
446
 
void fft_calc_altivec(FFTContext *s, FFTComplex *z);
 
626
int ff_fft_init(FFTContext *s, int nbits, int inverse);
 
627
void ff_fft_permute(FFTContext *s, FFTComplex *z);
 
628
void ff_fft_calc_c(FFTContext *s, FFTComplex *z);
 
629
void ff_fft_calc_sse(FFTContext *s, FFTComplex *z);
 
630
void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z);
 
631
void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z);
 
632
void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z);
447
633
 
448
 
static inline void fft_calc(FFTContext *s, FFTComplex *z)
 
634
static inline void ff_fft_calc(FFTContext *s, FFTComplex *z)
449
635
{
450
636
    s->fft_calc(s, z);
451
637
}
452
 
void fft_end(FFTContext *s);
 
638
void ff_fft_end(FFTContext *s);
453
639
 
454
640
/* MDCT computation */
455
641
 
465
651
int ff_mdct_init(MDCTContext *s, int nbits, int inverse);
466
652
void ff_imdct_calc(MDCTContext *s, FFTSample *output,
467
653
                const FFTSample *input, FFTSample *tmp);
 
654
void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output,
 
655
                        const FFTSample *input, FFTSample *tmp);
 
656
void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output,
 
657
                       const FFTSample *input, FFTSample *tmp);
468
658
void ff_mdct_calc(MDCTContext *s, FFTSample *out,
469
659
               const FFTSample *input, FFTSample *tmp);
470
660
void ff_mdct_end(MDCTContext *s);
471
661
 
472
 
#define WARPER88_1616(name8, name16)\
473
 
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride){\
474
 
    return name8(s, dst           , src           , stride)\
475
 
          +name8(s, dst+8         , src+8         , stride)\
476
 
          +name8(s, dst  +8*stride, src  +8*stride, stride)\
477
 
          +name8(s, dst+8+8*stride, src+8+8*stride, stride);\
478
 
}
479
 
 
480
 
#ifndef HAVE_LRINTF
481
 
/* XXX: add ISOC specific test to avoid specific BSD testing. */
482
 
/* better than nothing implementation. */
483
 
/* btw, rintf() is existing on fbsd too -- alex */
484
 
static inline long int lrintf(float x)
485
 
{
486
 
#ifdef CONFIG_WIN32
487
 
    /* XXX: incorrect, but make it compile */
488
 
    return (int)(x);
489
 
#else
490
 
    return (int)(rint(x));
491
 
#endif
492
 
}
493
 
#endif
494
 
 
495
 
#if defined(CONFIG_OS2) || defined(CONFIG_SUNOS)
496
 
static inline float floorf(float f) { 
497
 
    return floor(f); 
498
 
}
499
 
#endif
 
662
#define WARPER8_16(name8, name16)\
 
663
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
 
664
    return name8(s, dst           , src           , stride, h)\
 
665
          +name8(s, dst+8         , src+8         , stride, h);\
 
666
}
 
667
 
 
668
#define WARPER8_16_SQ(name8, name16)\
 
669
static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\
 
670
    int score=0;\
 
671
    score +=name8(s, dst           , src           , stride, 8);\
 
672
    score +=name8(s, dst+8         , src+8         , stride, 8);\
 
673
    if(h==16){\
 
674
        dst += 8*stride;\
 
675
        src += 8*stride;\
 
676
        score +=name8(s, dst           , src           , stride, 8);\
 
677
        score +=name8(s, dst+8         , src+8         , stride, 8);\
 
678
    }\
 
679
    return score;\
 
680
}
 
681
 
 
682
 
 
683
static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
684
{
 
685
    int i;
 
686
    for(i=0; i<h; i++)
 
687
    {
 
688
        ST16(dst   , LD16(src   ));
 
689
        dst+=dstStride;
 
690
        src+=srcStride;
 
691
    }
 
692
}
 
693
 
 
694
static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
695
{
 
696
    int i;
 
697
    for(i=0; i<h; i++)
 
698
    {
 
699
        ST32(dst   , LD32(src   ));
 
700
        dst+=dstStride;
 
701
        src+=srcStride;
 
702
    }
 
703
}
 
704
 
 
705
static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
706
{
 
707
    int i;
 
708
    for(i=0; i<h; i++)
 
709
    {
 
710
        ST32(dst   , LD32(src   ));
 
711
        ST32(dst+4 , LD32(src+4 ));
 
712
        dst+=dstStride;
 
713
        src+=srcStride;
 
714
    }
 
715
}
 
716
 
 
717
static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
718
{
 
719
    int i;
 
720
    for(i=0; i<h; i++)
 
721
    {
 
722
        ST32(dst   , LD32(src   ));
 
723
        ST32(dst+4 , LD32(src+4 ));
 
724
        dst[8]= src[8];
 
725
        dst+=dstStride;
 
726
        src+=srcStride;
 
727
    }
 
728
}
 
729
 
 
730
static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
731
{
 
732
    int i;
 
733
    for(i=0; i<h; i++)
 
734
    {
 
735
        ST32(dst   , LD32(src   ));
 
736
        ST32(dst+4 , LD32(src+4 ));
 
737
        ST32(dst+8 , LD32(src+8 ));
 
738
        ST32(dst+12, LD32(src+12));
 
739
        dst+=dstStride;
 
740
        src+=srcStride;
 
741
    }
 
742
}
 
743
 
 
744
static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h)
 
745
{
 
746
    int i;
 
747
    for(i=0; i<h; i++)
 
748
    {
 
749
        ST32(dst   , LD32(src   ));
 
750
        ST32(dst+4 , LD32(src+4 ));
 
751
        ST32(dst+8 , LD32(src+8 ));
 
752
        ST32(dst+12, LD32(src+12));
 
753
        dst[16]= src[16];
 
754
        dst+=dstStride;
 
755
        src+=srcStride;
 
756
    }
 
757
}
500
758
 
501
759
#endif