(commit by michael)
[ffmpeg.git] / libavcodec / dsputil.c
1 /*
2  * DSP utils
3  * Copyright (c) 2000, 2001 Gerard Lantau.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "simple_idct.h"
24
25 void (*ff_idct)(DCTELEM *block);
26 void (*get_pixels)(DCTELEM *block, const UINT8 *pixels, int line_size);
27 void (*put_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
28 void (*add_pixels_clamped)(const DCTELEM *block, UINT8 *pixels, int line_size);
29
30 op_pixels_abs_func pix_abs16x16;
31 op_pixels_abs_func pix_abs16x16_x2;
32 op_pixels_abs_func pix_abs16x16_y2;
33 op_pixels_abs_func pix_abs16x16_xy2;
34
35 UINT8 cropTbl[256 + 2 * MAX_NEG_CROP];
36 UINT32 squareTbl[512];
37
38 extern UINT16 default_intra_matrix[64];
39 extern UINT16 default_non_intra_matrix[64];
40
41 UINT8 zigzag_direct[64] = {
42     0, 1, 8, 16, 9, 2, 3, 10,
43     17, 24, 32, 25, 18, 11, 4, 5,
44     12, 19, 26, 33, 40, 48, 41, 34,
45     27, 20, 13, 6, 7, 14, 21, 28,
46     35, 42, 49, 56, 57, 50, 43, 36,
47     29, 22, 15, 23, 30, 37, 44, 51,
48     58, 59, 52, 45, 38, 31, 39, 46,
49     53, 60, 61, 54, 47, 55, 62, 63
50 };
51
52 UINT8 ff_alternate_horizontal_scan[64] = {
53     0,  1,  2,  3,  8,  9, 16, 17, 
54     10, 11,  4,  5,  6,  7, 15, 14,
55     13, 12, 19, 18, 24, 25, 32, 33, 
56     26, 27, 20, 21, 22, 23, 28, 29,
57     30, 31, 34, 35, 40, 41, 48, 49, 
58     42, 43, 36, 37, 38, 39, 44, 45,
59     46, 47, 50, 51, 56, 57, 58, 59, 
60     52, 53, 54, 55, 60, 61, 62, 63,
61 };
62
63 UINT8 ff_alternate_vertical_scan[64] = {
64     0,  8, 16, 24,  1,  9,  2, 10, 
65     17, 25, 32, 40, 48, 56, 57, 49,
66     41, 33, 26, 18,  3, 11,  4, 12, 
67     19, 27, 34, 42, 50, 58, 35, 43,
68     51, 59, 20, 28,  5, 13,  6, 14, 
69     21, 29, 36, 44, 52, 60, 37, 45,
70     53, 61, 22, 30,  7, 15, 23, 31, 
71     38, 46, 54, 62, 39, 47, 55, 63,
72 };
73
74
75 static UINT8 simple_mmx_permutation[64]={
76         0x00, 0x08, 0x01, 0x09, 0x04, 0x0C, 0x05, 0x0D,
77         0x10, 0x18, 0x11, 0x19, 0x14, 0x1C, 0x15, 0x1D,
78         0x02, 0x0A, 0x03, 0x0B, 0x06, 0x0E, 0x07, 0x0F,
79         0x12, 0x1A, 0x13, 0x1B, 0x16, 0x1E, 0x17, 0x1F,
80         0x20, 0x28, 0x21, 0x29, 0x24, 0x2C, 0x25, 0x2D,
81         0x30, 0x38, 0x31, 0x39, 0x34, 0x3C, 0x35, 0x3D,
82         0x22, 0x2A, 0x23, 0x2B, 0x26, 0x2E, 0x27, 0x2F,
83         0x32, 0x3A, 0x33, 0x3B, 0x36, 0x3E, 0x37, 0x3F,
84 };
85
86 /* used to skip zeros at the end */
87 UINT8 zigzag_end[64];
88
89 UINT8 permutation[64];
90 //UINT8 invPermutation[64];
91
92 static void build_zigzag_end()
93 {
94     int lastIndex;
95     int lastIndexAfterPerm=0;
96     for(lastIndex=0; lastIndex<64; lastIndex++)
97     {
98         if(zigzag_direct[lastIndex] > lastIndexAfterPerm) 
99             lastIndexAfterPerm= zigzag_direct[lastIndex];
100         zigzag_end[lastIndex]= lastIndexAfterPerm + 1;
101     }
102 }
103
104 void get_pixels_c(DCTELEM *block, const UINT8 *pixels, int line_size)
105 {
106     DCTELEM *p;
107     const UINT8 *pix;
108     int i;
109
110     /* read the pixels */
111     p = block;
112     pix = pixels;
113     for(i=0;i<8;i++) {
114         p[0] = pix[0];
115         p[1] = pix[1];
116         p[2] = pix[2];
117         p[3] = pix[3];
118         p[4] = pix[4];
119         p[5] = pix[5];
120         p[6] = pix[6];
121         p[7] = pix[7];
122         pix += line_size;
123         p += 8;
124     }
125 }
126
127 void put_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)
128 {
129     const DCTELEM *p;
130     UINT8 *pix;
131     int i;
132     UINT8 *cm = cropTbl + MAX_NEG_CROP;
133     
134     /* read the pixels */
135     p = block;
136     pix = pixels;
137     for(i=0;i<8;i++) {
138         pix[0] = cm[p[0]];
139         pix[1] = cm[p[1]];
140         pix[2] = cm[p[2]];
141         pix[3] = cm[p[3]];
142         pix[4] = cm[p[4]];
143         pix[5] = cm[p[5]];
144         pix[6] = cm[p[6]];
145         pix[7] = cm[p[7]];
146         pix += line_size;
147         p += 8;
148     }
149 }
150
151 void add_pixels_clamped_c(const DCTELEM *block, UINT8 *pixels, int line_size)
152 {
153     const DCTELEM *p;
154     UINT8 *pix;
155     int i;
156     UINT8 *cm = cropTbl + MAX_NEG_CROP;
157     
158     /* read the pixels */
159     p = block;
160     pix = pixels;
161     for(i=0;i<8;i++) {
162         pix[0] = cm[pix[0] + p[0]];
163         pix[1] = cm[pix[1] + p[1]];
164         pix[2] = cm[pix[2] + p[2]];
165         pix[3] = cm[pix[3] + p[3]];
166         pix[4] = cm[pix[4] + p[4]];
167         pix[5] = cm[pix[5] + p[5]];
168         pix[6] = cm[pix[6] + p[6]];
169         pix[7] = cm[pix[7] + p[7]];
170         pix += line_size;
171         p += 8;
172     }
173 }
174
175 #define PIXOP(BTYPE, OPNAME, OP, INCR)                                                   \
176                                                                                          \
177 static void OPNAME ## _pixels(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \
178 {                                                                                        \
179     BTYPE *p;                                                                            \
180     const UINT8 *pix;                                                                    \
181                                                                                          \
182     p = block;                                                                           \
183     pix = pixels;                                                                        \
184     do {                                                                                 \
185         OP(p[0], pix[0]);                                                                  \
186         OP(p[1], pix[1]);                                                                  \
187         OP(p[2], pix[2]);                                                                  \
188         OP(p[3], pix[3]);                                                                  \
189         OP(p[4], pix[4]);                                                                  \
190         OP(p[5], pix[5]);                                                                  \
191         OP(p[6], pix[6]);                                                                  \
192         OP(p[7], pix[7]);                                                                  \
193         pix += line_size;                                                                \
194         p += INCR;                                                                       \
195     } while (--h);;                                                                       \
196 }                                                                                        \
197                                                                                          \
198 static void OPNAME ## _pixels_x2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \
199 {                                                                                        \
200     BTYPE *p;                                                                          \
201     const UINT8 *pix;                                                                    \
202                                                                                          \
203     p = block;                                                                           \
204     pix = pixels;                                                                        \
205     do {                                                                   \
206         OP(p[0], avg2(pix[0], pix[1]));                                                    \
207         OP(p[1], avg2(pix[1], pix[2]));                                                    \
208         OP(p[2], avg2(pix[2], pix[3]));                                                    \
209         OP(p[3], avg2(pix[3], pix[4]));                                                    \
210         OP(p[4], avg2(pix[4], pix[5]));                                                    \
211         OP(p[5], avg2(pix[5], pix[6]));                                                    \
212         OP(p[6], avg2(pix[6], pix[7]));                                                    \
213         OP(p[7], avg2(pix[7], pix[8]));                                                    \
214         pix += line_size;                                                                \
215         p += INCR;                                                                       \
216     } while (--h);                                                                        \
217 }                                                                                        \
218                                                                                          \
219 static void OPNAME ## _pixels_y2(BTYPE *block, const UINT8 *pixels, int line_size, int h)     \
220 {                                                                                        \
221     BTYPE *p;                                                                          \
222     const UINT8 *pix;                                                                    \
223     const UINT8 *pix1;                                                                   \
224                                                                                          \
225     p = block;                                                                           \
226     pix = pixels;                                                                        \
227     pix1 = pixels + line_size;                                                           \
228     do {                                                                                 \
229         OP(p[0], avg2(pix[0], pix1[0]));                                                   \
230         OP(p[1], avg2(pix[1], pix1[1]));                                                   \
231         OP(p[2], avg2(pix[2], pix1[2]));                                                   \
232         OP(p[3], avg2(pix[3], pix1[3]));                                                   \
233         OP(p[4], avg2(pix[4], pix1[4]));                                                   \
234         OP(p[5], avg2(pix[5], pix1[5]));                                                   \
235         OP(p[6], avg2(pix[6], pix1[6]));                                                   \
236         OP(p[7], avg2(pix[7], pix1[7]));                                                   \
237         pix += line_size;                                                                \
238         pix1 += line_size;                                                               \
239         p += INCR;                                                                       \
240     } while(--h);                                                                         \
241 }                                                                                        \
242                                                                                          \
243 static void OPNAME ## _pixels_xy2(BTYPE *block, const UINT8 *pixels, int line_size, int h)    \
244 {                                                                                        \
245     BTYPE *p;                                                                          \
246     const UINT8 *pix;                                                                    \
247     const UINT8 *pix1;                                                                   \
248                                                                                          \
249     p = block;                                                                           \
250     pix = pixels;                                                                        \
251     pix1 = pixels + line_size;                                                           \
252     do {                                                                   \
253         OP(p[0], avg4(pix[0], pix[1], pix1[0], pix1[1]));                                  \
254         OP(p[1], avg4(pix[1], pix[2], pix1[1], pix1[2]));                                  \
255         OP(p[2], avg4(pix[2], pix[3], pix1[2], pix1[3]));                                  \
256         OP(p[3], avg4(pix[3], pix[4], pix1[3], pix1[4]));                                  \
257         OP(p[4], avg4(pix[4], pix[5], pix1[4], pix1[5]));                                  \
258         OP(p[5], avg4(pix[5], pix[6], pix1[5], pix1[6]));                                  \
259         OP(p[6], avg4(pix[6], pix[7], pix1[6], pix1[7]));                                  \
260         OP(p[7], avg4(pix[7], pix[8], pix1[7], pix1[8]));                                  \
261         pix += line_size;                                                                \
262         pix1 += line_size;                                                               \
263         p += INCR;                                                                       \
264     } while(--h);                                                                         \
265 }                                                                                        \
266                                                                                          \
267 void (*OPNAME ## _pixels_tab[4])(BTYPE *block, const UINT8 *pixels, int line_size, int h) = { \
268     OPNAME ## _pixels,                                                                   \
269     OPNAME ## _pixels_x2,                                                                \
270     OPNAME ## _pixels_y2,                                                                \
271     OPNAME ## _pixels_xy2,                                                               \
272 };
273
274
275 /* rounding primitives */
276 #define avg2(a,b) ((a+b+1)>>1)
277 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
278
279 #define op_put(a, b) a = b
280 #define op_avg(a, b) a = avg2(a, b)
281 #define op_sub(a, b) a -= b
282
283 PIXOP(UINT8, put, op_put, line_size)
284 PIXOP(UINT8, avg, op_avg, line_size)
285
286 PIXOP(DCTELEM, sub, op_sub, 8)
287
288 /* not rounding primitives */
289 #undef avg2
290 #undef avg4
291 #define avg2(a,b) ((a+b)>>1)
292 #define avg4(a,b,c,d) ((a+b+c+d+1)>>2)
293
294 PIXOP(UINT8, put_no_rnd, op_put, line_size)
295 PIXOP(UINT8, avg_no_rnd, op_avg, line_size)
296
297 /* motion estimation */
298
299 #undef avg2
300 #undef avg4
301 #define avg2(a,b) ((a+b+1)>>1)
302 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
303
304 int pix_abs16x16_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
305 {
306     int s, i;
307
308     s = 0;
309     for(i=0;i<h;i++) {
310         s += abs(pix1[0] - pix2[0]);
311         s += abs(pix1[1] - pix2[1]);
312         s += abs(pix1[2] - pix2[2]);
313         s += abs(pix1[3] - pix2[3]);
314         s += abs(pix1[4] - pix2[4]);
315         s += abs(pix1[5] - pix2[5]);
316         s += abs(pix1[6] - pix2[6]);
317         s += abs(pix1[7] - pix2[7]);
318         s += abs(pix1[8] - pix2[8]);
319         s += abs(pix1[9] - pix2[9]);
320         s += abs(pix1[10] - pix2[10]);
321         s += abs(pix1[11] - pix2[11]);
322         s += abs(pix1[12] - pix2[12]);
323         s += abs(pix1[13] - pix2[13]);
324         s += abs(pix1[14] - pix2[14]);
325         s += abs(pix1[15] - pix2[15]);
326         pix1 += line_size;
327         pix2 += line_size;
328     }
329     return s;
330 }
331
332 int pix_abs16x16_x2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
333 {
334     int s, i;
335
336     s = 0;
337     for(i=0;i<h;i++) {
338         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
339         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
340         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
341         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
342         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
343         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
344         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
345         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
346         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
347         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
348         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
349         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
350         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
351         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
352         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
353         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
354         pix1 += line_size;
355         pix2 += line_size;
356     }
357     return s;
358 }
359
360 int pix_abs16x16_y2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
361 {
362     int s, i;
363     UINT8 *pix3 = pix2 + line_size;
364
365     s = 0;
366     for(i=0;i<h;i++) {
367         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
368         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
369         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
370         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
371         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
372         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
373         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
374         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
375         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
376         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
377         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
378         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
379         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
380         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
381         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
382         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
383         pix1 += line_size;
384         pix2 += line_size;
385         pix3 += line_size;
386     }
387     return s;
388 }
389
390 int pix_abs16x16_xy2_c(UINT8 *pix1, UINT8 *pix2, int line_size, int h)
391 {
392     int s, i;
393     UINT8 *pix3 = pix2 + line_size;
394
395     s = 0;
396     for(i=0;i<h;i++) {
397         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
398         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
399         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
400         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
401         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
402         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
403         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
404         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
405         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
406         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
407         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
408         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
409         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
410         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
411         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
412         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
413         pix1 += line_size;
414         pix2 += line_size;
415         pix3 += line_size;
416     }
417     return s;
418 }
419
420 /* permute block according so that it corresponds to the MMX idct
421    order */
422 #ifdef SIMPLE_IDCT
423  /* general permutation, but perhaps slightly slower */
424 void block_permute(INT16 *block)
425 {
426         int i;
427         INT16 temp[64];
428
429         for(i=0; i<64; i++) temp[ block_permute_op(i) ] = block[i];
430
431         for(i=0; i<64; i++) block[i] = temp[i];
432 }
433 #else
434
435 void block_permute(INT16 *block)
436 {
437     int tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
438     int i;
439
440     for(i=0;i<8;i++) {
441         tmp1 = block[1];
442         tmp2 = block[2];
443         tmp3 = block[3];
444         tmp4 = block[4];
445         tmp5 = block[5];
446         tmp6 = block[6];
447         block[1] = tmp2;
448         block[2] = tmp4;
449         block[3] = tmp6;
450         block[4] = tmp1;
451         block[5] = tmp3;
452         block[6] = tmp5;
453         block += 8;
454     }
455 }
456 #endif
457
458 void dsputil_init(void)
459 {
460     int i, j;
461     int use_permuted_idct;
462
463     for(i=0;i<256;i++) cropTbl[i + MAX_NEG_CROP] = i;
464     for(i=0;i<MAX_NEG_CROP;i++) {
465         cropTbl[i] = 0;
466         cropTbl[i + MAX_NEG_CROP + 256] = 255;
467     }
468
469     for(i=0;i<512;i++) {
470         squareTbl[i] = (i - 256) * (i - 256);
471     }
472
473 #ifdef SIMPLE_IDCT
474     ff_idct = simple_idct;
475 #else
476     ff_idct = j_rev_dct;
477 #endif
478     get_pixels = get_pixels_c;
479     put_pixels_clamped = put_pixels_clamped_c;
480     add_pixels_clamped = add_pixels_clamped_c;
481
482     pix_abs16x16 = pix_abs16x16_c;
483     pix_abs16x16_x2 = pix_abs16x16_x2_c;
484     pix_abs16x16_y2 = pix_abs16x16_y2_c;
485     pix_abs16x16_xy2 = pix_abs16x16_xy2_c;
486     av_fdct = jpeg_fdct_ifast;
487
488     use_permuted_idct = 1;
489
490 #ifdef HAVE_MMX
491     dsputil_init_mmx();
492 #endif
493 #ifdef ARCH_ARMV4L
494     dsputil_init_armv4l();
495 #endif
496 #ifdef HAVE_MLIB
497     dsputil_init_mlib();
498     use_permuted_idct = 0;
499 #endif
500
501 #ifdef SIMPLE_IDCT
502     if(ff_idct == simple_idct) use_permuted_idct=0;
503 #endif
504
505     if(use_permuted_idct)
506 #ifdef SIMPLE_IDCT
507         for(i=0; i<64; i++) permutation[i]= simple_mmx_permutation[i];
508 #else
509         for(i=0; i<64; i++) permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
510 #endif
511     else
512         for(i=0; i<64; i++) permutation[i]=i;
513
514     if (use_permuted_idct) {
515         /* permute for IDCT */
516         for(i=0;i<64;i++) {
517             j = zigzag_direct[i];
518             zigzag_direct[i] = block_permute_op(j);
519             j = ff_alternate_horizontal_scan[i];
520             ff_alternate_horizontal_scan[i] = block_permute_op(j);
521             j = ff_alternate_vertical_scan[i];
522             ff_alternate_vertical_scan[i] = block_permute_op(j);
523         }
524         block_permute(default_intra_matrix);
525         block_permute(default_non_intra_matrix);
526     }
527     
528     build_zigzag_end();
529 }