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