diff options
Diffstat (limited to 'apps/codecs/libcook/dsputil.h')
-rw-r--r-- | apps/codecs/libcook/dsputil.h | 898 |
1 files changed, 898 insertions, 0 deletions
diff --git a/apps/codecs/libcook/dsputil.h b/apps/codecs/libcook/dsputil.h new file mode 100644 index 0000000000..e9c2bfc77e --- /dev/null +++ b/apps/codecs/libcook/dsputil.h | |||
@@ -0,0 +1,898 @@ | |||
1 | /* | ||
2 | * DSP utils | ||
3 | * Copyright (c) 2000, 2001, 2002 Fabrice Bellard | ||
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 | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * 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 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * 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 | */ | ||
22 | |||
23 | /** | ||
24 | * @file libavcodec/dsputil.h | ||
25 | * DSP utils. | ||
26 | * note, many functions in here may use MMX which trashes the FPU state, it is | ||
27 | * absolutely necessary to call emms_c() between dsp & float/double code | ||
28 | */ | ||
29 | |||
30 | #ifndef AVCODEC_DSPUTIL_H | ||
31 | #define AVCODEC_DSPUTIL_H | ||
32 | |||
33 | #include "libavutil/intreadwrite.h" | ||
34 | #include "avcodec.h" | ||
35 | |||
36 | |||
37 | //#define DEBUG | ||
38 | /* dct code */ | ||
39 | typedef short DCTELEM; | ||
40 | typedef int DWTELEM; | ||
41 | typedef short IDWTELEM; | ||
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); | ||
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); | ||
53 | |||
54 | void ff_fdct_mmx(DCTELEM *block); | ||
55 | void ff_fdct_mmx2(DCTELEM *block); | ||
56 | void ff_fdct_sse2(DCTELEM *block); | ||
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 | void ff_h264_idct8_dc_add_c(uint8_t *dst, DCTELEM *block, int stride); | ||
61 | void ff_h264_idct_dc_add_c(uint8_t *dst, DCTELEM *block, int stride); | ||
62 | void ff_h264_lowres_idct_add_c(uint8_t *dst, int stride, DCTELEM *block); | ||
63 | void ff_h264_lowres_idct_put_c(uint8_t *dst, int stride, DCTELEM *block); | ||
64 | void ff_h264_idct_add16_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]); | ||
65 | void ff_h264_idct_add16intra_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]); | ||
66 | void ff_h264_idct8_add4_c(uint8_t *dst, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]); | ||
67 | void ff_h264_idct_add8_c(uint8_t **dest, const int *blockoffset, DCTELEM *block, int stride, const uint8_t nnzc[6*8]); | ||
68 | |||
69 | void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1, | ||
70 | const float *src2, int src3, int blocksize, int step); | ||
71 | void ff_vector_fmul_window_c(float *dst, const float *src0, const float *src1, | ||
72 | const float *win, float add_bias, int len); | ||
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 | extern const uint8_t ff_alternate_horizontal_scan[64]; | ||
78 | extern const uint8_t ff_alternate_vertical_scan[64]; | ||
79 | extern const uint8_t ff_zigzag_direct[64]; | ||
80 | extern const uint8_t ff_zigzag248_direct[64]; | ||
81 | |||
82 | /* pixel operations */ | ||
83 | #define MAX_NEG_CROP 1024 | ||
84 | |||
85 | /* temporary */ | ||
86 | extern uint32_t ff_squareTbl[512]; | ||
87 | extern uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP]; | ||
88 | |||
89 | /* VP3 DSP functions */ | ||
90 | void ff_vp3_idct_c(DCTELEM *block/* align 16*/); | ||
91 | void ff_vp3_idct_put_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); | ||
92 | void ff_vp3_idct_add_c(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); | ||
93 | |||
94 | void ff_vp3_v_loop_filter_c(uint8_t *src, int stride, int *bounding_values); | ||
95 | void ff_vp3_h_loop_filter_c(uint8_t *src, int stride, int *bounding_values); | ||
96 | |||
97 | /* VP6 DSP functions */ | ||
98 | void ff_vp6_filter_diag4_c(uint8_t *dst, uint8_t *src, int stride, | ||
99 | const int16_t *h_weights, const int16_t *v_weights); | ||
100 | |||
101 | /* 1/2^n downscaling functions from imgconvert.c */ | ||
102 | void ff_img_copy_plane(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); | ||
103 | void ff_shrink22(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); | ||
104 | void ff_shrink44(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); | ||
105 | void ff_shrink88(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); | ||
106 | |||
107 | void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy, | ||
108 | int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height); | ||
109 | |||
110 | /* minimum alignment rules ;) | ||
111 | If you notice errors in the align stuff, need more alignment for some ASM code | ||
112 | for some CPU or need to use a function with less aligned data then send a mail | ||
113 | to the ffmpeg-devel mailing list, ... | ||
114 | |||
115 | !warning These alignments might not match reality, (missing attribute((align)) | ||
116 | stuff somewhere possible). | ||
117 | I (Michael) did not check them, these are just the alignments which I think | ||
118 | could be reached easily ... | ||
119 | |||
120 | !future video codecs might need functions with less strict alignment | ||
121 | */ | ||
122 | |||
123 | /* | ||
124 | void get_pixels_c(DCTELEM *block, const uint8_t *pixels, int line_size); | ||
125 | void diff_pixels_c(DCTELEM *block, const uint8_t *s1, const uint8_t *s2, int stride); | ||
126 | void put_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size); | ||
127 | void add_pixels_clamped_c(const DCTELEM *block, uint8_t *pixels, int line_size); | ||
128 | void clear_blocks_c(DCTELEM *blocks); | ||
129 | */ | ||
130 | |||
131 | /* add and put pixel (decoding) */ | ||
132 | // blocksizes for op_pixels_func are 8x4,8x8 16x8 16x16 | ||
133 | //h for op_pixels_func is limited to {width/2, width} but never larger than 16 and never smaller then 4 | ||
134 | typedef void (*op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h); | ||
135 | 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); | ||
136 | typedef void (*qpel_mc_func)(uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride); | ||
137 | typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y); | ||
138 | typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset); | ||
139 | typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset); | ||
140 | |||
141 | #define DEF_OLD_QPEL(name)\ | ||
142 | void ff_put_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\ | ||
143 | void ff_put_no_rnd_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\ | ||
144 | void ff_avg_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride); | ||
145 | |||
146 | DEF_OLD_QPEL(qpel16_mc11_old_c) | ||
147 | DEF_OLD_QPEL(qpel16_mc31_old_c) | ||
148 | DEF_OLD_QPEL(qpel16_mc12_old_c) | ||
149 | DEF_OLD_QPEL(qpel16_mc32_old_c) | ||
150 | DEF_OLD_QPEL(qpel16_mc13_old_c) | ||
151 | DEF_OLD_QPEL(qpel16_mc33_old_c) | ||
152 | DEF_OLD_QPEL(qpel8_mc11_old_c) | ||
153 | DEF_OLD_QPEL(qpel8_mc31_old_c) | ||
154 | DEF_OLD_QPEL(qpel8_mc12_old_c) | ||
155 | DEF_OLD_QPEL(qpel8_mc32_old_c) | ||
156 | DEF_OLD_QPEL(qpel8_mc13_old_c) | ||
157 | DEF_OLD_QPEL(qpel8_mc33_old_c) | ||
158 | |||
159 | #define CALL_2X_PIXELS(a, b, n)\ | ||
160 | static void a(uint8_t *block, const uint8_t *pixels, int line_size, int h){\ | ||
161 | b(block , pixels , line_size, h);\ | ||
162 | b(block+n, pixels+n, line_size, h);\ | ||
163 | } | ||
164 | |||
165 | /* motion estimation */ | ||
166 | // h is limited to {width/2, width, 2*width} but never larger than 16 and never smaller then 2 | ||
167 | // although currently h<4 is not used as functions with width <8 are neither used nor implemented | ||
168 | 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))*/; | ||
169 | |||
170 | |||
171 | // for snow slices | ||
172 | typedef struct slice_buffer_s slice_buffer; | ||
173 | |||
174 | /** | ||
175 | * Scantable. | ||
176 | */ | ||
177 | typedef struct ScanTable{ | ||
178 | const uint8_t *scantable; | ||
179 | uint8_t permutated[64]; | ||
180 | uint8_t raster_end[64]; | ||
181 | #if ARCH_PPC | ||
182 | /** Used by dct_quantize_altivec to find last-non-zero */ | ||
183 | DECLARE_ALIGNED(16, uint8_t, inverse[64]); | ||
184 | #endif | ||
185 | } ScanTable; | ||
186 | |||
187 | void ff_init_scantable(uint8_t *, ScanTable *st, const uint8_t *src_scantable); | ||
188 | |||
189 | void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, | ||
190 | int block_w, int block_h, | ||
191 | int src_x, int src_y, int w, int h); | ||
192 | |||
193 | /** | ||
194 | * DSPContext. | ||
195 | */ | ||
196 | typedef struct DSPContext { | ||
197 | /* pixel ops : interface with DCT */ | ||
198 | void (*get_pixels)(DCTELEM *block/*align 16*/, const uint8_t *pixels/*align 8*/, int line_size); | ||
199 | void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride); | ||
200 | void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size); | ||
201 | void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size); | ||
202 | void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size); | ||
203 | void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size); | ||
204 | void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size); | ||
205 | int (*sum_abs_dctelem)(DCTELEM *block/*align 16*/); | ||
206 | /** | ||
207 | * translational global motion compensation. | ||
208 | */ | ||
209 | void (*gmc1)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x16, int y16, int rounder); | ||
210 | /** | ||
211 | * global motion compensation. | ||
212 | */ | ||
213 | void (*gmc )(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int ox, int oy, | ||
214 | int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height); | ||
215 | void (*clear_block)(DCTELEM *block/*align 16*/); | ||
216 | void (*clear_blocks)(DCTELEM *blocks/*align 16*/); | ||
217 | int (*pix_sum)(uint8_t * pix, int line_size); | ||
218 | int (*pix_norm1)(uint8_t * pix, int line_size); | ||
219 | // 16x16 8x8 4x4 2x2 16x8 8x4 4x2 8x16 4x8 2x4 | ||
220 | |||
221 | me_cmp_func sad[6]; /* identical to pix_absAxA except additional void * */ | ||
222 | me_cmp_func sse[6]; | ||
223 | me_cmp_func hadamard8_diff[6]; | ||
224 | me_cmp_func dct_sad[6]; | ||
225 | me_cmp_func quant_psnr[6]; | ||
226 | me_cmp_func bit[6]; | ||
227 | me_cmp_func rd[6]; | ||
228 | me_cmp_func vsad[6]; | ||
229 | me_cmp_func vsse[6]; | ||
230 | me_cmp_func nsse[6]; | ||
231 | me_cmp_func w53[6]; | ||
232 | me_cmp_func w97[6]; | ||
233 | me_cmp_func dct_max[6]; | ||
234 | me_cmp_func dct264_sad[6]; | ||
235 | |||
236 | me_cmp_func me_pre_cmp[6]; | ||
237 | me_cmp_func me_cmp[6]; | ||
238 | me_cmp_func me_sub_cmp[6]; | ||
239 | me_cmp_func mb_cmp[6]; | ||
240 | me_cmp_func ildct_cmp[6]; //only width 16 used | ||
241 | me_cmp_func frame_skip_cmp[6]; //only width 8 used | ||
242 | |||
243 | int (*ssd_int8_vs_int16)(const int8_t *pix1, const int16_t *pix2, | ||
244 | int size); | ||
245 | |||
246 | /** | ||
247 | * Halfpel motion compensation with rounding (a+b+1)>>1. | ||
248 | * this is an array[4][4] of motion compensation functions for 4 | ||
249 | * horizontal blocksizes (8,16) and the 4 halfpel positions<br> | ||
250 | * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ] | ||
251 | * @param block destination where the result is stored | ||
252 | * @param pixels source | ||
253 | * @param line_size number of bytes in a horizontal line of block | ||
254 | * @param h height | ||
255 | */ | ||
256 | op_pixels_func put_pixels_tab[4][4]; | ||
257 | |||
258 | /** | ||
259 | * Halfpel motion compensation with rounding (a+b+1)>>1. | ||
260 | * This is an array[4][4] of motion compensation functions for 4 | ||
261 | * horizontal blocksizes (8,16) and the 4 halfpel positions<br> | ||
262 | * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ] | ||
263 | * @param block destination into which the result is averaged (a+b+1)>>1 | ||
264 | * @param pixels source | ||
265 | * @param line_size number of bytes in a horizontal line of block | ||
266 | * @param h height | ||
267 | */ | ||
268 | op_pixels_func avg_pixels_tab[4][4]; | ||
269 | |||
270 | /** | ||
271 | * Halfpel motion compensation with no rounding (a+b)>>1. | ||
272 | * this is an array[2][4] of motion compensation functions for 2 | ||
273 | * horizontal blocksizes (8,16) and the 4 halfpel positions<br> | ||
274 | * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ] | ||
275 | * @param block destination where the result is stored | ||
276 | * @param pixels source | ||
277 | * @param line_size number of bytes in a horizontal line of block | ||
278 | * @param h height | ||
279 | */ | ||
280 | op_pixels_func put_no_rnd_pixels_tab[4][4]; | ||
281 | |||
282 | /** | ||
283 | * Halfpel motion compensation with no rounding (a+b)>>1. | ||
284 | * this is an array[2][4] of motion compensation functions for 2 | ||
285 | * horizontal blocksizes (8,16) and the 4 halfpel positions<br> | ||
286 | * *pixels_tab[ 0->16xH 1->8xH ][ xhalfpel + 2*yhalfpel ] | ||
287 | * @param block destination into which the result is averaged (a+b)>>1 | ||
288 | * @param pixels source | ||
289 | * @param line_size number of bytes in a horizontal line of block | ||
290 | * @param h height | ||
291 | */ | ||
292 | op_pixels_func avg_no_rnd_pixels_tab[4][4]; | ||
293 | |||
294 | 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); | ||
295 | |||
296 | /** | ||
297 | * Thirdpel motion compensation with rounding (a+b+1)>>1. | ||
298 | * this is an array[12] of motion compensation functions for the 9 thirdpe | ||
299 | * positions<br> | ||
300 | * *pixels_tab[ xthirdpel + 4*ythirdpel ] | ||
301 | * @param block destination where the result is stored | ||
302 | * @param pixels source | ||
303 | * @param line_size number of bytes in a horizontal line of block | ||
304 | * @param h height | ||
305 | */ | ||
306 | tpel_mc_func put_tpel_pixels_tab[11]; //FIXME individual func ptr per width? | ||
307 | tpel_mc_func avg_tpel_pixels_tab[11]; //FIXME individual func ptr per width? | ||
308 | |||
309 | qpel_mc_func put_qpel_pixels_tab[2][16]; | ||
310 | qpel_mc_func avg_qpel_pixels_tab[2][16]; | ||
311 | qpel_mc_func put_no_rnd_qpel_pixels_tab[2][16]; | ||
312 | qpel_mc_func avg_no_rnd_qpel_pixels_tab[2][16]; | ||
313 | qpel_mc_func put_mspel_pixels_tab[8]; | ||
314 | |||
315 | /** | ||
316 | * h264 Chroma MC | ||
317 | */ | ||
318 | h264_chroma_mc_func put_h264_chroma_pixels_tab[3]; | ||
319 | /* This is really one func used in VC-1 decoding */ | ||
320 | h264_chroma_mc_func put_no_rnd_h264_chroma_pixels_tab[3]; | ||
321 | h264_chroma_mc_func avg_h264_chroma_pixels_tab[3]; | ||
322 | |||
323 | qpel_mc_func put_h264_qpel_pixels_tab[4][16]; | ||
324 | qpel_mc_func avg_h264_qpel_pixels_tab[4][16]; | ||
325 | |||
326 | qpel_mc_func put_2tap_qpel_pixels_tab[4][16]; | ||
327 | qpel_mc_func avg_2tap_qpel_pixels_tab[4][16]; | ||
328 | |||
329 | h264_weight_func weight_h264_pixels_tab[10]; | ||
330 | h264_biweight_func biweight_h264_pixels_tab[10]; | ||
331 | |||
332 | /* AVS specific */ | ||
333 | qpel_mc_func put_cavs_qpel_pixels_tab[2][16]; | ||
334 | qpel_mc_func avg_cavs_qpel_pixels_tab[2][16]; | ||
335 | void (*cavs_filter_lv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2); | ||
336 | void (*cavs_filter_lh)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2); | ||
337 | void (*cavs_filter_cv)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2); | ||
338 | void (*cavs_filter_ch)(uint8_t *pix, int stride, int alpha, int beta, int tc, int bs1, int bs2); | ||
339 | void (*cavs_idct8_add)(uint8_t *dst, DCTELEM *block, int stride); | ||
340 | |||
341 | me_cmp_func pix_abs[2][4]; | ||
342 | |||
343 | /* huffyuv specific */ | ||
344 | void (*add_bytes)(uint8_t *dst/*align 16*/, uint8_t *src/*align 16*/, int w); | ||
345 | void (*add_bytes_l2)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 16*/, int w); | ||
346 | void (*diff_bytes)(uint8_t *dst/*align 16*/, uint8_t *src1/*align 16*/, uint8_t *src2/*align 1*/,int w); | ||
347 | /** | ||
348 | * subtract huffyuv's variant of median prediction | ||
349 | * note, this might read from src1[-1], src2[-1] | ||
350 | */ | ||
351 | void (*sub_hfyu_median_prediction)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top); | ||
352 | void (*add_hfyu_median_prediction)(uint8_t *dst, uint8_t *top, uint8_t *diff, int w, int *left, int *left_top); | ||
353 | /* this might write to dst[w] */ | ||
354 | void (*add_png_paeth_prediction)(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp); | ||
355 | void (*bswap_buf)(uint32_t *dst, const uint32_t *src, int w); | ||
356 | |||
357 | void (*h264_v_loop_filter_luma)(uint8_t *pix/*align 16*/, int stride, int alpha, int beta, int8_t *tc0); | ||
358 | void (*h264_h_loop_filter_luma)(uint8_t *pix/*align 4 */, int stride, int alpha, int beta, int8_t *tc0); | ||
359 | /* v/h_loop_filter_luma_intra: align 16 */ | ||
360 | void (*h264_v_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta); | ||
361 | void (*h264_h_loop_filter_luma_intra)(uint8_t *pix, int stride, int alpha, int beta); | ||
362 | void (*h264_v_loop_filter_chroma)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta, int8_t *tc0); | ||
363 | void (*h264_h_loop_filter_chroma)(uint8_t *pix/*align 4*/, int stride, int alpha, int beta, int8_t *tc0); | ||
364 | void (*h264_v_loop_filter_chroma_intra)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta); | ||
365 | void (*h264_h_loop_filter_chroma_intra)(uint8_t *pix/*align 8*/, int stride, int alpha, int beta); | ||
366 | // h264_loop_filter_strength: simd only. the C version is inlined in h264.c | ||
367 | 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], | ||
368 | int bidir, int edges, int step, int mask_mv0, int mask_mv1, int field); | ||
369 | |||
370 | void (*h263_v_loop_filter)(uint8_t *src, int stride, int qscale); | ||
371 | void (*h263_h_loop_filter)(uint8_t *src, int stride, int qscale); | ||
372 | |||
373 | void (*h261_loop_filter)(uint8_t *src, int stride); | ||
374 | |||
375 | void (*x8_v_loop_filter)(uint8_t *src, int stride, int qscale); | ||
376 | void (*x8_h_loop_filter)(uint8_t *src, int stride, int qscale); | ||
377 | |||
378 | void (*vp3_v_loop_filter)(uint8_t *src, int stride, int *bounding_values); | ||
379 | void (*vp3_h_loop_filter)(uint8_t *src, int stride, int *bounding_values); | ||
380 | |||
381 | void (*vp6_filter_diag4)(uint8_t *dst, uint8_t *src, int stride, | ||
382 | const int16_t *h_weights,const int16_t *v_weights); | ||
383 | |||
384 | /* assume len is a multiple of 4, and arrays are 16-byte aligned */ | ||
385 | void (*vorbis_inverse_coupling)(float *mag, float *ang, int blocksize); | ||
386 | void (*ac3_downmix)(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len); | ||
387 | /* no alignment needed */ | ||
388 | void (*flac_compute_autocorr)(const int32_t *data, int len, int lag, double *autoc); | ||
389 | /* assume len is a multiple of 8, and arrays are 16-byte aligned */ | ||
390 | void (*vector_fmul)(float *dst, const float *src, int len); | ||
391 | void (*vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len); | ||
392 | /* assume len is a multiple of 8, and src arrays are 16-byte aligned */ | ||
393 | void (*vector_fmul_add_add)(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step); | ||
394 | /* assume len is a multiple of 4, and arrays are 16-byte aligned */ | ||
395 | void (*vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, float add_bias, int len); | ||
396 | /* assume len is a multiple of 8, and arrays are 16-byte aligned */ | ||
397 | void (*int32_to_float_fmul_scalar)(float *dst, const int *src, float mul, int len); | ||
398 | |||
399 | /* C version: convert floats from the range [384.0,386.0] to ints in [-32768,32767] | ||
400 | * simd versions: convert floats from [-32768.0,32767.0] without rescaling and arrays are 16byte aligned */ | ||
401 | void (*float_to_int16)(int16_t *dst, const float *src, long len); | ||
402 | void (*float_to_int16_interleave)(int16_t *dst, const float **src, long len, int channels); | ||
403 | |||
404 | /* (I)DCT */ | ||
405 | void (*fdct)(DCTELEM *block/* align 16*/); | ||
406 | void (*fdct248)(DCTELEM *block/* align 16*/); | ||
407 | |||
408 | /* IDCT really*/ | ||
409 | void (*idct)(DCTELEM *block/* align 16*/); | ||
410 | |||
411 | /** | ||
412 | * block -> idct -> clip to unsigned 8 bit -> dest. | ||
413 | * (-1392, 0, 0, ...) -> idct -> (-174, -174, ...) -> put -> (0, 0, ...) | ||
414 | * @param line_size size in bytes of a horizontal line of dest | ||
415 | */ | ||
416 | void (*idct_put)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); | ||
417 | |||
418 | /** | ||
419 | * block -> idct -> add dest -> clip to unsigned 8 bit -> dest. | ||
420 | * @param line_size size in bytes of a horizontal line of dest | ||
421 | */ | ||
422 | void (*idct_add)(uint8_t *dest/*align 8*/, int line_size, DCTELEM *block/*align 16*/); | ||
423 | |||
424 | /** | ||
425 | * idct input permutation. | ||
426 | * several optimized IDCTs need a permutated input (relative to the normal order of the reference | ||
427 | * IDCT) | ||
428 | * this permutation must be performed before the idct_put/add, note, normally this can be merged | ||
429 | * with the zigzag/alternate scan<br> | ||
430 | * an example to avoid confusion: | ||
431 | * - (->decode coeffs -> zigzag reorder -> dequant -> reference idct ->...) | ||
432 | * - (x -> referece dct -> reference idct -> x) | ||
433 | * - (x -> referece dct -> simple_mmx_perm = idct_permutation -> simple_idct_mmx -> x) | ||
434 | * - (->decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant -> simple_idct_mmx ->...) | ||
435 | */ | ||
436 | uint8_t idct_permutation[64]; | ||
437 | int idct_permutation_type; | ||
438 | #define FF_NO_IDCT_PERM 1 | ||
439 | #define FF_LIBMPEG2_IDCT_PERM 2 | ||
440 | #define FF_SIMPLE_IDCT_PERM 3 | ||
441 | #define FF_TRANSPOSE_IDCT_PERM 4 | ||
442 | #define FF_PARTTRANS_IDCT_PERM 5 | ||
443 | #define FF_SSE2_IDCT_PERM 6 | ||
444 | |||
445 | int (*try_8x8basis)(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale); | ||
446 | void (*add_8x8basis)(int16_t rem[64], int16_t basis[64], int scale); | ||
447 | #define BASIS_SHIFT 16 | ||
448 | #define RECON_SHIFT 6 | ||
449 | |||
450 | void (*draw_edges)(uint8_t *buf, int wrap, int width, int height, int w); | ||
451 | #define EDGE_WIDTH 16 | ||
452 | |||
453 | /* h264 functions */ | ||
454 | /* NOTE!!! if you implement any of h264_idct8_add, h264_idct8_add4 then you must implement all of them | ||
455 | 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 | ||
456 | The reason for above, is that no 2 out of one list may use a different permutation. | ||
457 | */ | ||
458 | void (*h264_idct_add)(uint8_t *dst/*align 4*/, DCTELEM *block/*align 16*/, int stride); | ||
459 | void (*h264_idct8_add)(uint8_t *dst/*align 8*/, DCTELEM *block/*align 16*/, int stride); | ||
460 | void (*h264_idct_dc_add)(uint8_t *dst/*align 4*/, DCTELEM *block/*align 16*/, int stride); | ||
461 | void (*h264_idct8_dc_add)(uint8_t *dst/*align 8*/, DCTELEM *block/*align 16*/, int stride); | ||
462 | void (*h264_dct)(DCTELEM block[4][4]); | ||
463 | void (*h264_idct_add16)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]); | ||
464 | void (*h264_idct8_add4)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]); | ||
465 | void (*h264_idct_add8)(uint8_t **dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]); | ||
466 | void (*h264_idct_add16intra)(uint8_t *dst/*align 16*/, const int *blockoffset, DCTELEM *block/*align 16*/, int stride, const uint8_t nnzc[6*8]); | ||
467 | |||
468 | /* snow wavelet */ | ||
469 | void (*vertical_compose97i)(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width); | ||
470 | void (*horizontal_compose97i)(IDWTELEM *b, int width); | ||
471 | 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); | ||
472 | |||
473 | void (*prefetch)(void *mem, int stride, int h); | ||
474 | |||
475 | void (*shrink[4])(uint8_t *dst, int dst_wrap, const uint8_t *src, int src_wrap, int width, int height); | ||
476 | |||
477 | /* vc1 functions */ | ||
478 | void (*vc1_inv_trans_8x8)(DCTELEM *b); | ||
479 | void (*vc1_inv_trans_8x4)(uint8_t *dest, int line_size, DCTELEM *block); | ||
480 | void (*vc1_inv_trans_4x8)(uint8_t *dest, int line_size, DCTELEM *block); | ||
481 | void (*vc1_inv_trans_4x4)(uint8_t *dest, int line_size, DCTELEM *block); | ||
482 | void (*vc1_v_overlap)(uint8_t* src, int stride); | ||
483 | void (*vc1_h_overlap)(uint8_t* src, int stride); | ||
484 | /* put 8x8 block with bicubic interpolation and quarterpel precision | ||
485 | * last argument is actually round value instead of height | ||
486 | */ | ||
487 | op_pixels_func put_vc1_mspel_pixels_tab[16]; | ||
488 | |||
489 | /* intrax8 functions */ | ||
490 | void (*x8_spatial_compensation[12])(uint8_t *src , uint8_t *dst, int linesize); | ||
491 | void (*x8_setup_spatial_compensation)(uint8_t *src, uint8_t *dst, int linesize, | ||
492 | int * range, int * sum, int edges); | ||
493 | |||
494 | /* ape functions */ | ||
495 | /** | ||
496 | * Add contents of the second vector to the first one. | ||
497 | * @param len length of vectors, should be multiple of 16 | ||
498 | */ | ||
499 | void (*add_int16)(int16_t *v1/*align 16*/, int16_t *v2, int len); | ||
500 | /** | ||
501 | * Add contents of the second vector to the first one. | ||
502 | * @param len length of vectors, should be multiple of 16 | ||
503 | */ | ||
504 | void (*sub_int16)(int16_t *v1/*align 16*/, int16_t *v2, int len); | ||
505 | /** | ||
506 | * Calculate scalar product of two vectors. | ||
507 | * @param len length of vectors, should be multiple of 16 | ||
508 | * @param shift number of bits to discard from product | ||
509 | */ | ||
510 | int32_t (*scalarproduct_int16)(int16_t *v1, int16_t *v2/*align 16*/, int len, int shift); | ||
511 | |||
512 | /* rv30 functions */ | ||
513 | qpel_mc_func put_rv30_tpel_pixels_tab[4][16]; | ||
514 | qpel_mc_func avg_rv30_tpel_pixels_tab[4][16]; | ||
515 | |||
516 | /* rv40 functions */ | ||
517 | qpel_mc_func put_rv40_qpel_pixels_tab[4][16]; | ||
518 | qpel_mc_func avg_rv40_qpel_pixels_tab[4][16]; | ||
519 | h264_chroma_mc_func put_rv40_chroma_pixels_tab[3]; | ||
520 | h264_chroma_mc_func avg_rv40_chroma_pixels_tab[3]; | ||
521 | } DSPContext; | ||
522 | |||
523 | void dsputil_static_init(void); | ||
524 | void dsputil_init(DSPContext* p, AVCodecContext *avctx); | ||
525 | |||
526 | int ff_check_alignment(void); | ||
527 | |||
528 | /** | ||
529 | * permute block according to permuatation. | ||
530 | * @param last last non zero element in scantable order | ||
531 | */ | ||
532 | void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last); | ||
533 | |||
534 | void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type); | ||
535 | |||
536 | #define BYTE_VEC32(c) ((c)*0x01010101UL) | ||
537 | |||
538 | static inline uint32_t rnd_avg32(uint32_t a, uint32_t b) | ||
539 | { | ||
540 | return (a | b) - (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1); | ||
541 | } | ||
542 | |||
543 | static inline uint32_t no_rnd_avg32(uint32_t a, uint32_t b) | ||
544 | { | ||
545 | return (a & b) + (((a ^ b) & ~BYTE_VEC32(0x01)) >> 1); | ||
546 | } | ||
547 | |||
548 | static inline int get_penalty_factor(int lambda, int lambda2, int type){ | ||
549 | switch(type&0xFF){ | ||
550 | default: | ||
551 | case FF_CMP_SAD: | ||
552 | return lambda>>FF_LAMBDA_SHIFT; | ||
553 | case FF_CMP_DCT: | ||
554 | return (3*lambda)>>(FF_LAMBDA_SHIFT+1); | ||
555 | case FF_CMP_W53: | ||
556 | return (4*lambda)>>(FF_LAMBDA_SHIFT); | ||
557 | case FF_CMP_W97: | ||
558 | return (2*lambda)>>(FF_LAMBDA_SHIFT); | ||
559 | case FF_CMP_SATD: | ||
560 | case FF_CMP_DCT264: | ||
561 | return (2*lambda)>>FF_LAMBDA_SHIFT; | ||
562 | case FF_CMP_RD: | ||
563 | case FF_CMP_PSNR: | ||
564 | case FF_CMP_SSE: | ||
565 | case FF_CMP_NSSE: | ||
566 | return lambda2>>FF_LAMBDA_SHIFT; | ||
567 | case FF_CMP_BIT: | ||
568 | return 1; | ||
569 | } | ||
570 | } | ||
571 | |||
572 | /** | ||
573 | * Empty mmx state. | ||
574 | * this must be called between any dsp function and float/double code. | ||
575 | * for example sin(); dsp->idct_put(); emms_c(); cos() | ||
576 | */ | ||
577 | #define emms_c() | ||
578 | |||
579 | /* should be defined by architectures supporting | ||
580 | one or more MultiMedia extension */ | ||
581 | int mm_support(void); | ||
582 | |||
583 | void dsputil_init_alpha(DSPContext* c, AVCodecContext *avctx); | ||
584 | void dsputil_init_arm(DSPContext* c, AVCodecContext *avctx); | ||
585 | void dsputil_init_bfin(DSPContext* c, AVCodecContext *avctx); | ||
586 | void dsputil_init_mlib(DSPContext* c, AVCodecContext *avctx); | ||
587 | void dsputil_init_mmi(DSPContext* c, AVCodecContext *avctx); | ||
588 | void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx); | ||
589 | void dsputil_init_ppc(DSPContext* c, AVCodecContext *avctx); | ||
590 | void dsputil_init_sh4(DSPContext* c, AVCodecContext *avctx); | ||
591 | void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx); | ||
592 | |||
593 | #define DECLARE_ALIGNED_16(t, v) DECLARE_ALIGNED(16, t, v) | ||
594 | |||
595 | #if HAVE_MMX | ||
596 | |||
597 | #undef emms_c | ||
598 | |||
599 | extern int mm_flags; | ||
600 | |||
601 | void add_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size); | ||
602 | void put_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size); | ||
603 | void put_signed_pixels_clamped_mmx(const DCTELEM *block, uint8_t *pixels, int line_size); | ||
604 | |||
605 | static inline void emms(void) | ||
606 | { | ||
607 | __asm__ volatile ("emms;":::"memory"); | ||
608 | } | ||
609 | |||
610 | |||
611 | #define emms_c() \ | ||
612 | {\ | ||
613 | if (mm_flags & FF_MM_MMX)\ | ||
614 | emms();\ | ||
615 | } | ||
616 | |||
617 | void dsputil_init_pix_mmx(DSPContext* c, AVCodecContext *avctx); | ||
618 | |||
619 | #elif ARCH_ARM | ||
620 | |||
621 | extern int mm_flags; | ||
622 | |||
623 | #if HAVE_NEON | ||
624 | # define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v) | ||
625 | # define STRIDE_ALIGN 16 | ||
626 | #endif | ||
627 | |||
628 | #elif ARCH_PPC | ||
629 | |||
630 | extern int mm_flags; | ||
631 | |||
632 | #define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v) | ||
633 | #define STRIDE_ALIGN 16 | ||
634 | |||
635 | #elif HAVE_MMI | ||
636 | |||
637 | #define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(16, t, v) | ||
638 | #define STRIDE_ALIGN 16 | ||
639 | |||
640 | #else | ||
641 | |||
642 | #define mm_flags 0 | ||
643 | #define mm_support() 0 | ||
644 | |||
645 | #endif | ||
646 | |||
647 | #ifndef DECLARE_ALIGNED_8 | ||
648 | # define DECLARE_ALIGNED_8(t, v) DECLARE_ALIGNED(8, t, v) | ||
649 | #endif | ||
650 | |||
651 | #ifndef STRIDE_ALIGN | ||
652 | # define STRIDE_ALIGN 8 | ||
653 | #endif | ||
654 | |||
655 | /* PSNR */ | ||
656 | void get_psnr(uint8_t *orig_image[3], uint8_t *coded_image[3], | ||
657 | int orig_linesize[3], int coded_linesize, | ||
658 | AVCodecContext *avctx); | ||
659 | |||
660 | /* FFT computation */ | ||
661 | |||
662 | /* NOTE: soon integer code will be added, so you must use the | ||
663 | FFTSample type */ | ||
664 | typedef float FFTSample; | ||
665 | |||
666 | struct MDCTContext; | ||
667 | |||
668 | typedef struct FFTComplex { | ||
669 | FFTSample re, im; | ||
670 | } FFTComplex; | ||
671 | |||
672 | typedef struct FFTContext { | ||
673 | int nbits; | ||
674 | int inverse; | ||
675 | uint16_t *revtab; | ||
676 | FFTComplex *exptab; | ||
677 | FFTComplex *exptab1; /* only used by SSE code */ | ||
678 | FFTComplex *tmp_buf; | ||
679 | void (*fft_permute)(struct FFTContext *s, FFTComplex *z); | ||
680 | void (*fft_calc)(struct FFTContext *s, FFTComplex *z); | ||
681 | void (*imdct_calc)(struct MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
682 | void (*imdct_half)(struct MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
683 | } FFTContext; | ||
684 | |||
685 | extern FFTSample* ff_cos_tabs[13]; | ||
686 | |||
687 | /** | ||
688 | * Sets up a complex FFT. | ||
689 | * @param nbits log2 of the length of the input array | ||
690 | * @param inverse if 0 perform the forward transform, if 1 perform the inverse | ||
691 | */ | ||
692 | int ff_fft_init(FFTContext *s, int nbits, int inverse); | ||
693 | void ff_fft_permute_c(FFTContext *s, FFTComplex *z); | ||
694 | void ff_fft_permute_sse(FFTContext *s, FFTComplex *z); | ||
695 | void ff_fft_calc_c(FFTContext *s, FFTComplex *z); | ||
696 | void ff_fft_calc_sse(FFTContext *s, FFTComplex *z); | ||
697 | void ff_fft_calc_3dn(FFTContext *s, FFTComplex *z); | ||
698 | void ff_fft_calc_3dn2(FFTContext *s, FFTComplex *z); | ||
699 | void ff_fft_calc_altivec(FFTContext *s, FFTComplex *z); | ||
700 | |||
701 | /** | ||
702 | * Do the permutation needed BEFORE calling ff_fft_calc(). | ||
703 | */ | ||
704 | static inline void ff_fft_permute(FFTContext *s, FFTComplex *z) | ||
705 | { | ||
706 | s->fft_permute(s, z); | ||
707 | } | ||
708 | /** | ||
709 | * Do a complex FFT with the parameters defined in ff_fft_init(). The | ||
710 | * input data must be permuted before. No 1.0/sqrt(n) normalization is done. | ||
711 | */ | ||
712 | static inline void ff_fft_calc(FFTContext *s, FFTComplex *z) | ||
713 | { | ||
714 | s->fft_calc(s, z); | ||
715 | } | ||
716 | void ff_fft_end(FFTContext *s); | ||
717 | |||
718 | /* MDCT computation */ | ||
719 | |||
720 | typedef struct MDCTContext { | ||
721 | int n; /* size of MDCT (i.e. number of input data * 2) */ | ||
722 | int nbits; /* n = 2^nbits */ | ||
723 | /* pre/post rotation tables */ | ||
724 | FFTSample *tcos; | ||
725 | FFTSample *tsin; | ||
726 | FFTContext fft; | ||
727 | } MDCTContext; | ||
728 | |||
729 | static inline void ff_imdct_calc(MDCTContext *s, FFTSample *output, const FFTSample *input) | ||
730 | { | ||
731 | s->fft.imdct_calc(s, output, input); | ||
732 | } | ||
733 | static inline void ff_imdct_half(MDCTContext *s, FFTSample *output, const FFTSample *input) | ||
734 | { | ||
735 | s->fft.imdct_half(s, output, input); | ||
736 | } | ||
737 | |||
738 | /** | ||
739 | * Generate a Kaiser-Bessel Derived Window. | ||
740 | * @param window pointer to half window | ||
741 | * @param alpha determines window shape | ||
742 | * @param n size of half window | ||
743 | */ | ||
744 | void ff_kbd_window_init(float *window, float alpha, int n); | ||
745 | |||
746 | /** | ||
747 | * Generate a sine window. | ||
748 | * @param window pointer to half window | ||
749 | * @param n size of half window | ||
750 | */ | ||
751 | void ff_sine_window_init(float *window, int n); | ||
752 | extern float ff_sine_128 [ 128]; | ||
753 | extern float ff_sine_256 [ 256]; | ||
754 | extern float ff_sine_512 [ 512]; | ||
755 | extern float ff_sine_1024[1024]; | ||
756 | extern float ff_sine_2048[2048]; | ||
757 | extern float ff_sine_4096[4096]; | ||
758 | extern float *ff_sine_windows[6]; | ||
759 | |||
760 | int ff_mdct_init(MDCTContext *s, int nbits, int inverse); | ||
761 | void ff_imdct_calc_c(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
762 | void ff_imdct_half_c(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
763 | void ff_imdct_calc_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
764 | void ff_imdct_half_3dn(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
765 | void ff_imdct_calc_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
766 | void ff_imdct_half_3dn2(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
767 | void ff_imdct_calc_sse(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
768 | void ff_imdct_half_sse(MDCTContext *s, FFTSample *output, const FFTSample *input); | ||
769 | void ff_mdct_calc(MDCTContext *s, FFTSample *out, const FFTSample *input); | ||
770 | void ff_mdct_end(MDCTContext *s); | ||
771 | |||
772 | /* Real Discrete Fourier Transform */ | ||
773 | |||
774 | enum RDFTransformType { | ||
775 | RDFT, | ||
776 | IRDFT, | ||
777 | RIDFT, | ||
778 | IRIDFT, | ||
779 | }; | ||
780 | |||
781 | typedef struct { | ||
782 | int nbits; | ||
783 | int inverse; | ||
784 | int sign_convention; | ||
785 | |||
786 | /* pre/post rotation tables */ | ||
787 | FFTSample *tcos; | ||
788 | FFTSample *tsin; | ||
789 | FFTContext fft; | ||
790 | } RDFTContext; | ||
791 | |||
792 | /** | ||
793 | * Sets up a real FFT. | ||
794 | * @param nbits log2 of the length of the input array | ||
795 | * @param trans the type of transform | ||
796 | */ | ||
797 | int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans); | ||
798 | void ff_rdft_calc(RDFTContext *s, FFTSample *data); | ||
799 | void ff_rdft_end(RDFTContext *s); | ||
800 | |||
801 | #define WRAPPER8_16(name8, name16)\ | ||
802 | static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\ | ||
803 | return name8(s, dst , src , stride, h)\ | ||
804 | +name8(s, dst+8 , src+8 , stride, h);\ | ||
805 | } | ||
806 | |||
807 | #define WRAPPER8_16_SQ(name8, name16)\ | ||
808 | static int name16(void /*MpegEncContext*/ *s, uint8_t *dst, uint8_t *src, int stride, int h){\ | ||
809 | int score=0;\ | ||
810 | score +=name8(s, dst , src , stride, 8);\ | ||
811 | score +=name8(s, dst+8 , src+8 , stride, 8);\ | ||
812 | if(h==16){\ | ||
813 | dst += 8*stride;\ | ||
814 | src += 8*stride;\ | ||
815 | score +=name8(s, dst , src , stride, 8);\ | ||
816 | score +=name8(s, dst+8 , src+8 , stride, 8);\ | ||
817 | }\ | ||
818 | return score;\ | ||
819 | } | ||
820 | |||
821 | |||
822 | static inline void copy_block2(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
823 | { | ||
824 | int i; | ||
825 | for(i=0; i<h; i++) | ||
826 | { | ||
827 | AV_WN16(dst , AV_RN16(src )); | ||
828 | dst+=dstStride; | ||
829 | src+=srcStride; | ||
830 | } | ||
831 | } | ||
832 | |||
833 | static inline void copy_block4(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
834 | { | ||
835 | int i; | ||
836 | for(i=0; i<h; i++) | ||
837 | { | ||
838 | AV_WN32(dst , AV_RN32(src )); | ||
839 | dst+=dstStride; | ||
840 | src+=srcStride; | ||
841 | } | ||
842 | } | ||
843 | |||
844 | static inline void copy_block8(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
845 | { | ||
846 | int i; | ||
847 | for(i=0; i<h; i++) | ||
848 | { | ||
849 | AV_WN32(dst , AV_RN32(src )); | ||
850 | AV_WN32(dst+4 , AV_RN32(src+4 )); | ||
851 | dst+=dstStride; | ||
852 | src+=srcStride; | ||
853 | } | ||
854 | } | ||
855 | |||
856 | static inline void copy_block9(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
857 | { | ||
858 | int i; | ||
859 | for(i=0; i<h; i++) | ||
860 | { | ||
861 | AV_WN32(dst , AV_RN32(src )); | ||
862 | AV_WN32(dst+4 , AV_RN32(src+4 )); | ||
863 | dst[8]= src[8]; | ||
864 | dst+=dstStride; | ||
865 | src+=srcStride; | ||
866 | } | ||
867 | } | ||
868 | |||
869 | static inline void copy_block16(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
870 | { | ||
871 | int i; | ||
872 | for(i=0; i<h; i++) | ||
873 | { | ||
874 | AV_WN32(dst , AV_RN32(src )); | ||
875 | AV_WN32(dst+4 , AV_RN32(src+4 )); | ||
876 | AV_WN32(dst+8 , AV_RN32(src+8 )); | ||
877 | AV_WN32(dst+12, AV_RN32(src+12)); | ||
878 | dst+=dstStride; | ||
879 | src+=srcStride; | ||
880 | } | ||
881 | } | ||
882 | |||
883 | static inline void copy_block17(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h) | ||
884 | { | ||
885 | int i; | ||
886 | for(i=0; i<h; i++) | ||
887 | { | ||
888 | AV_WN32(dst , AV_RN32(src )); | ||
889 | AV_WN32(dst+4 , AV_RN32(src+4 )); | ||
890 | AV_WN32(dst+8 , AV_RN32(src+8 )); | ||
891 | AV_WN32(dst+12, AV_RN32(src+12)); | ||
892 | dst[16]= src[16]; | ||
893 | dst+=dstStride; | ||
894 | src+=srcStride; | ||
895 | } | ||
896 | } | ||
897 | |||
898 | #endif /* AVCODEC_DSPUTIL_H */ | ||