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