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