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