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