dsputil: template get_pixels() for different bit depths
[ffmpeg.git] / libavcodec / dsputil.c
1 /*
2  * DSP utils
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of Libav.
9  *
10  * Libav is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * Libav is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with Libav; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 /**
26  * @file
27  * DSP utils
28  */
29
30 #include "libavutil/imgutils.h"
31 #include "avcodec.h"
32 #include "dsputil.h"
33 #include "simple_idct.h"
34 #include "faandct.h"
35 #include "faanidct.h"
36 #include "mathops.h"
37 #include "mpegvideo.h"
38 #include "config.h"
39 #include "ac3dec.h"
40 #include "vorbis.h"
41 #include "png.h"
42
43 uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
44 uint32_t ff_squareTbl[512] = {0, };
45
46 #define BIT_DEPTH 9
47 #include "dsputil_template.c"
48 #undef BIT_DEPTH
49
50 #define BIT_DEPTH 10
51 #include "dsputil_template.c"
52 #undef BIT_DEPTH
53
54 #define BIT_DEPTH 8
55 #include "dsputil_template.c"
56
57 // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
58 #define pb_7f (~0UL/255 * 0x7f)
59 #define pb_80 (~0UL/255 * 0x80)
60
61 const uint8_t ff_zigzag_direct[64] = {
62     0,   1,  8, 16,  9,  2,  3, 10,
63     17, 24, 32, 25, 18, 11,  4,  5,
64     12, 19, 26, 33, 40, 48, 41, 34,
65     27, 20, 13,  6,  7, 14, 21, 28,
66     35, 42, 49, 56, 57, 50, 43, 36,
67     29, 22, 15, 23, 30, 37, 44, 51,
68     58, 59, 52, 45, 38, 31, 39, 46,
69     53, 60, 61, 54, 47, 55, 62, 63
70 };
71
72 /* Specific zigzag scan for 248 idct. NOTE that unlike the
73    specification, we interleave the fields */
74 const uint8_t ff_zigzag248_direct[64] = {
75      0,  8,  1,  9, 16, 24,  2, 10,
76     17, 25, 32, 40, 48, 56, 33, 41,
77     18, 26,  3, 11,  4, 12, 19, 27,
78     34, 42, 49, 57, 50, 58, 35, 43,
79     20, 28,  5, 13,  6, 14, 21, 29,
80     36, 44, 51, 59, 52, 60, 37, 45,
81     22, 30,  7, 15, 23, 31, 38, 46,
82     53, 61, 54, 62, 39, 47, 55, 63,
83 };
84
85 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
86 DECLARE_ALIGNED(16, uint16_t, inv_zigzag_direct16)[64];
87
88 const uint8_t ff_alternate_horizontal_scan[64] = {
89     0,  1,   2,  3,  8,  9, 16, 17,
90     10, 11,  4,  5,  6,  7, 15, 14,
91     13, 12, 19, 18, 24, 25, 32, 33,
92     26, 27, 20, 21, 22, 23, 28, 29,
93     30, 31, 34, 35, 40, 41, 48, 49,
94     42, 43, 36, 37, 38, 39, 44, 45,
95     46, 47, 50, 51, 56, 57, 58, 59,
96     52, 53, 54, 55, 60, 61, 62, 63,
97 };
98
99 const uint8_t ff_alternate_vertical_scan[64] = {
100     0,  8,  16, 24,  1,  9,  2, 10,
101     17, 25, 32, 40, 48, 56, 57, 49,
102     41, 33, 26, 18,  3, 11,  4, 12,
103     19, 27, 34, 42, 50, 58, 35, 43,
104     51, 59, 20, 28,  5, 13,  6, 14,
105     21, 29, 36, 44, 52, 60, 37, 45,
106     53, 61, 22, 30,  7, 15, 23, 31,
107     38, 46, 54, 62, 39, 47, 55, 63,
108 };
109
110 /* Input permutation for the simple_idct_mmx */
111 static const uint8_t simple_mmx_permutation[64]={
112         0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
113         0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
114         0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
115         0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
116         0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
117         0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
118         0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
119         0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
120 };
121
122 static const uint8_t idct_sse2_row_perm[8] = {0, 4, 1, 5, 2, 6, 3, 7};
123
124 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
125     int i;
126     int end;
127
128     st->scantable= src_scantable;
129
130     for(i=0; i<64; i++){
131         int j;
132         j = src_scantable[i];
133         st->permutated[i] = permutation[j];
134 #if ARCH_PPC
135         st->inverse[j] = i;
136 #endif
137     }
138
139     end=-1;
140     for(i=0; i<64; i++){
141         int j;
142         j = st->permutated[i];
143         if(j>end) end=j;
144         st->raster_end[i]= end;
145     }
146 }
147
148 static int pix_sum_c(uint8_t * pix, int line_size)
149 {
150     int s, i, j;
151
152     s = 0;
153     for (i = 0; i < 16; i++) {
154         for (j = 0; j < 16; j += 8) {
155             s += pix[0];
156             s += pix[1];
157             s += pix[2];
158             s += pix[3];
159             s += pix[4];
160             s += pix[5];
161             s += pix[6];
162             s += pix[7];
163             pix += 8;
164         }
165         pix += line_size - 16;
166     }
167     return s;
168 }
169
170 static int pix_norm1_c(uint8_t * pix, int line_size)
171 {
172     int s, i, j;
173     uint32_t *sq = ff_squareTbl + 256;
174
175     s = 0;
176     for (i = 0; i < 16; i++) {
177         for (j = 0; j < 16; j += 8) {
178 #if 0
179             s += sq[pix[0]];
180             s += sq[pix[1]];
181             s += sq[pix[2]];
182             s += sq[pix[3]];
183             s += sq[pix[4]];
184             s += sq[pix[5]];
185             s += sq[pix[6]];
186             s += sq[pix[7]];
187 #else
188 #if HAVE_FAST_64BIT
189             register uint64_t x=*(uint64_t*)pix;
190             s += sq[x&0xff];
191             s += sq[(x>>8)&0xff];
192             s += sq[(x>>16)&0xff];
193             s += sq[(x>>24)&0xff];
194             s += sq[(x>>32)&0xff];
195             s += sq[(x>>40)&0xff];
196             s += sq[(x>>48)&0xff];
197             s += sq[(x>>56)&0xff];
198 #else
199             register uint32_t x=*(uint32_t*)pix;
200             s += sq[x&0xff];
201             s += sq[(x>>8)&0xff];
202             s += sq[(x>>16)&0xff];
203             s += sq[(x>>24)&0xff];
204             x=*(uint32_t*)(pix+4);
205             s += sq[x&0xff];
206             s += sq[(x>>8)&0xff];
207             s += sq[(x>>16)&0xff];
208             s += sq[(x>>24)&0xff];
209 #endif
210 #endif
211             pix += 8;
212         }
213         pix += line_size - 16;
214     }
215     return s;
216 }
217
218 static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
219     int i;
220
221     for(i=0; i+8<=w; i+=8){
222         dst[i+0]= av_bswap32(src[i+0]);
223         dst[i+1]= av_bswap32(src[i+1]);
224         dst[i+2]= av_bswap32(src[i+2]);
225         dst[i+3]= av_bswap32(src[i+3]);
226         dst[i+4]= av_bswap32(src[i+4]);
227         dst[i+5]= av_bswap32(src[i+5]);
228         dst[i+6]= av_bswap32(src[i+6]);
229         dst[i+7]= av_bswap32(src[i+7]);
230     }
231     for(;i<w; i++){
232         dst[i+0]= av_bswap32(src[i+0]);
233     }
234 }
235
236 static void bswap16_buf(uint16_t *dst, const uint16_t *src, int len)
237 {
238     while (len--)
239         *dst++ = av_bswap16(*src++);
240 }
241
242 static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
243 {
244     int s, i;
245     uint32_t *sq = ff_squareTbl + 256;
246
247     s = 0;
248     for (i = 0; i < h; i++) {
249         s += sq[pix1[0] - pix2[0]];
250         s += sq[pix1[1] - pix2[1]];
251         s += sq[pix1[2] - pix2[2]];
252         s += sq[pix1[3] - pix2[3]];
253         pix1 += line_size;
254         pix2 += line_size;
255     }
256     return s;
257 }
258
259 static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
260 {
261     int s, i;
262     uint32_t *sq = ff_squareTbl + 256;
263
264     s = 0;
265     for (i = 0; i < h; i++) {
266         s += sq[pix1[0] - pix2[0]];
267         s += sq[pix1[1] - pix2[1]];
268         s += sq[pix1[2] - pix2[2]];
269         s += sq[pix1[3] - pix2[3]];
270         s += sq[pix1[4] - pix2[4]];
271         s += sq[pix1[5] - pix2[5]];
272         s += sq[pix1[6] - pix2[6]];
273         s += sq[pix1[7] - pix2[7]];
274         pix1 += line_size;
275         pix2 += line_size;
276     }
277     return s;
278 }
279
280 static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
281 {
282     int s, i;
283     uint32_t *sq = ff_squareTbl + 256;
284
285     s = 0;
286     for (i = 0; i < h; i++) {
287         s += sq[pix1[ 0] - pix2[ 0]];
288         s += sq[pix1[ 1] - pix2[ 1]];
289         s += sq[pix1[ 2] - pix2[ 2]];
290         s += sq[pix1[ 3] - pix2[ 3]];
291         s += sq[pix1[ 4] - pix2[ 4]];
292         s += sq[pix1[ 5] - pix2[ 5]];
293         s += sq[pix1[ 6] - pix2[ 6]];
294         s += sq[pix1[ 7] - pix2[ 7]];
295         s += sq[pix1[ 8] - pix2[ 8]];
296         s += sq[pix1[ 9] - pix2[ 9]];
297         s += sq[pix1[10] - pix2[10]];
298         s += sq[pix1[11] - pix2[11]];
299         s += sq[pix1[12] - pix2[12]];
300         s += sq[pix1[13] - pix2[13]];
301         s += sq[pix1[14] - pix2[14]];
302         s += sq[pix1[15] - pix2[15]];
303
304         pix1 += line_size;
305         pix2 += line_size;
306     }
307     return s;
308 }
309
310 static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
311                           const uint8_t *s2, int stride){
312     int i;
313
314     /* read the pixels */
315     for(i=0;i<8;i++) {
316         block[0] = s1[0] - s2[0];
317         block[1] = s1[1] - s2[1];
318         block[2] = s1[2] - s2[2];
319         block[3] = s1[3] - s2[3];
320         block[4] = s1[4] - s2[4];
321         block[5] = s1[5] - s2[5];
322         block[6] = s1[6] - s2[6];
323         block[7] = s1[7] - s2[7];
324         s1 += stride;
325         s2 += stride;
326         block += 8;
327     }
328 }
329
330
331 void ff_put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
332                              int line_size)
333 {
334     int i;
335     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
336
337     /* read the pixels */
338     for(i=0;i<8;i++) {
339         pixels[0] = cm[block[0]];
340         pixels[1] = cm[block[1]];
341         pixels[2] = cm[block[2]];
342         pixels[3] = cm[block[3]];
343         pixels[4] = cm[block[4]];
344         pixels[5] = cm[block[5]];
345         pixels[6] = cm[block[6]];
346         pixels[7] = cm[block[7]];
347
348         pixels += line_size;
349         block += 8;
350     }
351 }
352
353 static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
354                                  int line_size)
355 {
356     int i;
357     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
358
359     /* read the pixels */
360     for(i=0;i<4;i++) {
361         pixels[0] = cm[block[0]];
362         pixels[1] = cm[block[1]];
363         pixels[2] = cm[block[2]];
364         pixels[3] = cm[block[3]];
365
366         pixels += line_size;
367         block += 8;
368     }
369 }
370
371 static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
372                                  int line_size)
373 {
374     int i;
375     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
376
377     /* read the pixels */
378     for(i=0;i<2;i++) {
379         pixels[0] = cm[block[0]];
380         pixels[1] = cm[block[1]];
381
382         pixels += line_size;
383         block += 8;
384     }
385 }
386
387 void ff_put_signed_pixels_clamped_c(const DCTELEM *block,
388                                     uint8_t *restrict pixels,
389                                     int line_size)
390 {
391     int i, j;
392
393     for (i = 0; i < 8; i++) {
394         for (j = 0; j < 8; j++) {
395             if (*block < -128)
396                 *pixels = 0;
397             else if (*block > 127)
398                 *pixels = 255;
399             else
400                 *pixels = (uint8_t)(*block + 128);
401             block++;
402             pixels++;
403         }
404         pixels += (line_size - 8);
405     }
406 }
407
408 static void put_pixels_nonclamped_c(const DCTELEM *block, uint8_t *restrict pixels,
409                                     int line_size)
410 {
411     int i;
412
413     /* read the pixels */
414     for(i=0;i<8;i++) {
415         pixels[0] = block[0];
416         pixels[1] = block[1];
417         pixels[2] = block[2];
418         pixels[3] = block[3];
419         pixels[4] = block[4];
420         pixels[5] = block[5];
421         pixels[6] = block[6];
422         pixels[7] = block[7];
423
424         pixels += line_size;
425         block += 8;
426     }
427 }
428
429 void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
430                              int line_size)
431 {
432     int i;
433     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
434
435     /* read the pixels */
436     for(i=0;i<8;i++) {
437         pixels[0] = cm[pixels[0] + block[0]];
438         pixels[1] = cm[pixels[1] + block[1]];
439         pixels[2] = cm[pixels[2] + block[2]];
440         pixels[3] = cm[pixels[3] + block[3]];
441         pixels[4] = cm[pixels[4] + block[4]];
442         pixels[5] = cm[pixels[5] + block[5]];
443         pixels[6] = cm[pixels[6] + block[6]];
444         pixels[7] = cm[pixels[7] + block[7]];
445         pixels += line_size;
446         block += 8;
447     }
448 }
449
450 static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
451                           int line_size)
452 {
453     int i;
454     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
455
456     /* read the pixels */
457     for(i=0;i<4;i++) {
458         pixels[0] = cm[pixels[0] + block[0]];
459         pixels[1] = cm[pixels[1] + block[1]];
460         pixels[2] = cm[pixels[2] + block[2]];
461         pixels[3] = cm[pixels[3] + block[3]];
462         pixels += line_size;
463         block += 8;
464     }
465 }
466
467 static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
468                           int line_size)
469 {
470     int i;
471     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
472
473     /* read the pixels */
474     for(i=0;i<2;i++) {
475         pixels[0] = cm[pixels[0] + block[0]];
476         pixels[1] = cm[pixels[1] + block[1]];
477         pixels += line_size;
478         block += 8;
479     }
480 }
481
482 static int sum_abs_dctelem_c(DCTELEM *block)
483 {
484     int sum=0, i;
485     for(i=0; i<64; i++)
486         sum+= FFABS(block[i]);
487     return sum;
488 }
489
490 static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
491 {
492     int i;
493
494     for (i = 0; i < h; i++) {
495         memset(block, value, 16);
496         block += line_size;
497     }
498 }
499
500 static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
501 {
502     int i;
503
504     for (i = 0; i < h; i++) {
505         memset(block, value, 8);
506         block += line_size;
507     }
508 }
509
510 static void scale_block_c(const uint8_t src[64]/*align 8*/, uint8_t *dst/*align 8*/, int linesize)
511 {
512     int i, j;
513     uint16_t *dst1 = (uint16_t *) dst;
514     uint16_t *dst2 = (uint16_t *)(dst + linesize);
515
516     for (j = 0; j < 8; j++) {
517         for (i = 0; i < 8; i++) {
518             dst1[i] = dst2[i] = src[i] * 0x0101;
519         }
520         src  += 8;
521         dst1 += linesize;
522         dst2 += linesize;
523     }
524 }
525
526 #define avg2(a,b) ((a+b+1)>>1)
527 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
528
529 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
530 {
531     const int A=(16-x16)*(16-y16);
532     const int B=(   x16)*(16-y16);
533     const int C=(16-x16)*(   y16);
534     const int D=(   x16)*(   y16);
535     int i;
536
537     for(i=0; i<h; i++)
538     {
539         dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
540         dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
541         dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
542         dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
543         dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
544         dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
545         dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
546         dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
547         dst+= stride;
548         src+= stride;
549     }
550 }
551
552 void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
553                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
554 {
555     int y, vx, vy;
556     const int s= 1<<shift;
557
558     width--;
559     height--;
560
561     for(y=0; y<h; y++){
562         int x;
563
564         vx= ox;
565         vy= oy;
566         for(x=0; x<8; x++){ //XXX FIXME optimize
567             int src_x, src_y, frac_x, frac_y, index;
568
569             src_x= vx>>16;
570             src_y= vy>>16;
571             frac_x= src_x&(s-1);
572             frac_y= src_y&(s-1);
573             src_x>>=shift;
574             src_y>>=shift;
575
576             if((unsigned)src_x < width){
577                 if((unsigned)src_y < height){
578                     index= src_x + src_y*stride;
579                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
580                                            + src[index       +1]*   frac_x )*(s-frac_y)
581                                         + (  src[index+stride  ]*(s-frac_x)
582                                            + src[index+stride+1]*   frac_x )*   frac_y
583                                         + r)>>(shift*2);
584                 }else{
585                     index= src_x + av_clip(src_y, 0, height)*stride;
586                     dst[y*stride + x]= ( (  src[index         ]*(s-frac_x)
587                                           + src[index       +1]*   frac_x )*s
588                                         + r)>>(shift*2);
589                 }
590             }else{
591                 if((unsigned)src_y < height){
592                     index= av_clip(src_x, 0, width) + src_y*stride;
593                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_y)
594                                            + src[index+stride  ]*   frac_y )*s
595                                         + r)>>(shift*2);
596                 }else{
597                     index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
598                     dst[y*stride + x]=    src[index         ];
599                 }
600             }
601
602             vx+= dxx;
603             vy+= dyx;
604         }
605         ox += dxy;
606         oy += dyy;
607     }
608 }
609
610 static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
611     switch(width){
612     case 2: put_pixels2_8_c (dst, src, stride, height); break;
613     case 4: put_pixels4_8_c (dst, src, stride, height); break;
614     case 8: put_pixels8_8_c (dst, src, stride, height); break;
615     case 16:put_pixels16_8_c(dst, src, stride, height); break;
616     }
617 }
618
619 static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
620     int i,j;
621     for (i=0; i < height; i++) {
622       for (j=0; j < width; j++) {
623         dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
624       }
625       src += stride;
626       dst += stride;
627     }
628 }
629
630 static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
631     int i,j;
632     for (i=0; i < height; i++) {
633       for (j=0; j < width; j++) {
634         dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
635       }
636       src += stride;
637       dst += stride;
638     }
639 }
640
641 static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
642     int i,j;
643     for (i=0; i < height; i++) {
644       for (j=0; j < width; j++) {
645         dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
646       }
647       src += stride;
648       dst += stride;
649     }
650 }
651
652 static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
653     int i,j;
654     for (i=0; i < height; i++) {
655       for (j=0; j < width; j++) {
656         dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
657       }
658       src += stride;
659       dst += stride;
660     }
661 }
662
663 static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
664     int i,j;
665     for (i=0; i < height; i++) {
666       for (j=0; j < width; j++) {
667         dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
668       }
669       src += stride;
670       dst += stride;
671     }
672 }
673
674 static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
675     int i,j;
676     for (i=0; i < height; i++) {
677       for (j=0; j < width; j++) {
678         dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
679       }
680       src += stride;
681       dst += stride;
682     }
683 }
684
685 static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
686     int i,j;
687     for (i=0; i < height; i++) {
688       for (j=0; j < width; j++) {
689         dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
690       }
691       src += stride;
692       dst += stride;
693     }
694 }
695
696 static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
697     int i,j;
698     for (i=0; i < height; i++) {
699       for (j=0; j < width; j++) {
700         dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
701       }
702       src += stride;
703       dst += stride;
704     }
705 }
706
707 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
708     switch(width){
709     case 2: avg_pixels2_8_c (dst, src, stride, height); break;
710     case 4: avg_pixels4_8_c (dst, src, stride, height); break;
711     case 8: avg_pixels8_8_c (dst, src, stride, height); break;
712     case 16:avg_pixels16_8_c(dst, src, stride, height); break;
713     }
714 }
715
716 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
717     int i,j;
718     for (i=0; i < height; i++) {
719       for (j=0; j < width; j++) {
720         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
721       }
722       src += stride;
723       dst += stride;
724     }
725 }
726
727 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
728     int i,j;
729     for (i=0; i < height; i++) {
730       for (j=0; j < width; j++) {
731         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
732       }
733       src += stride;
734       dst += stride;
735     }
736 }
737
738 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
739     int i,j;
740     for (i=0; i < height; i++) {
741       for (j=0; j < width; j++) {
742         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
743       }
744       src += stride;
745       dst += stride;
746     }
747 }
748
749 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
750     int i,j;
751     for (i=0; i < height; i++) {
752       for (j=0; j < width; j++) {
753         dst[j] = (dst[j] + ((2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
754       }
755       src += stride;
756       dst += stride;
757     }
758 }
759
760 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
761     int i,j;
762     for (i=0; i < height; i++) {
763       for (j=0; j < width; j++) {
764         dst[j] = (dst[j] + ((2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
765       }
766       src += stride;
767       dst += stride;
768     }
769 }
770
771 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
772     int i,j;
773     for (i=0; i < height; i++) {
774       for (j=0; j < width; j++) {
775         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
776       }
777       src += stride;
778       dst += stride;
779     }
780 }
781
782 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
783     int i,j;
784     for (i=0; i < height; i++) {
785       for (j=0; j < width; j++) {
786         dst[j] = (dst[j] + ((2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
787       }
788       src += stride;
789       dst += stride;
790     }
791 }
792
793 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
794     int i,j;
795     for (i=0; i < height; i++) {
796       for (j=0; j < width; j++) {
797         dst[j] = (dst[j] + ((2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15) + 1) >> 1;
798       }
799       src += stride;
800       dst += stride;
801     }
802 }
803
804 #define QPEL_MC(r, OPNAME, RND, OP) \
805 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
806     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
807     int i;\
808     for(i=0; i<h; i++)\
809     {\
810         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
811         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
812         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
813         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
814         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
815         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
816         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
817         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
818         dst+=dstStride;\
819         src+=srcStride;\
820     }\
821 }\
822 \
823 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
824     const int w=8;\
825     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
826     int i;\
827     for(i=0; i<w; i++)\
828     {\
829         const int src0= src[0*srcStride];\
830         const int src1= src[1*srcStride];\
831         const int src2= src[2*srcStride];\
832         const int src3= src[3*srcStride];\
833         const int src4= src[4*srcStride];\
834         const int src5= src[5*srcStride];\
835         const int src6= src[6*srcStride];\
836         const int src7= src[7*srcStride];\
837         const int src8= src[8*srcStride];\
838         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
839         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
840         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
841         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
842         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
843         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
844         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
845         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
846         dst++;\
847         src++;\
848     }\
849 }\
850 \
851 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
852     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
853     int i;\
854     \
855     for(i=0; i<h; i++)\
856     {\
857         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
858         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
859         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
860         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
861         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
862         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
863         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
864         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
865         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
866         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
867         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
868         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
869         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
870         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
871         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
872         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
873         dst+=dstStride;\
874         src+=srcStride;\
875     }\
876 }\
877 \
878 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
879     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
880     int i;\
881     const int w=16;\
882     for(i=0; i<w; i++)\
883     {\
884         const int src0= src[0*srcStride];\
885         const int src1= src[1*srcStride];\
886         const int src2= src[2*srcStride];\
887         const int src3= src[3*srcStride];\
888         const int src4= src[4*srcStride];\
889         const int src5= src[5*srcStride];\
890         const int src6= src[6*srcStride];\
891         const int src7= src[7*srcStride];\
892         const int src8= src[8*srcStride];\
893         const int src9= src[9*srcStride];\
894         const int src10= src[10*srcStride];\
895         const int src11= src[11*srcStride];\
896         const int src12= src[12*srcStride];\
897         const int src13= src[13*srcStride];\
898         const int src14= src[14*srcStride];\
899         const int src15= src[15*srcStride];\
900         const int src16= src[16*srcStride];\
901         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
902         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
903         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
904         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
905         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
906         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
907         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
908         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
909         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
910         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
911         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
912         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
913         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
914         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
915         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
916         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
917         dst++;\
918         src++;\
919     }\
920 }\
921 \
922 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
923     uint8_t half[64];\
924     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
925     OPNAME ## pixels8_l2_8(dst, src, half, stride, stride, 8, 8);\
926 }\
927 \
928 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
929     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
930 }\
931 \
932 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
933     uint8_t half[64];\
934     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
935     OPNAME ## pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);\
936 }\
937 \
938 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
939     uint8_t full[16*9];\
940     uint8_t half[64];\
941     copy_block9(full, src, 16, stride, 9);\
942     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
943     OPNAME ## pixels8_l2_8(dst, full, half, stride, 16, 8, 8);\
944 }\
945 \
946 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
947     uint8_t full[16*9];\
948     copy_block9(full, src, 16, stride, 9);\
949     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
950 }\
951 \
952 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
953     uint8_t full[16*9];\
954     uint8_t half[64];\
955     copy_block9(full, src, 16, stride, 9);\
956     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
957     OPNAME ## pixels8_l2_8(dst, full+16, half, stride, 16, 8, 8);\
958 }\
959 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
960     uint8_t full[16*9];\
961     uint8_t halfH[72];\
962     uint8_t halfV[64];\
963     uint8_t halfHV[64];\
964     copy_block9(full, src, 16, stride, 9);\
965     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
966     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
967     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
968     OPNAME ## pixels8_l4_8(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
969 }\
970 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
971     uint8_t full[16*9];\
972     uint8_t halfH[72];\
973     uint8_t halfHV[64];\
974     copy_block9(full, src, 16, stride, 9);\
975     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
976     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
977     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
978     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
979 }\
980 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
981     uint8_t full[16*9];\
982     uint8_t halfH[72];\
983     uint8_t halfV[64];\
984     uint8_t halfHV[64];\
985     copy_block9(full, src, 16, stride, 9);\
986     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
987     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
988     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
989     OPNAME ## pixels8_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
990 }\
991 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
992     uint8_t full[16*9];\
993     uint8_t halfH[72];\
994     uint8_t halfHV[64];\
995     copy_block9(full, src, 16, stride, 9);\
996     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
997     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
998     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
999     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
1000 }\
1001 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1002     uint8_t full[16*9];\
1003     uint8_t halfH[72];\
1004     uint8_t halfV[64];\
1005     uint8_t halfHV[64];\
1006     copy_block9(full, src, 16, stride, 9);\
1007     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1008     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1009     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1010     OPNAME ## pixels8_l4_8(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1011 }\
1012 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1013     uint8_t full[16*9];\
1014     uint8_t halfH[72];\
1015     uint8_t halfHV[64];\
1016     copy_block9(full, src, 16, stride, 9);\
1017     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1018     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
1019     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1020     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1021 }\
1022 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1023     uint8_t full[16*9];\
1024     uint8_t halfH[72];\
1025     uint8_t halfV[64];\
1026     uint8_t halfHV[64];\
1027     copy_block9(full, src, 16, stride, 9);\
1028     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
1029     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1030     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1031     OPNAME ## pixels8_l4_8(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1032 }\
1033 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1034     uint8_t full[16*9];\
1035     uint8_t halfH[72];\
1036     uint8_t halfHV[64];\
1037     copy_block9(full, src, 16, stride, 9);\
1038     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1039     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1040     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1041     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1042 }\
1043 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1044     uint8_t halfH[72];\
1045     uint8_t halfHV[64];\
1046     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1047     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1048     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
1049 }\
1050 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1051     uint8_t halfH[72];\
1052     uint8_t halfHV[64];\
1053     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1054     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1055     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1056 }\
1057 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1058     uint8_t full[16*9];\
1059     uint8_t halfH[72];\
1060     uint8_t halfV[64];\
1061     uint8_t halfHV[64];\
1062     copy_block9(full, src, 16, stride, 9);\
1063     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1064     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1065     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1066     OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
1067 }\
1068 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1069     uint8_t full[16*9];\
1070     uint8_t halfH[72];\
1071     copy_block9(full, src, 16, stride, 9);\
1072     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1073     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
1074     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1075 }\
1076 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1077     uint8_t full[16*9];\
1078     uint8_t halfH[72];\
1079     uint8_t halfV[64];\
1080     uint8_t halfHV[64];\
1081     copy_block9(full, src, 16, stride, 9);\
1082     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1083     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1084     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1085     OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
1086 }\
1087 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1088     uint8_t full[16*9];\
1089     uint8_t halfH[72];\
1090     copy_block9(full, src, 16, stride, 9);\
1091     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1092     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1093     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1094 }\
1095 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1096     uint8_t halfH[72];\
1097     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1098     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1099 }\
1100 \
1101 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1102     uint8_t half[256];\
1103     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1104     OPNAME ## pixels16_l2_8(dst, src, half, stride, stride, 16, 16);\
1105 }\
1106 \
1107 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1108     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1109 }\
1110 \
1111 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1112     uint8_t half[256];\
1113     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1114     OPNAME ## pixels16_l2_8(dst, src+1, half, stride, stride, 16, 16);\
1115 }\
1116 \
1117 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1118     uint8_t full[24*17];\
1119     uint8_t half[256];\
1120     copy_block17(full, src, 24, stride, 17);\
1121     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1122     OPNAME ## pixels16_l2_8(dst, full, half, stride, 24, 16, 16);\
1123 }\
1124 \
1125 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1126     uint8_t full[24*17];\
1127     copy_block17(full, src, 24, stride, 17);\
1128     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
1129 }\
1130 \
1131 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1132     uint8_t full[24*17];\
1133     uint8_t half[256];\
1134     copy_block17(full, src, 24, stride, 17);\
1135     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1136     OPNAME ## pixels16_l2_8(dst, full+24, half, stride, 24, 16, 16);\
1137 }\
1138 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1139     uint8_t full[24*17];\
1140     uint8_t halfH[272];\
1141     uint8_t halfV[256];\
1142     uint8_t halfHV[256];\
1143     copy_block17(full, src, 24, stride, 17);\
1144     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1145     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1146     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1147     OPNAME ## pixels16_l4_8(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1148 }\
1149 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1150     uint8_t full[24*17];\
1151     uint8_t halfH[272];\
1152     uint8_t halfHV[256];\
1153     copy_block17(full, src, 24, stride, 17);\
1154     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1155     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1156     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1157     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1158 }\
1159 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1160     uint8_t full[24*17];\
1161     uint8_t halfH[272];\
1162     uint8_t halfV[256];\
1163     uint8_t halfHV[256];\
1164     copy_block17(full, src, 24, stride, 17);\
1165     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1166     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1167     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1168     OPNAME ## pixels16_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1169 }\
1170 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1171     uint8_t full[24*17];\
1172     uint8_t halfH[272];\
1173     uint8_t halfHV[256];\
1174     copy_block17(full, src, 24, stride, 17);\
1175     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1176     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1177     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1178     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1179 }\
1180 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1181     uint8_t full[24*17];\
1182     uint8_t halfH[272];\
1183     uint8_t halfV[256];\
1184     uint8_t halfHV[256];\
1185     copy_block17(full, src, 24, stride, 17);\
1186     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1187     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1188     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1189     OPNAME ## pixels16_l4_8(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1190 }\
1191 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1192     uint8_t full[24*17];\
1193     uint8_t halfH[272];\
1194     uint8_t halfHV[256];\
1195     copy_block17(full, src, 24, stride, 17);\
1196     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1197     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1198     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1199     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1200 }\
1201 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1202     uint8_t full[24*17];\
1203     uint8_t halfH[272];\
1204     uint8_t halfV[256];\
1205     uint8_t halfHV[256];\
1206     copy_block17(full, src, 24, stride, 17);\
1207     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
1208     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1209     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1210     OPNAME ## pixels16_l4_8(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1211 }\
1212 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1213     uint8_t full[24*17];\
1214     uint8_t halfH[272];\
1215     uint8_t halfHV[256];\
1216     copy_block17(full, src, 24, stride, 17);\
1217     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1218     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1219     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1220     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1221 }\
1222 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1223     uint8_t halfH[272];\
1224     uint8_t halfHV[256];\
1225     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1226     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1227     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1228 }\
1229 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1230     uint8_t halfH[272];\
1231     uint8_t halfHV[256];\
1232     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1233     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1234     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1235 }\
1236 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1237     uint8_t full[24*17];\
1238     uint8_t halfH[272];\
1239     uint8_t halfV[256];\
1240     uint8_t halfHV[256];\
1241     copy_block17(full, src, 24, stride, 17);\
1242     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1243     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1244     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1245     OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1246 }\
1247 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1248     uint8_t full[24*17];\
1249     uint8_t halfH[272];\
1250     copy_block17(full, src, 24, stride, 17);\
1251     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1252     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1253     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1254 }\
1255 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1256     uint8_t full[24*17];\
1257     uint8_t halfH[272];\
1258     uint8_t halfV[256];\
1259     uint8_t halfHV[256];\
1260     copy_block17(full, src, 24, stride, 17);\
1261     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1262     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1263     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1264     OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1265 }\
1266 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1267     uint8_t full[24*17];\
1268     uint8_t halfH[272];\
1269     copy_block17(full, src, 24, stride, 17);\
1270     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1271     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1272     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1273 }\
1274 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1275     uint8_t halfH[272];\
1276     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1277     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1278 }
1279
1280 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
1281 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
1282 #define op_put(a, b) a = cm[((b) + 16)>>5]
1283 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
1284
1285 QPEL_MC(0, put_       , _       , op_put)
1286 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
1287 QPEL_MC(0, avg_       , _       , op_avg)
1288 //QPEL_MC(1, avg_no_rnd , _       , op_avg)
1289 #undef op_avg
1290 #undef op_avg_no_rnd
1291 #undef op_put
1292 #undef op_put_no_rnd
1293
1294 #define put_qpel8_mc00_c  ff_put_pixels8x8_c
1295 #define avg_qpel8_mc00_c  ff_avg_pixels8x8_c
1296 #define put_qpel16_mc00_c ff_put_pixels16x16_c
1297 #define avg_qpel16_mc00_c ff_avg_pixels16x16_c
1298 #define put_no_rnd_qpel8_mc00_c  ff_put_pixels8x8_c
1299 #define put_no_rnd_qpel16_mc00_c ff_put_pixels16x16_8_c
1300
1301 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
1302     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1303     int i;
1304
1305     for(i=0; i<h; i++){
1306         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
1307         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
1308         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
1309         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
1310         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
1311         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
1312         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
1313         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
1314         dst+=dstStride;
1315         src+=srcStride;
1316     }
1317 }
1318
1319 #if CONFIG_RV40_DECODER
1320 static void put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1321     put_pixels16_xy2_8_c(dst, src, stride, 16);
1322 }
1323 static void avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1324     avg_pixels16_xy2_8_c(dst, src, stride, 16);
1325 }
1326 static void put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1327     put_pixels8_xy2_8_c(dst, src, stride, 8);
1328 }
1329 static void avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1330     avg_pixels8_xy2_8_c(dst, src, stride, 8);
1331 }
1332 #endif /* CONFIG_RV40_DECODER */
1333
1334 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
1335     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1336     int i;
1337
1338     for(i=0; i<w; i++){
1339         const int src_1= src[ -srcStride];
1340         const int src0 = src[0          ];
1341         const int src1 = src[  srcStride];
1342         const int src2 = src[2*srcStride];
1343         const int src3 = src[3*srcStride];
1344         const int src4 = src[4*srcStride];
1345         const int src5 = src[5*srcStride];
1346         const int src6 = src[6*srcStride];
1347         const int src7 = src[7*srcStride];
1348         const int src8 = src[8*srcStride];
1349         const int src9 = src[9*srcStride];
1350         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
1351         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
1352         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
1353         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
1354         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
1355         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
1356         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
1357         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
1358         src++;
1359         dst++;
1360     }
1361 }
1362
1363 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
1364     uint8_t half[64];
1365     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1366     put_pixels8_l2_8(dst, src, half, stride, stride, 8, 8);
1367 }
1368
1369 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
1370     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
1371 }
1372
1373 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
1374     uint8_t half[64];
1375     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1376     put_pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);
1377 }
1378
1379 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
1380     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
1381 }
1382
1383 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
1384     uint8_t halfH[88];
1385     uint8_t halfV[64];
1386     uint8_t halfHV[64];
1387     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1388     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
1389     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1390     put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1391 }
1392 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
1393     uint8_t halfH[88];
1394     uint8_t halfV[64];
1395     uint8_t halfHV[64];
1396     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1397     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
1398     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1399     put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1400 }
1401 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
1402     uint8_t halfH[88];
1403     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1404     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
1405 }
1406
1407 static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
1408     if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1409     int x;
1410     const int strength= ff_h263_loop_filter_strength[qscale];
1411
1412     for(x=0; x<8; x++){
1413         int d1, d2, ad1;
1414         int p0= src[x-2*stride];
1415         int p1= src[x-1*stride];
1416         int p2= src[x+0*stride];
1417         int p3= src[x+1*stride];
1418         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1419
1420         if     (d<-2*strength) d1= 0;
1421         else if(d<-  strength) d1=-2*strength - d;
1422         else if(d<   strength) d1= d;
1423         else if(d< 2*strength) d1= 2*strength - d;
1424         else                   d1= 0;
1425
1426         p1 += d1;
1427         p2 -= d1;
1428         if(p1&256) p1= ~(p1>>31);
1429         if(p2&256) p2= ~(p2>>31);
1430
1431         src[x-1*stride] = p1;
1432         src[x+0*stride] = p2;
1433
1434         ad1= FFABS(d1)>>1;
1435
1436         d2= av_clip((p0-p3)/4, -ad1, ad1);
1437
1438         src[x-2*stride] = p0 - d2;
1439         src[x+  stride] = p3 + d2;
1440     }
1441     }
1442 }
1443
1444 static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
1445     if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1446     int y;
1447     const int strength= ff_h263_loop_filter_strength[qscale];
1448
1449     for(y=0; y<8; y++){
1450         int d1, d2, ad1;
1451         int p0= src[y*stride-2];
1452         int p1= src[y*stride-1];
1453         int p2= src[y*stride+0];
1454         int p3= src[y*stride+1];
1455         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1456
1457         if     (d<-2*strength) d1= 0;
1458         else if(d<-  strength) d1=-2*strength - d;
1459         else if(d<   strength) d1= d;
1460         else if(d< 2*strength) d1= 2*strength - d;
1461         else                   d1= 0;
1462
1463         p1 += d1;
1464         p2 -= d1;
1465         if(p1&256) p1= ~(p1>>31);
1466         if(p2&256) p2= ~(p2>>31);
1467
1468         src[y*stride-1] = p1;
1469         src[y*stride+0] = p2;
1470
1471         ad1= FFABS(d1)>>1;
1472
1473         d2= av_clip((p0-p3)/4, -ad1, ad1);
1474
1475         src[y*stride-2] = p0 - d2;
1476         src[y*stride+1] = p3 + d2;
1477     }
1478     }
1479 }
1480
1481 static void h261_loop_filter_c(uint8_t *src, int stride){
1482     int x,y,xy,yz;
1483     int temp[64];
1484
1485     for(x=0; x<8; x++){
1486         temp[x      ] = 4*src[x           ];
1487         temp[x + 7*8] = 4*src[x + 7*stride];
1488     }
1489     for(y=1; y<7; y++){
1490         for(x=0; x<8; x++){
1491             xy = y * stride + x;
1492             yz = y * 8 + x;
1493             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
1494         }
1495     }
1496
1497     for(y=0; y<8; y++){
1498         src[  y*stride] = (temp[  y*8] + 2)>>2;
1499         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
1500         for(x=1; x<7; x++){
1501             xy = y * stride + x;
1502             yz = y * 8 + x;
1503             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
1504         }
1505     }
1506 }
1507
1508 static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1509 {
1510     int s, i;
1511
1512     s = 0;
1513     for(i=0;i<h;i++) {
1514         s += abs(pix1[0] - pix2[0]);
1515         s += abs(pix1[1] - pix2[1]);
1516         s += abs(pix1[2] - pix2[2]);
1517         s += abs(pix1[3] - pix2[3]);
1518         s += abs(pix1[4] - pix2[4]);
1519         s += abs(pix1[5] - pix2[5]);
1520         s += abs(pix1[6] - pix2[6]);
1521         s += abs(pix1[7] - pix2[7]);
1522         s += abs(pix1[8] - pix2[8]);
1523         s += abs(pix1[9] - pix2[9]);
1524         s += abs(pix1[10] - pix2[10]);
1525         s += abs(pix1[11] - pix2[11]);
1526         s += abs(pix1[12] - pix2[12]);
1527         s += abs(pix1[13] - pix2[13]);
1528         s += abs(pix1[14] - pix2[14]);
1529         s += abs(pix1[15] - pix2[15]);
1530         pix1 += line_size;
1531         pix2 += line_size;
1532     }
1533     return s;
1534 }
1535
1536 static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1537 {
1538     int s, i;
1539
1540     s = 0;
1541     for(i=0;i<h;i++) {
1542         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1543         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1544         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1545         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1546         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1547         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1548         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1549         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1550         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
1551         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
1552         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
1553         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
1554         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
1555         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
1556         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
1557         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
1558         pix1 += line_size;
1559         pix2 += line_size;
1560     }
1561     return s;
1562 }
1563
1564 static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1565 {
1566     int s, i;
1567     uint8_t *pix3 = pix2 + line_size;
1568
1569     s = 0;
1570     for(i=0;i<h;i++) {
1571         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1572         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1573         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1574         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1575         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1576         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1577         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1578         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1579         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
1580         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
1581         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
1582         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
1583         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
1584         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
1585         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
1586         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
1587         pix1 += line_size;
1588         pix2 += line_size;
1589         pix3 += line_size;
1590     }
1591     return s;
1592 }
1593
1594 static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1595 {
1596     int s, i;
1597     uint8_t *pix3 = pix2 + line_size;
1598
1599     s = 0;
1600     for(i=0;i<h;i++) {
1601         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1602         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1603         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1604         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1605         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1606         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1607         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1608         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1609         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
1610         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
1611         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
1612         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
1613         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
1614         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
1615         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
1616         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
1617         pix1 += line_size;
1618         pix2 += line_size;
1619         pix3 += line_size;
1620     }
1621     return s;
1622 }
1623
1624 static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1625 {
1626     int s, i;
1627
1628     s = 0;
1629     for(i=0;i<h;i++) {
1630         s += abs(pix1[0] - pix2[0]);
1631         s += abs(pix1[1] - pix2[1]);
1632         s += abs(pix1[2] - pix2[2]);
1633         s += abs(pix1[3] - pix2[3]);
1634         s += abs(pix1[4] - pix2[4]);
1635         s += abs(pix1[5] - pix2[5]);
1636         s += abs(pix1[6] - pix2[6]);
1637         s += abs(pix1[7] - pix2[7]);
1638         pix1 += line_size;
1639         pix2 += line_size;
1640     }
1641     return s;
1642 }
1643
1644 static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1645 {
1646     int s, i;
1647
1648     s = 0;
1649     for(i=0;i<h;i++) {
1650         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1651         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1652         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1653         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1654         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1655         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1656         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1657         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1658         pix1 += line_size;
1659         pix2 += line_size;
1660     }
1661     return s;
1662 }
1663
1664 static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1665 {
1666     int s, i;
1667     uint8_t *pix3 = pix2 + line_size;
1668
1669     s = 0;
1670     for(i=0;i<h;i++) {
1671         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1672         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1673         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1674         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1675         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1676         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1677         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1678         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1679         pix1 += line_size;
1680         pix2 += line_size;
1681         pix3 += line_size;
1682     }
1683     return s;
1684 }
1685
1686 static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1687 {
1688     int s, i;
1689     uint8_t *pix3 = pix2 + line_size;
1690
1691     s = 0;
1692     for(i=0;i<h;i++) {
1693         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1694         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1695         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1696         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1697         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1698         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1699         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1700         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1701         pix1 += line_size;
1702         pix2 += line_size;
1703         pix3 += line_size;
1704     }
1705     return s;
1706 }
1707
1708 static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1709     MpegEncContext *c = v;
1710     int score1=0;
1711     int score2=0;
1712     int x,y;
1713
1714     for(y=0; y<h; y++){
1715         for(x=0; x<16; x++){
1716             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
1717         }
1718         if(y+1<h){
1719             for(x=0; x<15; x++){
1720                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
1721                              - s1[x+1] + s1[x+1+stride])
1722                         -FFABS(  s2[x  ] - s2[x  +stride]
1723                              - s2[x+1] + s2[x+1+stride]);
1724             }
1725         }
1726         s1+= stride;
1727         s2+= stride;
1728     }
1729
1730     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1731     else  return score1 + FFABS(score2)*8;
1732 }
1733
1734 static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1735     MpegEncContext *c = v;
1736     int score1=0;
1737     int score2=0;
1738     int x,y;
1739
1740     for(y=0; y<h; y++){
1741         for(x=0; x<8; x++){
1742             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
1743         }
1744         if(y+1<h){
1745             for(x=0; x<7; x++){
1746                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
1747                              - s1[x+1] + s1[x+1+stride])
1748                         -FFABS(  s2[x  ] - s2[x  +stride]
1749                              - s2[x+1] + s2[x+1+stride]);
1750             }
1751         }
1752         s1+= stride;
1753         s2+= stride;
1754     }
1755
1756     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1757     else  return score1 + FFABS(score2)*8;
1758 }
1759
1760 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
1761     int i;
1762     unsigned int sum=0;
1763
1764     for(i=0; i<8*8; i++){
1765         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
1766         int w= weight[i];
1767         b>>= RECON_SHIFT;
1768         assert(-512<b && b<512);
1769
1770         sum += (w*b)*(w*b)>>4;
1771     }
1772     return sum>>2;
1773 }
1774
1775 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
1776     int i;
1777
1778     for(i=0; i<8*8; i++){
1779         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
1780     }
1781 }
1782
1783 /**
1784  * permutes an 8x8 block.
1785  * @param block the block which will be permuted according to the given permutation vector
1786  * @param permutation the permutation vector
1787  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
1788  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
1789  *                  (inverse) permutated to scantable order!
1790  */
1791 void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
1792 {
1793     int i;
1794     DCTELEM temp[64];
1795
1796     if(last<=0) return;
1797     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
1798
1799     for(i=0; i<=last; i++){
1800         const int j= scantable[i];
1801         temp[j]= block[j];
1802         block[j]=0;
1803     }
1804
1805     for(i=0; i<=last; i++){
1806         const int j= scantable[i];
1807         const int perm_j= permutation[j];
1808         block[perm_j]= temp[j];
1809     }
1810 }
1811
1812 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
1813     return 0;
1814 }
1815
1816 void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
1817     int i;
1818
1819     memset(cmp, 0, sizeof(void*)*6);
1820
1821     for(i=0; i<6; i++){
1822         switch(type&0xFF){
1823         case FF_CMP_SAD:
1824             cmp[i]= c->sad[i];
1825             break;
1826         case FF_CMP_SATD:
1827             cmp[i]= c->hadamard8_diff[i];
1828             break;
1829         case FF_CMP_SSE:
1830             cmp[i]= c->sse[i];
1831             break;
1832         case FF_CMP_DCT:
1833             cmp[i]= c->dct_sad[i];
1834             break;
1835         case FF_CMP_DCT264:
1836             cmp[i]= c->dct264_sad[i];
1837             break;
1838         case FF_CMP_DCTMAX:
1839             cmp[i]= c->dct_max[i];
1840             break;
1841         case FF_CMP_PSNR:
1842             cmp[i]= c->quant_psnr[i];
1843             break;
1844         case FF_CMP_BIT:
1845             cmp[i]= c->bit[i];
1846             break;
1847         case FF_CMP_RD:
1848             cmp[i]= c->rd[i];
1849             break;
1850         case FF_CMP_VSAD:
1851             cmp[i]= c->vsad[i];
1852             break;
1853         case FF_CMP_VSSE:
1854             cmp[i]= c->vsse[i];
1855             break;
1856         case FF_CMP_ZERO:
1857             cmp[i]= zero_cmp;
1858             break;
1859         case FF_CMP_NSSE:
1860             cmp[i]= c->nsse[i];
1861             break;
1862 #if CONFIG_DWT
1863         case FF_CMP_W53:
1864             cmp[i]= c->w53[i];
1865             break;
1866         case FF_CMP_W97:
1867             cmp[i]= c->w97[i];
1868             break;
1869 #endif
1870         default:
1871             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selection\n");
1872         }
1873     }
1874 }
1875
1876 static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
1877     long i;
1878     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1879         long a = *(long*)(src+i);
1880         long b = *(long*)(dst+i);
1881         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
1882     }
1883     for(; i<w; i++)
1884         dst[i+0] += src[i+0];
1885 }
1886
1887 static void add_bytes_l2_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
1888     long i;
1889     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1890         long a = *(long*)(src1+i);
1891         long b = *(long*)(src2+i);
1892         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
1893     }
1894     for(; i<w; i++)
1895         dst[i] = src1[i]+src2[i];
1896 }
1897
1898 static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
1899     long i;
1900 #if !HAVE_FAST_UNALIGNED
1901     if((long)src2 & (sizeof(long)-1)){
1902         for(i=0; i+7<w; i+=8){
1903             dst[i+0] = src1[i+0]-src2[i+0];
1904             dst[i+1] = src1[i+1]-src2[i+1];
1905             dst[i+2] = src1[i+2]-src2[i+2];
1906             dst[i+3] = src1[i+3]-src2[i+3];
1907             dst[i+4] = src1[i+4]-src2[i+4];
1908             dst[i+5] = src1[i+5]-src2[i+5];
1909             dst[i+6] = src1[i+6]-src2[i+6];
1910             dst[i+7] = src1[i+7]-src2[i+7];
1911         }
1912     }else
1913 #endif
1914     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1915         long a = *(long*)(src1+i);
1916         long b = *(long*)(src2+i);
1917         *(long*)(dst+i) = ((a|pb_80) - (b&pb_7f)) ^ ((a^b^pb_80)&pb_80);
1918     }
1919     for(; i<w; i++)
1920         dst[i+0] = src1[i+0]-src2[i+0];
1921 }
1922
1923 static void add_hfyu_median_prediction_c(uint8_t *dst, const uint8_t *src1, const uint8_t *diff, int w, int *left, int *left_top){
1924     int i;
1925     uint8_t l, lt;
1926
1927     l= *left;
1928     lt= *left_top;
1929
1930     for(i=0; i<w; i++){
1931         l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
1932         lt= src1[i];
1933         dst[i]= l;
1934     }
1935
1936     *left= l;
1937     *left_top= lt;
1938 }
1939
1940 static void sub_hfyu_median_prediction_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top){
1941     int i;
1942     uint8_t l, lt;
1943
1944     l= *left;
1945     lt= *left_top;
1946
1947     for(i=0; i<w; i++){
1948         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
1949         lt= src1[i];
1950         l= src2[i];
1951         dst[i]= l - pred;
1952     }
1953
1954     *left= l;
1955     *left_top= lt;
1956 }
1957
1958 static int add_hfyu_left_prediction_c(uint8_t *dst, const uint8_t *src, int w, int acc){
1959     int i;
1960
1961     for(i=0; i<w-1; i++){
1962         acc+= src[i];
1963         dst[i]= acc;
1964         i++;
1965         acc+= src[i];
1966         dst[i]= acc;
1967     }
1968
1969     for(; i<w; i++){
1970         acc+= src[i];
1971         dst[i]= acc;
1972     }
1973
1974     return acc;
1975 }
1976
1977 #if HAVE_BIGENDIAN
1978 #define B 3
1979 #define G 2
1980 #define R 1
1981 #define A 0
1982 #else
1983 #define B 0
1984 #define G 1
1985 #define R 2
1986 #define A 3
1987 #endif
1988 static void add_hfyu_left_prediction_bgr32_c(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha){
1989     int i;
1990     int r,g,b,a;
1991     r= *red;
1992     g= *green;
1993     b= *blue;
1994     a= *alpha;
1995
1996     for(i=0; i<w; i++){
1997         b+= src[4*i+B];
1998         g+= src[4*i+G];
1999         r+= src[4*i+R];
2000         a+= src[4*i+A];
2001
2002         dst[4*i+B]= b;
2003         dst[4*i+G]= g;
2004         dst[4*i+R]= r;
2005         dst[4*i+A]= a;
2006     }
2007
2008     *red= r;
2009     *green= g;
2010     *blue= b;
2011     *alpha= a;
2012 }
2013 #undef B
2014 #undef G
2015 #undef R
2016 #undef A
2017
2018 #define BUTTERFLY2(o1,o2,i1,i2) \
2019 o1= (i1)+(i2);\
2020 o2= (i1)-(i2);
2021
2022 #define BUTTERFLY1(x,y) \
2023 {\
2024     int a,b;\
2025     a= x;\
2026     b= y;\
2027     x= a+b;\
2028     y= a-b;\
2029 }
2030
2031 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
2032
2033 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
2034     int i;
2035     int temp[64];
2036     int sum=0;
2037
2038     assert(h==8);
2039
2040     for(i=0; i<8; i++){
2041         //FIXME try pointer walks
2042         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0]-dst[stride*i+0],src[stride*i+1]-dst[stride*i+1]);
2043         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2]-dst[stride*i+2],src[stride*i+3]-dst[stride*i+3]);
2044         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4]-dst[stride*i+4],src[stride*i+5]-dst[stride*i+5]);
2045         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6]-dst[stride*i+6],src[stride*i+7]-dst[stride*i+7]);
2046
2047         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
2048         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
2049         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
2050         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
2051
2052         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
2053         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
2054         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
2055         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
2056     }
2057
2058     for(i=0; i<8; i++){
2059         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
2060         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
2061         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
2062         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
2063
2064         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
2065         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
2066         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
2067         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
2068
2069         sum +=
2070              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
2071             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
2072             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
2073             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
2074     }
2075     return sum;
2076 }
2077
2078 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
2079     int i;
2080     int temp[64];
2081     int sum=0;
2082
2083     assert(h==8);
2084
2085     for(i=0; i<8; i++){
2086         //FIXME try pointer walks
2087         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
2088         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
2089         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
2090         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
2091
2092         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
2093         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
2094         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
2095         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
2096
2097         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
2098         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
2099         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
2100         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
2101     }
2102
2103     for(i=0; i<8; i++){
2104         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
2105         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
2106         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
2107         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
2108
2109         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
2110         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
2111         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
2112         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
2113
2114         sum +=
2115              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
2116             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
2117             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
2118             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
2119     }
2120
2121     sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
2122
2123     return sum;
2124 }
2125
2126 static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2127     MpegEncContext * const s= (MpegEncContext *)c;
2128     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2129
2130     assert(h==8);
2131
2132     s->dsp.diff_pixels(temp, src1, src2, stride);
2133     s->dsp.fdct(temp);
2134     return s->dsp.sum_abs_dctelem(temp);
2135 }
2136
2137 #if CONFIG_GPL
2138 #define DCT8_1D {\
2139     const int s07 = SRC(0) + SRC(7);\
2140     const int s16 = SRC(1) + SRC(6);\
2141     const int s25 = SRC(2) + SRC(5);\
2142     const int s34 = SRC(3) + SRC(4);\
2143     const int a0 = s07 + s34;\
2144     const int a1 = s16 + s25;\
2145     const int a2 = s07 - s34;\
2146     const int a3 = s16 - s25;\
2147     const int d07 = SRC(0) - SRC(7);\
2148     const int d16 = SRC(1) - SRC(6);\
2149     const int d25 = SRC(2) - SRC(5);\
2150     const int d34 = SRC(3) - SRC(4);\
2151     const int a4 = d16 + d25 + (d07 + (d07>>1));\
2152     const int a5 = d07 - d34 - (d25 + (d25>>1));\
2153     const int a6 = d07 + d34 - (d16 + (d16>>1));\
2154     const int a7 = d16 - d25 + (d34 + (d34>>1));\
2155     DST(0,  a0 + a1     ) ;\
2156     DST(1,  a4 + (a7>>2)) ;\
2157     DST(2,  a2 + (a3>>1)) ;\
2158     DST(3,  a5 + (a6>>2)) ;\
2159     DST(4,  a0 - a1     ) ;\
2160     DST(5,  a6 - (a5>>2)) ;\
2161     DST(6, (a2>>1) - a3 ) ;\
2162     DST(7, (a4>>2) - a7 ) ;\
2163 }
2164
2165 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2166     MpegEncContext * const s= (MpegEncContext *)c;
2167     DCTELEM dct[8][8];
2168     int i;
2169     int sum=0;
2170
2171     s->dsp.diff_pixels(dct[0], src1, src2, stride);
2172
2173 #define SRC(x) dct[i][x]
2174 #define DST(x,v) dct[i][x]= v
2175     for( i = 0; i < 8; i++ )
2176         DCT8_1D
2177 #undef SRC
2178 #undef DST
2179
2180 #define SRC(x) dct[x][i]
2181 #define DST(x,v) sum += FFABS(v)
2182     for( i = 0; i < 8; i++ )
2183         DCT8_1D
2184 #undef SRC
2185 #undef DST
2186     return sum;
2187 }
2188 #endif
2189
2190 static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2191     MpegEncContext * const s= (MpegEncContext *)c;
2192     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2193     int sum=0, i;
2194
2195     assert(h==8);
2196
2197     s->dsp.diff_pixels(temp, src1, src2, stride);
2198     s->dsp.fdct(temp);
2199
2200     for(i=0; i<64; i++)
2201         sum= FFMAX(sum, FFABS(temp[i]));
2202
2203     return sum;
2204 }
2205
2206 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2207     MpegEncContext * const s= (MpegEncContext *)c;
2208     LOCAL_ALIGNED_16(DCTELEM, temp, [64*2]);
2209     DCTELEM * const bak = temp+64;
2210     int sum=0, i;
2211
2212     assert(h==8);
2213     s->mb_intra=0;
2214
2215     s->dsp.diff_pixels(temp, src1, src2, stride);
2216
2217     memcpy(bak, temp, 64*sizeof(DCTELEM));
2218
2219     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2220     s->dct_unquantize_inter(s, temp, 0, s->qscale);
2221     ff_simple_idct_8(temp); //FIXME
2222
2223     for(i=0; i<64; i++)
2224         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
2225
2226     return sum;
2227 }
2228
2229 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2230     MpegEncContext * const s= (MpegEncContext *)c;
2231     const uint8_t *scantable= s->intra_scantable.permutated;
2232     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2233     LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
2234     LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
2235     int i, last, run, bits, level, distortion, start_i;
2236     const int esc_length= s->ac_esc_length;
2237     uint8_t * length;
2238     uint8_t * last_length;
2239
2240     assert(h==8);
2241
2242     copy_block8(lsrc1, src1, 8, stride, 8);
2243     copy_block8(lsrc2, src2, 8, stride, 8);
2244
2245     s->dsp.diff_pixels(temp, lsrc1, lsrc2, 8);
2246
2247     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2248
2249     bits=0;
2250
2251     if (s->mb_intra) {
2252         start_i = 1;
2253         length     = s->intra_ac_vlc_length;
2254         last_length= s->intra_ac_vlc_last_length;
2255         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2256     } else {
2257         start_i = 0;
2258         length     = s->inter_ac_vlc_length;
2259         last_length= s->inter_ac_vlc_last_length;
2260     }
2261
2262     if(last>=start_i){
2263         run=0;
2264         for(i=start_i; i<last; i++){
2265             int j= scantable[i];
2266             level= temp[j];
2267
2268             if(level){
2269                 level+=64;
2270                 if((level&(~127)) == 0){
2271                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
2272                 }else
2273                     bits+= esc_length;
2274                 run=0;
2275             }else
2276                 run++;
2277         }
2278         i= scantable[last];
2279
2280         level= temp[i] + 64;
2281
2282         assert(level - 64);
2283
2284         if((level&(~127)) == 0){
2285             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2286         }else
2287             bits+= esc_length;
2288
2289     }
2290
2291     if(last>=0){
2292         if(s->mb_intra)
2293             s->dct_unquantize_intra(s, temp, 0, s->qscale);
2294         else
2295             s->dct_unquantize_inter(s, temp, 0, s->qscale);
2296     }
2297
2298     s->dsp.idct_add(lsrc2, 8, temp);
2299
2300     distortion= s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);
2301
2302     return distortion + ((bits*s->qscale*s->qscale*109 + 64)>>7);
2303 }
2304
2305 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2306     MpegEncContext * const s= (MpegEncContext *)c;
2307     const uint8_t *scantable= s->intra_scantable.permutated;
2308     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2309     int i, last, run, bits, level, start_i;
2310     const int esc_length= s->ac_esc_length;
2311     uint8_t * length;
2312     uint8_t * last_length;
2313
2314     assert(h==8);
2315
2316     s->dsp.diff_pixels(temp, src1, src2, stride);
2317
2318     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2319
2320     bits=0;
2321
2322     if (s->mb_intra) {
2323         start_i = 1;
2324         length     = s->intra_ac_vlc_length;
2325         last_length= s->intra_ac_vlc_last_length;
2326         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2327     } else {
2328         start_i = 0;
2329         length     = s->inter_ac_vlc_length;
2330         last_length= s->inter_ac_vlc_last_length;
2331     }
2332
2333     if(last>=start_i){
2334         run=0;
2335         for(i=start_i; i<last; i++){
2336             int j= scantable[i];
2337             level= temp[j];
2338
2339             if(level){
2340                 level+=64;
2341                 if((level&(~127)) == 0){
2342                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
2343                 }else
2344                     bits+= esc_length;
2345                 run=0;
2346             }else
2347                 run++;
2348         }
2349         i= scantable[last];
2350
2351         level= temp[i] + 64;
2352
2353         assert(level - 64);
2354
2355         if((level&(~127)) == 0){
2356             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2357         }else
2358             bits+= esc_length;
2359     }
2360
2361     return bits;
2362 }
2363
2364 #define VSAD_INTRA(size) \
2365 static int vsad_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2366     int score=0;                                                                                            \
2367     int x,y;                                                                                                \
2368                                                                                                             \
2369     for(y=1; y<h; y++){                                                                                     \
2370         for(x=0; x<size; x+=4){                                                                             \
2371             score+= FFABS(s[x  ] - s[x  +stride]) + FFABS(s[x+1] - s[x+1+stride])                           \
2372                    +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]);                          \
2373         }                                                                                                   \
2374         s+= stride;                                                                                         \
2375     }                                                                                                       \
2376                                                                                                             \
2377     return score;                                                                                           \
2378 }
2379 VSAD_INTRA(8)
2380 VSAD_INTRA(16)
2381
2382 static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2383     int score=0;
2384     int x,y;
2385
2386     for(y=1; y<h; y++){
2387         for(x=0; x<16; x++){
2388             score+= FFABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2389         }
2390         s1+= stride;
2391         s2+= stride;
2392     }
2393
2394     return score;
2395 }
2396
2397 #define SQ(a) ((a)*(a))
2398 #define VSSE_INTRA(size) \
2399 static int vsse_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2400     int score=0;                                                                                            \
2401     int x,y;                                                                                                \
2402                                                                                                             \
2403     for(y=1; y<h; y++){                                                                                     \
2404         for(x=0; x<size; x+=4){                                                                               \
2405             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])                                 \
2406                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);                                \
2407         }                                                                                                   \
2408         s+= stride;                                                                                         \
2409     }                                                                                                       \
2410                                                                                                             \
2411     return score;                                                                                           \
2412 }
2413 VSSE_INTRA(8)
2414 VSSE_INTRA(16)
2415
2416 static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2417     int score=0;
2418     int x,y;
2419
2420     for(y=1; y<h; y++){
2421         for(x=0; x<16; x++){
2422             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2423         }
2424         s1+= stride;
2425         s2+= stride;
2426     }
2427
2428     return score;
2429 }
2430
2431 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
2432                                int size){
2433     int score=0;
2434     int i;
2435     for(i=0; i<size; i++)
2436         score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
2437     return score;
2438 }
2439
2440 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
2441 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
2442 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
2443 #if CONFIG_GPL
2444 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
2445 #endif
2446 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
2447 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
2448 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
2449 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
2450
2451 static void vector_fmul_c(float *dst, const float *src0, const float *src1, int len){
2452     int i;
2453     for(i=0; i<len; i++)
2454         dst[i] = src0[i] * src1[i];
2455 }
2456
2457 static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
2458     int i;
2459     src1 += len-1;
2460     for(i=0; i<len; i++)
2461         dst[i] = src0[i] * src1[-i];
2462 }
2463
2464 static void vector_fmul_add_c(float *dst, const float *src0, const float *src1, const float *src2, int len){
2465     int i;
2466     for(i=0; i<len; i++)
2467         dst[i] = src0[i] * src1[i] + src2[i];
2468 }
2469
2470 static void vector_fmul_window_c(float *dst, const float *src0,
2471                                  const float *src1, const float *win, int len)
2472 {
2473     int i,j;
2474     dst += len;
2475     win += len;
2476     src0+= len;
2477     for(i=-len, j=len-1; i<0; i++, j--) {
2478         float s0 = src0[i];
2479         float s1 = src1[j];
2480         float wi = win[i];
2481         float wj = win[j];
2482         dst[i] = s0*wj - s1*wi;
2483         dst[j] = s0*wi + s1*wj;
2484     }
2485 }
2486
2487 static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
2488                                  int len)
2489 {
2490     int i;
2491     for (i = 0; i < len; i++)
2492         dst[i] = src[i] * mul;
2493 }
2494
2495 static void vector_fmul_sv_scalar_2_c(float *dst, const float *src,
2496                                       const float **sv, float mul, int len)
2497 {
2498     int i;
2499     for (i = 0; i < len; i += 2, sv++) {
2500         dst[i  ] = src[i  ] * sv[0][0] * mul;
2501         dst[i+1] = src[i+1] * sv[0][1] * mul;
2502     }
2503 }
2504
2505 static void vector_fmul_sv_scalar_4_c(float *dst, const float *src,
2506                                       const float **sv, float mul, int len)
2507 {
2508     int i;
2509     for (i = 0; i < len; i += 4, sv++) {
2510         dst[i  ] = src[i  ] * sv[0][0] * mul;
2511         dst[i+1] = src[i+1] * sv[0][1] * mul;
2512         dst[i+2] = src[i+2] * sv[0][2] * mul;
2513         dst[i+3] = src[i+3] * sv[0][3] * mul;
2514     }
2515 }
2516
2517 static void sv_fmul_scalar_2_c(float *dst, const float **sv, float mul,
2518                                int len)
2519 {
2520     int i;
2521     for (i = 0; i < len; i += 2, sv++) {
2522         dst[i  ] = sv[0][0] * mul;
2523         dst[i+1] = sv[0][1] * mul;
2524     }
2525 }
2526
2527 static void sv_fmul_scalar_4_c(float *dst, const float **sv, float mul,
2528                                int len)
2529 {
2530     int i;
2531     for (i = 0; i < len; i += 4, sv++) {
2532         dst[i  ] = sv[0][0] * mul;
2533         dst[i+1] = sv[0][1] * mul;
2534         dst[i+2] = sv[0][2] * mul;
2535         dst[i+3] = sv[0][3] * mul;
2536     }
2537 }
2538
2539 static void butterflies_float_c(float *restrict v1, float *restrict v2,
2540                                 int len)
2541 {
2542     int i;
2543     for (i = 0; i < len; i++) {
2544         float t = v1[i] - v2[i];
2545         v1[i] += v2[i];
2546         v2[i] = t;
2547     }
2548 }
2549
2550 static float scalarproduct_float_c(const float *v1, const float *v2, int len)
2551 {
2552     float p = 0.0;
2553     int i;
2554
2555     for (i = 0; i < len; i++)
2556         p += v1[i] * v2[i];
2557
2558     return p;
2559 }
2560
2561 static inline uint32_t clipf_c_one(uint32_t a, uint32_t mini,
2562                    uint32_t maxi, uint32_t maxisign)
2563 {
2564
2565     if(a > mini) return mini;
2566     else if((a^(1U<<31)) > maxisign) return maxi;
2567     else return a;
2568 }
2569
2570 static void vector_clipf_c_opposite_sign(float *dst, const float *src, float *min, float *max, int len){
2571     int i;
2572     uint32_t mini = *(uint32_t*)min;
2573     uint32_t maxi = *(uint32_t*)max;
2574     uint32_t maxisign = maxi ^ (1U<<31);
2575     uint32_t *dsti = (uint32_t*)dst;
2576     const uint32_t *srci = (const uint32_t*)src;
2577     for(i=0; i<len; i+=8) {
2578         dsti[i + 0] = clipf_c_one(srci[i + 0], mini, maxi, maxisign);
2579         dsti[i + 1] = clipf_c_one(srci[i + 1], mini, maxi, maxisign);
2580         dsti[i + 2] = clipf_c_one(srci[i + 2], mini, maxi, maxisign);
2581         dsti[i + 3] = clipf_c_one(srci[i + 3], mini, maxi, maxisign);
2582         dsti[i + 4] = clipf_c_one(srci[i + 4], mini, maxi, maxisign);
2583         dsti[i + 5] = clipf_c_one(srci[i + 5], mini, maxi, maxisign);
2584         dsti[i + 6] = clipf_c_one(srci[i + 6], mini, maxi, maxisign);
2585         dsti[i + 7] = clipf_c_one(srci[i + 7], mini, maxi, maxisign);
2586     }
2587 }
2588 static void vector_clipf_c(float *dst, const float *src, float min, float max, int len){
2589     int i;
2590     if(min < 0 && max > 0) {
2591         vector_clipf_c_opposite_sign(dst, src, &min, &max, len);
2592     } else {
2593         for(i=0; i < len; i+=8) {
2594             dst[i    ] = av_clipf(src[i    ], min, max);
2595             dst[i + 1] = av_clipf(src[i + 1], min, max);
2596             dst[i + 2] = av_clipf(src[i + 2], min, max);
2597             dst[i + 3] = av_clipf(src[i + 3], min, max);
2598             dst[i + 4] = av_clipf(src[i + 4], min, max);
2599             dst[i + 5] = av_clipf(src[i + 5], min, max);
2600             dst[i + 6] = av_clipf(src[i + 6], min, max);
2601             dst[i + 7] = av_clipf(src[i + 7], min, max);
2602         }
2603     }
2604 }
2605
2606 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order, int shift)
2607 {
2608     int res = 0;
2609
2610     while (order--)
2611         res += (*v1++ * *v2++) >> shift;
2612
2613     return res;
2614 }
2615
2616 static int32_t scalarproduct_and_madd_int16_c(int16_t *v1, const int16_t *v2, const int16_t *v3, int order, int mul)
2617 {
2618     int res = 0;
2619     while (order--) {
2620         res   += *v1 * *v2++;
2621         *v1++ += mul * *v3++;
2622     }
2623     return res;
2624 }
2625
2626 static void apply_window_int16_c(int16_t *output, const int16_t *input,
2627                                  const int16_t *window, unsigned int len)
2628 {
2629     int i;
2630     int len2 = len >> 1;
2631
2632     for (i = 0; i < len2; i++) {
2633         int16_t w       = window[i];
2634         output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
2635         output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
2636     }
2637 }
2638
2639 static void vector_clip_int32_c(int32_t *dst, const int32_t *src, int32_t min,
2640                                 int32_t max, unsigned int len)
2641 {
2642     do {
2643         *dst++ = av_clip(*src++, min, max);
2644         *dst++ = av_clip(*src++, min, max);
2645         *dst++ = av_clip(*src++, min, max);
2646         *dst++ = av_clip(*src++, min, max);
2647         *dst++ = av_clip(*src++, min, max);
2648         *dst++ = av_clip(*src++, min, max);
2649         *dst++ = av_clip(*src++, min, max);
2650         *dst++ = av_clip(*src++, min, max);
2651         len -= 8;
2652     } while (len > 0);
2653 }
2654
2655 #define W0 2048
2656 #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
2657 #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
2658 #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
2659 #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
2660 #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
2661 #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
2662 #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
2663
2664 static void wmv2_idct_row(short * b)
2665 {
2666     int s1,s2;
2667     int a0,a1,a2,a3,a4,a5,a6,a7;
2668     /*step 1*/
2669     a1 = W1*b[1]+W7*b[7];
2670     a7 = W7*b[1]-W1*b[7];
2671     a5 = W5*b[5]+W3*b[3];
2672     a3 = W3*b[5]-W5*b[3];
2673     a2 = W2*b[2]+W6*b[6];
2674     a6 = W6*b[2]-W2*b[6];
2675     a0 = W0*b[0]+W0*b[4];
2676     a4 = W0*b[0]-W0*b[4];
2677     /*step 2*/
2678     s1 = (181*(a1-a5+a7-a3)+128)>>8;//1,3,5,7,
2679     s2 = (181*(a1-a5-a7+a3)+128)>>8;
2680     /*step 3*/
2681     b[0] = (a0+a2+a1+a5 + (1<<7))>>8;
2682     b[1] = (a4+a6 +s1   + (1<<7))>>8;
2683     b[2] = (a4-a6 +s2   + (1<<7))>>8;
2684     b[3] = (a0-a2+a7+a3 + (1<<7))>>8;
2685     b[4] = (a0-a2-a7-a3 + (1<<7))>>8;
2686     b[5] = (a4-a6 -s2   + (1<<7))>>8;
2687     b[6] = (a4+a6 -s1   + (1<<7))>>8;
2688     b[7] = (a0+a2-a1-a5 + (1<<7))>>8;
2689 }
2690 static void wmv2_idct_col(short * b)
2691 {
2692     int s1,s2;
2693     int a0,a1,a2,a3,a4,a5,a6,a7;
2694     /*step 1, with extended precision*/
2695     a1 = (W1*b[8*1]+W7*b[8*7] + 4)>>3;
2696     a7 = (W7*b[8*1]-W1*b[8*7] + 4)>>3;
2697     a5 = (W5*b[8*5]+W3*b[8*3] + 4)>>3;
2698     a3 = (W3*b[8*5]-W5*b[8*3] + 4)>>3;
2699     a2 = (W2*b[8*2]+W6*b[8*6] + 4)>>3;
2700     a6 = (W6*b[8*2]-W2*b[8*6] + 4)>>3;
2701     a0 = (W0*b[8*0]+W0*b[8*4]    )>>3;
2702     a4 = (W0*b[8*0]-W0*b[8*4]    )>>3;
2703     /*step 2*/
2704     s1 = (181*(a1-a5+a7-a3)+128)>>8;
2705     s2 = (181*(a1-a5-a7+a3)+128)>>8;
2706     /*step 3*/
2707     b[8*0] = (a0+a2+a1+a5 + (1<<13))>>14;
2708     b[8*1] = (a4+a6 +s1   + (1<<13))>>14;
2709     b[8*2] = (a4-a6 +s2   + (1<<13))>>14;
2710     b[8*3] = (a0-a2+a7+a3 + (1<<13))>>14;
2711
2712     b[8*4] = (a0-a2-a7-a3 + (1<<13))>>14;
2713     b[8*5] = (a4-a6 -s2   + (1<<13))>>14;
2714     b[8*6] = (a4+a6 -s1   + (1<<13))>>14;
2715     b[8*7] = (a0+a2-a1-a5 + (1<<13))>>14;
2716 }
2717 void ff_wmv2_idct_c(short * block){
2718     int i;
2719
2720     for(i=0;i<64;i+=8){
2721         wmv2_idct_row(block+i);
2722     }
2723     for(i=0;i<8;i++){
2724         wmv2_idct_col(block+i);
2725     }
2726 }
2727 /* XXX: those functions should be suppressed ASAP when all IDCTs are
2728  converted */
2729 static void ff_wmv2_idct_put_c(uint8_t *dest, int line_size, DCTELEM *block)
2730 {
2731     ff_wmv2_idct_c(block);
2732     ff_put_pixels_clamped_c(block, dest, line_size);
2733 }
2734 static void ff_wmv2_idct_add_c(uint8_t *dest, int line_size, DCTELEM *block)
2735 {
2736     ff_wmv2_idct_c(block);
2737     ff_add_pixels_clamped_c(block, dest, line_size);
2738 }
2739 static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
2740 {
2741     j_rev_dct (block);
2742     ff_put_pixels_clamped_c(block, dest, line_size);
2743 }
2744 static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
2745 {
2746     j_rev_dct (block);
2747     ff_add_pixels_clamped_c(block, dest, line_size);
2748 }
2749
2750 static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
2751 {
2752     j_rev_dct4 (block);
2753     put_pixels_clamped4_c(block, dest, line_size);
2754 }
2755 static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
2756 {
2757     j_rev_dct4 (block);
2758     add_pixels_clamped4_c(block, dest, line_size);
2759 }
2760
2761 static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
2762 {
2763     j_rev_dct2 (block);
2764     put_pixels_clamped2_c(block, dest, line_size);
2765 }
2766 static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
2767 {
2768     j_rev_dct2 (block);
2769     add_pixels_clamped2_c(block, dest, line_size);
2770 }
2771
2772 static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
2773 {
2774     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2775
2776     dest[0] = cm[(block[0] + 4)>>3];
2777 }
2778 static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
2779 {
2780     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2781
2782     dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
2783 }
2784
2785 static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
2786
2787 /* init static data */
2788 av_cold void dsputil_static_init(void)
2789 {
2790     int i;
2791
2792     for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
2793     for(i=0;i<MAX_NEG_CROP;i++) {
2794         ff_cropTbl[i] = 0;
2795         ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
2796     }
2797
2798     for(i=0;i<512;i++) {
2799         ff_squareTbl[i] = (i - 256) * (i - 256);
2800     }
2801
2802     for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
2803 }
2804
2805 int ff_check_alignment(void){
2806     static int did_fail=0;
2807     LOCAL_ALIGNED_16(int, aligned, [4]);
2808
2809     if((intptr_t)aligned & 15){
2810         if(!did_fail){
2811 #if HAVE_MMX || HAVE_ALTIVEC
2812             av_log(NULL, AV_LOG_ERROR,
2813                 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
2814                 "and may be very slow or crash. This is not a bug in libavcodec,\n"
2815                 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
2816                 "Do not report crashes to Libav developers.\n");
2817 #endif
2818             did_fail=1;
2819         }
2820         return -1;
2821     }
2822     return 0;
2823 }
2824
2825 av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
2826 {
2827     int i;
2828
2829     ff_check_alignment();
2830
2831 #if CONFIG_ENCODERS
2832     if (avctx->bits_per_raw_sample == 10) {
2833         c->fdct    = ff_jpeg_fdct_islow_10;
2834         c->fdct248 = ff_fdct248_islow_10;
2835     } else {
2836         if(avctx->dct_algo==FF_DCT_FASTINT) {
2837             c->fdct    = fdct_ifast;
2838             c->fdct248 = fdct_ifast248;
2839         }
2840         else if(avctx->dct_algo==FF_DCT_FAAN) {
2841             c->fdct    = ff_faandct;
2842             c->fdct248 = ff_faandct248;
2843         }
2844         else {
2845             c->fdct    = ff_jpeg_fdct_islow_8; //slow/accurate/default
2846             c->fdct248 = ff_fdct248_islow_8;
2847         }
2848     }
2849 #endif //CONFIG_ENCODERS
2850
2851     if(avctx->lowres==1){
2852         c->idct_put= ff_jref_idct4_put;
2853         c->idct_add= ff_jref_idct4_add;
2854         c->idct    = j_rev_dct4;
2855         c->idct_permutation_type= FF_NO_IDCT_PERM;
2856     }else if(avctx->lowres==2){
2857         c->idct_put= ff_jref_idct2_put;
2858         c->idct_add= ff_jref_idct2_add;
2859         c->idct    = j_rev_dct2;
2860         c->idct_permutation_type= FF_NO_IDCT_PERM;
2861     }else if(avctx->lowres==3){
2862         c->idct_put= ff_jref_idct1_put;
2863         c->idct_add= ff_jref_idct1_add;
2864         c->idct    = j_rev_dct1;
2865         c->idct_permutation_type= FF_NO_IDCT_PERM;
2866     }else{
2867         if (avctx->bits_per_raw_sample == 10) {
2868             c->idct_put              = ff_simple_idct_put_10;
2869             c->idct_add              = ff_simple_idct_add_10;
2870             c->idct                  = ff_simple_idct_10;
2871             c->idct_permutation_type = FF_NO_IDCT_PERM;
2872         } else {
2873         if(avctx->idct_algo==FF_IDCT_INT){
2874             c->idct_put= ff_jref_idct_put;
2875             c->idct_add= ff_jref_idct_add;
2876             c->idct    = j_rev_dct;
2877             c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
2878         }else if((CONFIG_VP3_DECODER || CONFIG_VP5_DECODER || CONFIG_VP6_DECODER ) &&
2879                 avctx->idct_algo==FF_IDCT_VP3){
2880             c->idct_put= ff_vp3_idct_put_c;
2881             c->idct_add= ff_vp3_idct_add_c;
2882             c->idct    = ff_vp3_idct_c;
2883             c->idct_permutation_type= FF_NO_IDCT_PERM;
2884         }else if(avctx->idct_algo==FF_IDCT_WMV2){
2885             c->idct_put= ff_wmv2_idct_put_c;
2886             c->idct_add= ff_wmv2_idct_add_c;
2887             c->idct    = ff_wmv2_idct_c;
2888             c->idct_permutation_type= FF_NO_IDCT_PERM;
2889         }else if(avctx->idct_algo==FF_IDCT_FAAN){
2890             c->idct_put= ff_faanidct_put;
2891             c->idct_add= ff_faanidct_add;
2892             c->idct    = ff_faanidct;
2893             c->idct_permutation_type= FF_NO_IDCT_PERM;
2894         }else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) {
2895             c->idct_put= ff_ea_idct_put_c;
2896             c->idct_permutation_type= FF_NO_IDCT_PERM;
2897         }else if(CONFIG_BINK_DECODER && avctx->idct_algo==FF_IDCT_BINK) {
2898             c->idct     = ff_bink_idct_c;
2899             c->idct_add = ff_bink_idct_add_c;
2900             c->idct_put = ff_bink_idct_put_c;
2901             c->idct_permutation_type = FF_NO_IDCT_PERM;
2902         }else{ //accurate/default
2903             c->idct_put = ff_simple_idct_put_8;
2904             c->idct_add = ff_simple_idct_add_8;
2905             c->idct     = ff_simple_idct_8;
2906             c->idct_permutation_type= FF_NO_IDCT_PERM;
2907         }
2908         }
2909     }
2910
2911     c->diff_pixels = diff_pixels_c;
2912     c->put_pixels_clamped = ff_put_pixels_clamped_c;
2913     c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_c;
2914     c->put_pixels_nonclamped = put_pixels_nonclamped_c;
2915     c->add_pixels_clamped = ff_add_pixels_clamped_c;
2916     c->sum_abs_dctelem = sum_abs_dctelem_c;
2917     c->gmc1 = gmc1_c;
2918     c->gmc = ff_gmc_c;
2919     c->pix_sum = pix_sum_c;
2920     c->pix_norm1 = pix_norm1_c;
2921
2922     c->fill_block_tab[0] = fill_block16_c;
2923     c->fill_block_tab[1] = fill_block8_c;
2924     c->scale_block = scale_block_c;
2925
2926     /* TODO [0] 16  [1] 8 */
2927     c->pix_abs[0][0] = pix_abs16_c;
2928     c->pix_abs[0][1] = pix_abs16_x2_c;
2929     c->pix_abs[0][2] = pix_abs16_y2_c;
2930     c->pix_abs[0][3] = pix_abs16_xy2_c;
2931     c->pix_abs[1][0] = pix_abs8_c;
2932     c->pix_abs[1][1] = pix_abs8_x2_c;
2933     c->pix_abs[1][2] = pix_abs8_y2_c;
2934     c->pix_abs[1][3] = pix_abs8_xy2_c;
2935
2936     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
2937     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
2938     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
2939     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
2940     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
2941     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
2942     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
2943     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
2944     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
2945
2946     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
2947     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
2948     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
2949     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
2950     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
2951     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
2952     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
2953     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
2954     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
2955
2956 #define dspfunc(PFX, IDX, NUM) \
2957     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
2958     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
2959     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
2960     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
2961     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
2962     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
2963     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
2964     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
2965     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
2966     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
2967     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
2968     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
2969     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
2970     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
2971     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
2972     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
2973
2974     dspfunc(put_qpel, 0, 16);
2975     dspfunc(put_no_rnd_qpel, 0, 16);
2976
2977     dspfunc(avg_qpel, 0, 16);
2978     /* dspfunc(avg_no_rnd_qpel, 0, 16); */
2979
2980     dspfunc(put_qpel, 1, 8);
2981     dspfunc(put_no_rnd_qpel, 1, 8);
2982
2983     dspfunc(avg_qpel, 1, 8);
2984     /* dspfunc(avg_no_rnd_qpel, 1, 8); */
2985
2986 #undef dspfunc
2987
2988 #if CONFIG_MLP_DECODER || CONFIG_TRUEHD_DECODER
2989     ff_mlp_init(c, avctx);
2990 #endif
2991 #if CONFIG_WMV2_DECODER || CONFIG_VC1_DECODER
2992     ff_intrax8dsp_init(c,avctx);
2993 #endif
2994 #if CONFIG_RV30_DECODER
2995     ff_rv30dsp_init(c,avctx);
2996 #endif
2997 #if CONFIG_RV40_DECODER
2998     ff_rv40dsp_init(c,avctx);
2999     c->put_rv40_qpel_pixels_tab[0][15] = put_rv40_qpel16_mc33_c;
3000     c->avg_rv40_qpel_pixels_tab[0][15] = avg_rv40_qpel16_mc33_c;
3001     c->put_rv40_qpel_pixels_tab[1][15] = put_rv40_qpel8_mc33_c;
3002     c->avg_rv40_qpel_pixels_tab[1][15] = avg_rv40_qpel8_mc33_c;
3003 #endif
3004
3005     c->put_mspel_pixels_tab[0]= ff_put_pixels8x8_c;
3006     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
3007     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
3008     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
3009     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
3010     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
3011     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
3012     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
3013
3014 #define SET_CMP_FUNC(name) \
3015     c->name[0]= name ## 16_c;\
3016     c->name[1]= name ## 8x8_c;
3017
3018     SET_CMP_FUNC(hadamard8_diff)
3019     c->hadamard8_diff[4]= hadamard8_intra16_c;
3020     c->hadamard8_diff[5]= hadamard8_intra8x8_c;
3021     SET_CMP_FUNC(dct_sad)
3022     SET_CMP_FUNC(dct_max)
3023 #if CONFIG_GPL
3024     SET_CMP_FUNC(dct264_sad)
3025 #endif
3026     c->sad[0]= pix_abs16_c;
3027     c->sad[1]= pix_abs8_c;
3028     c->sse[0]= sse16_c;
3029     c->sse[1]= sse8_c;
3030     c->sse[2]= sse4_c;
3031     SET_CMP_FUNC(quant_psnr)
3032     SET_CMP_FUNC(rd)
3033     SET_CMP_FUNC(bit)
3034     c->vsad[0]= vsad16_c;
3035     c->vsad[4]= vsad_intra16_c;
3036     c->vsad[5]= vsad_intra8_c;
3037     c->vsse[0]= vsse16_c;
3038     c->vsse[4]= vsse_intra16_c;
3039     c->vsse[5]= vsse_intra8_c;
3040     c->nsse[0]= nsse16_c;
3041     c->nsse[1]= nsse8_c;
3042 #if CONFIG_DWT
3043     ff_dsputil_init_dwt(c);
3044 #endif
3045
3046     c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
3047
3048     c->add_bytes= add_bytes_c;
3049     c->add_bytes_l2= add_bytes_l2_c;
3050     c->diff_bytes= diff_bytes_c;
3051     c->add_hfyu_median_prediction= add_hfyu_median_prediction_c;
3052     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
3053     c->add_hfyu_left_prediction  = add_hfyu_left_prediction_c;
3054     c->add_hfyu_left_prediction_bgr32 = add_hfyu_left_prediction_bgr32_c;
3055     c->bswap_buf= bswap_buf;
3056     c->bswap16_buf = bswap16_buf;
3057 #if CONFIG_PNG_DECODER
3058     c->add_png_paeth_prediction= ff_add_png_paeth_prediction;
3059 #endif
3060
3061     if (CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
3062         c->h263_h_loop_filter= h263_h_loop_filter_c;
3063         c->h263_v_loop_filter= h263_v_loop_filter_c;
3064     }
3065
3066     if (CONFIG_VP3_DECODER) {
3067         c->vp3_h_loop_filter= ff_vp3_h_loop_filter_c;
3068         c->vp3_v_loop_filter= ff_vp3_v_loop_filter_c;
3069         c->vp3_idct_dc_add= ff_vp3_idct_dc_add_c;
3070     }
3071
3072     c->h261_loop_filter= h261_loop_filter_c;
3073
3074     c->try_8x8basis= try_8x8basis_c;
3075     c->add_8x8basis= add_8x8basis_c;
3076
3077 #if CONFIG_VORBIS_DECODER
3078     c->vorbis_inverse_coupling = vorbis_inverse_coupling;
3079 #endif
3080 #if CONFIG_AC3_DECODER
3081     c->ac3_downmix = ff_ac3_downmix_c;
3082 #endif
3083     c->vector_fmul = vector_fmul_c;
3084     c->vector_fmul_reverse = vector_fmul_reverse_c;
3085     c->vector_fmul_add = vector_fmul_add_c;
3086     c->vector_fmul_window = vector_fmul_window_c;
3087     c->vector_clipf = vector_clipf_c;
3088     c->scalarproduct_int16 = scalarproduct_int16_c;
3089     c->scalarproduct_and_madd_int16 = scalarproduct_and_madd_int16_c;
3090     c->apply_window_int16 = apply_window_int16_c;
3091     c->vector_clip_int32 = vector_clip_int32_c;
3092     c->scalarproduct_float = scalarproduct_float_c;
3093     c->butterflies_float = butterflies_float_c;
3094     c->vector_fmul_scalar = vector_fmul_scalar_c;
3095
3096     c->vector_fmul_sv_scalar[0] = vector_fmul_sv_scalar_2_c;
3097     c->vector_fmul_sv_scalar[1] = vector_fmul_sv_scalar_4_c;
3098
3099     c->sv_fmul_scalar[0] = sv_fmul_scalar_2_c;
3100     c->sv_fmul_scalar[1] = sv_fmul_scalar_4_c;
3101
3102     c->shrink[0]= av_image_copy_plane;
3103     c->shrink[1]= ff_shrink22;
3104     c->shrink[2]= ff_shrink44;
3105     c->shrink[3]= ff_shrink88;
3106
3107     c->prefetch= just_return;
3108
3109     memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));
3110     memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));
3111
3112 #undef FUNC
3113 #undef FUNCC
3114 #define FUNC(f, depth) f ## _ ## depth
3115 #define FUNCC(f, depth) f ## _ ## depth ## _c
3116
3117 #define dspfunc1(PFX, IDX, NUM, depth)\
3118     c->PFX ## _pixels_tab[IDX][0] = FUNCC(PFX ## _pixels ## NUM        , depth);\
3119     c->PFX ## _pixels_tab[IDX][1] = FUNCC(PFX ## _pixels ## NUM ## _x2 , depth);\
3120     c->PFX ## _pixels_tab[IDX][2] = FUNCC(PFX ## _pixels ## NUM ## _y2 , depth);\
3121     c->PFX ## _pixels_tab[IDX][3] = FUNCC(PFX ## _pixels ## NUM ## _xy2, depth)
3122
3123 #define dspfunc2(PFX, IDX, NUM, depth)\
3124     c->PFX ## _pixels_tab[IDX][ 0] = FUNCC(PFX ## NUM ## _mc00, depth);\
3125     c->PFX ## _pixels_tab[IDX][ 1] = FUNCC(PFX ## NUM ## _mc10, depth);\
3126     c->PFX ## _pixels_tab[IDX][ 2] = FUNCC(PFX ## NUM ## _mc20, depth);\
3127     c->PFX ## _pixels_tab[IDX][ 3] = FUNCC(PFX ## NUM ## _mc30, depth);\
3128     c->PFX ## _pixels_tab[IDX][ 4] = FUNCC(PFX ## NUM ## _mc01, depth);\
3129     c->PFX ## _pixels_tab[IDX][ 5] = FUNCC(PFX ## NUM ## _mc11, depth);\
3130     c->PFX ## _pixels_tab[IDX][ 6] = FUNCC(PFX ## NUM ## _mc21, depth);\
3131     c->PFX ## _pixels_tab[IDX][ 7] = FUNCC(PFX ## NUM ## _mc31, depth);\
3132     c->PFX ## _pixels_tab[IDX][ 8] = FUNCC(PFX ## NUM ## _mc02, depth);\
3133     c->PFX ## _pixels_tab[IDX][ 9] = FUNCC(PFX ## NUM ## _mc12, depth);\
3134     c->PFX ## _pixels_tab[IDX][10] = FUNCC(PFX ## NUM ## _mc22, depth);\
3135     c->PFX ## _pixels_tab[IDX][11] = FUNCC(PFX ## NUM ## _mc32, depth);\
3136     c->PFX ## _pixels_tab[IDX][12] = FUNCC(PFX ## NUM ## _mc03, depth);\
3137     c->PFX ## _pixels_tab[IDX][13] = FUNCC(PFX ## NUM ## _mc13, depth);\
3138     c->PFX ## _pixels_tab[IDX][14] = FUNCC(PFX ## NUM ## _mc23, depth);\
3139     c->PFX ## _pixels_tab[IDX][15] = FUNCC(PFX ## NUM ## _mc33, depth)
3140
3141
3142 #define BIT_DEPTH_FUNCS(depth, dct)\
3143     c->get_pixels                    = FUNCC(get_pixels   ## dct   , depth);\
3144     c->draw_edges                    = FUNCC(draw_edges            , depth);\
3145     c->emulated_edge_mc              = FUNC (ff_emulated_edge_mc   , depth);\
3146     c->clear_block                   = FUNCC(clear_block  ## dct   , depth);\
3147     c->clear_blocks                  = FUNCC(clear_blocks ## dct   , depth);\
3148     c->add_pixels8                   = FUNCC(add_pixels8  ## dct   , depth);\
3149     c->add_pixels4                   = FUNCC(add_pixels4  ## dct   , depth);\
3150     c->put_no_rnd_pixels_l2[0]       = FUNCC(put_no_rnd_pixels16_l2, depth);\
3151     c->put_no_rnd_pixels_l2[1]       = FUNCC(put_no_rnd_pixels8_l2 , depth);\
3152 \
3153     c->put_h264_chroma_pixels_tab[0] = FUNCC(put_h264_chroma_mc8   , depth);\
3154     c->put_h264_chroma_pixels_tab[1] = FUNCC(put_h264_chroma_mc4   , depth);\
3155     c->put_h264_chroma_pixels_tab[2] = FUNCC(put_h264_chroma_mc2   , depth);\
3156     c->avg_h264_chroma_pixels_tab[0] = FUNCC(avg_h264_chroma_mc8   , depth);\
3157     c->avg_h264_chroma_pixels_tab[1] = FUNCC(avg_h264_chroma_mc4   , depth);\
3158     c->avg_h264_chroma_pixels_tab[2] = FUNCC(avg_h264_chroma_mc2   , depth);\
3159 \
3160     dspfunc1(put       , 0, 16, depth);\
3161     dspfunc1(put       , 1,  8, depth);\
3162     dspfunc1(put       , 2,  4, depth);\
3163     dspfunc1(put       , 3,  2, depth);\
3164     dspfunc1(put_no_rnd, 0, 16, depth);\
3165     dspfunc1(put_no_rnd, 1,  8, depth);\
3166     dspfunc1(avg       , 0, 16, depth);\
3167     dspfunc1(avg       , 1,  8, depth);\
3168     dspfunc1(avg       , 2,  4, depth);\
3169     dspfunc1(avg       , 3,  2, depth);\
3170     dspfunc1(avg_no_rnd, 0, 16, depth);\
3171     dspfunc1(avg_no_rnd, 1,  8, depth);\
3172 \
3173     dspfunc2(put_h264_qpel, 0, 16, depth);\
3174     dspfunc2(put_h264_qpel, 1,  8, depth);\
3175     dspfunc2(put_h264_qpel, 2,  4, depth);\
3176     dspfunc2(put_h264_qpel, 3,  2, depth);\
3177     dspfunc2(avg_h264_qpel, 0, 16, depth);\
3178     dspfunc2(avg_h264_qpel, 1,  8, depth);\
3179     dspfunc2(avg_h264_qpel, 2,  4, depth);
3180
3181     switch (avctx->bits_per_raw_sample) {
3182     case 9:
3183         if (c->dct_bits == 32) {
3184             BIT_DEPTH_FUNCS(9, _32);
3185         } else {
3186             BIT_DEPTH_FUNCS(9, _16);
3187         }
3188         break;
3189     case 10:
3190         if (c->dct_bits == 32) {
3191             BIT_DEPTH_FUNCS(10, _32);
3192         } else {
3193             BIT_DEPTH_FUNCS(10, _16);
3194         }
3195         break;
3196     default:
3197         av_log(avctx, AV_LOG_DEBUG, "Unsupported bit depth: %d\n", avctx->bits_per_raw_sample);
3198     case 8:
3199         BIT_DEPTH_FUNCS(8, _16);
3200         break;
3201     }
3202
3203
3204     if (HAVE_MMX)        dsputil_init_mmx   (c, avctx);
3205     if (ARCH_ARM)        dsputil_init_arm   (c, avctx);
3206     if (CONFIG_MLIB)     dsputil_init_mlib  (c, avctx);
3207     if (HAVE_VIS)        dsputil_init_vis   (c, avctx);
3208     if (ARCH_ALPHA)      dsputil_init_alpha (c, avctx);
3209     if (ARCH_PPC)        dsputil_init_ppc   (c, avctx);
3210     if (HAVE_MMI)        dsputil_init_mmi   (c, avctx);
3211     if (ARCH_SH4)        dsputil_init_sh4   (c, avctx);
3212     if (ARCH_BFIN)       dsputil_init_bfin  (c, avctx);
3213
3214     for(i=0; i<64; i++){
3215         if(!c->put_2tap_qpel_pixels_tab[0][i])
3216             c->put_2tap_qpel_pixels_tab[0][i]= c->put_h264_qpel_pixels_tab[0][i];
3217         if(!c->avg_2tap_qpel_pixels_tab[0][i])
3218             c->avg_2tap_qpel_pixels_tab[0][i]= c->avg_h264_qpel_pixels_tab[0][i];
3219     }
3220
3221     c->put_rv30_tpel_pixels_tab[0][0] = c->put_h264_qpel_pixels_tab[0][0];
3222     c->put_rv30_tpel_pixels_tab[1][0] = c->put_h264_qpel_pixels_tab[1][0];
3223     c->avg_rv30_tpel_pixels_tab[0][0] = c->avg_h264_qpel_pixels_tab[0][0];
3224     c->avg_rv30_tpel_pixels_tab[1][0] = c->avg_h264_qpel_pixels_tab[1][0];
3225
3226     c->put_rv40_qpel_pixels_tab[0][0] = c->put_h264_qpel_pixels_tab[0][0];
3227     c->put_rv40_qpel_pixels_tab[1][0] = c->put_h264_qpel_pixels_tab[1][0];
3228     c->avg_rv40_qpel_pixels_tab[0][0] = c->avg_h264_qpel_pixels_tab[0][0];
3229     c->avg_rv40_qpel_pixels_tab[1][0] = c->avg_h264_qpel_pixels_tab[1][0];
3230
3231     switch(c->idct_permutation_type){
3232     case FF_NO_IDCT_PERM:
3233         for(i=0; i<64; i++)
3234             c->idct_permutation[i]= i;
3235         break;
3236     case FF_LIBMPEG2_IDCT_PERM:
3237         for(i=0; i<64; i++)
3238             c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
3239         break;
3240     case FF_SIMPLE_IDCT_PERM:
3241         for(i=0; i<64; i++)
3242             c->idct_permutation[i]= simple_mmx_permutation[i];
3243         break;
3244     case FF_TRANSPOSE_IDCT_PERM:
3245         for(i=0; i<64; i++)
3246             c->idct_permutation[i]= ((i&7)<<3) | (i>>3);
3247         break;
3248     case FF_PARTTRANS_IDCT_PERM:
3249         for(i=0; i<64; i++)
3250             c->idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
3251         break;
3252     case FF_SSE2_IDCT_PERM:
3253         for(i=0; i<64; i++)
3254             c->idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];
3255         break;
3256     default:
3257         av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");
3258     }
3259 }