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