move ff_init_scantable() into dsputil
[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 dsputil.c
27  * DSP utils
28  */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "mpegvideo.h"
33 #include "simple_idct.h"
34 #include "faandct.h"
35 #include "faanidct.h"
36 #include "h263.h"
37 #include "snow.h"
38
39 /* snow.c */
40 void ff_spatial_dwt(int *buffer, int width, int height, int stride, int type, int decomposition_count);
41
42 /* vorbis.c */
43 void vorbis_inverse_coupling(float *mag, float *ang, int blocksize);
44
45 /* flacenc.c */
46 void ff_flac_compute_autocorr(const int32_t *data, int len, int lag, double *autoc);
47
48 /* pngdec.c */
49 void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp);
50
51 uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
52 uint32_t ff_squareTbl[512] = {0, };
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 const uint8_t ff_zigzag_direct[64] = {
59     0,   1,  8, 16,  9,  2,  3, 10,
60     17, 24, 32, 25, 18, 11,  4,  5,
61     12, 19, 26, 33, 40, 48, 41, 34,
62     27, 20, 13,  6,  7, 14, 21, 28,
63     35, 42, 49, 56, 57, 50, 43, 36,
64     29, 22, 15, 23, 30, 37, 44, 51,
65     58, 59, 52, 45, 38, 31, 39, 46,
66     53, 60, 61, 54, 47, 55, 62, 63
67 };
68
69 /* Specific zigzag scan for 248 idct. NOTE that unlike the
70    specification, we interleave the fields */
71 const uint8_t ff_zigzag248_direct[64] = {
72      0,  8,  1,  9, 16, 24,  2, 10,
73     17, 25, 32, 40, 48, 56, 33, 41,
74     18, 26,  3, 11,  4, 12, 19, 27,
75     34, 42, 49, 57, 50, 58, 35, 43,
76     20, 28,  5, 13,  6, 14, 21, 29,
77     36, 44, 51, 59, 52, 60, 37, 45,
78     22, 30,  7, 15, 23, 31, 38, 46,
79     53, 61, 54, 62, 39, 47, 55, 63,
80 };
81
82 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
83 DECLARE_ALIGNED_8(uint16_t, inv_zigzag_direct16[64]) = {0, };
84
85 const uint8_t ff_alternate_horizontal_scan[64] = {
86     0,  1,   2,  3,  8,  9, 16, 17,
87     10, 11,  4,  5,  6,  7, 15, 14,
88     13, 12, 19, 18, 24, 25, 32, 33,
89     26, 27, 20, 21, 22, 23, 28, 29,
90     30, 31, 34, 35, 40, 41, 48, 49,
91     42, 43, 36, 37, 38, 39, 44, 45,
92     46, 47, 50, 51, 56, 57, 58, 59,
93     52, 53, 54, 55, 60, 61, 62, 63,
94 };
95
96 const uint8_t ff_alternate_vertical_scan[64] = {
97     0,  8,  16, 24,  1,  9,  2, 10,
98     17, 25, 32, 40, 48, 56, 57, 49,
99     41, 33, 26, 18,  3, 11,  4, 12,
100     19, 27, 34, 42, 50, 58, 35, 43,
101     51, 59, 20, 28,  5, 13,  6, 14,
102     21, 29, 36, 44, 52, 60, 37, 45,
103     53, 61, 22, 30,  7, 15, 23, 31,
104     38, 46, 54, 62, 39, 47, 55, 63,
105 };
106
107 /* a*inverse[b]>>32 == a/b for all 0<=a<=65536 && 2<=b<=255 */
108 const uint32_t ff_inverse[256]={
109          0, 4294967295U,2147483648U,1431655766, 1073741824,  858993460,  715827883,  613566757,
110  536870912,  477218589,  429496730,  390451573,  357913942,  330382100,  306783379,  286331154,
111  268435456,  252645136,  238609295,  226050911,  214748365,  204522253,  195225787,  186737709,
112  178956971,  171798692,  165191050,  159072863,  153391690,  148102321,  143165577,  138547333,
113  134217728,  130150525,  126322568,  122713352,  119304648,  116080198,  113025456,  110127367,
114  107374183,  104755300,  102261127,   99882961,   97612894,   95443718,   93368855,   91382283,
115   89478486,   87652394,   85899346,   84215046,   82595525,   81037119,   79536432,   78090315,
116   76695845,   75350304,   74051161,   72796056,   71582789,   70409300,   69273667,   68174085,
117   67108864,   66076420,   65075263,   64103990,   63161284,   62245903,   61356676,   60492498,
118   59652324,   58835169,   58040099,   57266231,   56512728,   55778797,   55063684,   54366675,
119   53687092,   53024288,   52377650,   51746594,   51130564,   50529028,   49941481,   49367441,
120   48806447,   48258060,   47721859,   47197443,   46684428,   46182445,   45691142,   45210183,
121   44739243,   44278014,   43826197,   43383509,   42949673,   42524429,   42107523,   41698712,
122   41297763,   40904451,   40518560,   40139882,   39768216,   39403370,   39045158,   38693400,
123   38347923,   38008561,   37675152,   37347542,   37025581,   36709123,   36398028,   36092163,
124   35791395,   35495598,   35204650,   34918434,   34636834,   34359739,   34087043,   33818641,
125   33554432,   33294321,   33038210,   32786010,   32537632,   32292988,   32051995,   31814573,
126   31580642,   31350127,   31122952,   30899046,   30678338,   30460761,   30246249,   30034737,
127   29826162,   29620465,   29417585,   29217465,   29020050,   28825284,   28633116,   28443493,
128   28256364,   28071682,   27889399,   27709467,   27531842,   27356480,   27183338,   27012373,
129   26843546,   26676816,   26512144,   26349493,   26188825,   26030105,   25873297,   25718368,
130   25565282,   25414008,   25264514,   25116768,   24970741,   24826401,   24683721,   24542671,
131   24403224,   24265352,   24129030,   23994231,   23860930,   23729102,   23598722,   23469767,
132   23342214,   23216040,   23091223,   22967740,   22845571,   22724695,   22605092,   22486740,
133   22369622,   22253717,   22139007,   22025474,   21913099,   21801865,   21691755,   21582751,
134   21474837,   21367997,   21262215,   21157475,   21053762,   20951060,   20849356,   20748635,
135   20648882,   20550083,   20452226,   20355296,   20259280,   20164166,   20069941,   19976593,
136   19884108,   19792477,   19701685,   19611723,   19522579,   19434242,   19346700,   19259944,
137   19173962,   19088744,   19004281,   18920561,   18837576,   18755316,   18673771,   18592933,
138   18512791,   18433337,   18354562,   18276457,   18199014,   18122225,   18046082,   17970575,
139   17895698,   17821442,   17747799,   17674763,   17602325,   17530479,   17459217,   17388532,
140   17318417,   17248865,   17179870,   17111424,   17043522,   16976156,   16909321,   16843010,
141 };
142
143 /* Input permutation for the simple_idct_mmx */
144 static const uint8_t simple_mmx_permutation[64]={
145         0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
146         0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
147         0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
148         0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
149         0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
150         0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
151         0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
152         0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
153 };
154
155 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
156     int i;
157     int end;
158
159     st->scantable= src_scantable;
160
161     for(i=0; i<64; i++){
162         int j;
163         j = src_scantable[i];
164         st->permutated[i] = permutation[j];
165 #ifdef ARCH_POWERPC
166         st->inverse[j] = i;
167 #endif
168     }
169
170     end=-1;
171     for(i=0; i<64; i++){
172         int j;
173         j = st->permutated[i];
174         if(j>end) end=j;
175         st->raster_end[i]= end;
176     }
177 }
178
179 static int pix_sum_c(uint8_t * pix, int line_size)
180 {
181     int s, i, j;
182
183     s = 0;
184     for (i = 0; i < 16; i++) {
185         for (j = 0; j < 16; j += 8) {
186             s += pix[0];
187             s += pix[1];
188             s += pix[2];
189             s += pix[3];
190             s += pix[4];
191             s += pix[5];
192             s += pix[6];
193             s += pix[7];
194             pix += 8;
195         }
196         pix += line_size - 16;
197     }
198     return s;
199 }
200
201 static int pix_norm1_c(uint8_t * pix, int line_size)
202 {
203     int s, i, j;
204     uint32_t *sq = ff_squareTbl + 256;
205
206     s = 0;
207     for (i = 0; i < 16; i++) {
208         for (j = 0; j < 16; j += 8) {
209 #if 0
210             s += sq[pix[0]];
211             s += sq[pix[1]];
212             s += sq[pix[2]];
213             s += sq[pix[3]];
214             s += sq[pix[4]];
215             s += sq[pix[5]];
216             s += sq[pix[6]];
217             s += sq[pix[7]];
218 #else
219 #if LONG_MAX > 2147483647
220             register uint64_t x=*(uint64_t*)pix;
221             s += sq[x&0xff];
222             s += sq[(x>>8)&0xff];
223             s += sq[(x>>16)&0xff];
224             s += sq[(x>>24)&0xff];
225             s += sq[(x>>32)&0xff];
226             s += sq[(x>>40)&0xff];
227             s += sq[(x>>48)&0xff];
228             s += sq[(x>>56)&0xff];
229 #else
230             register uint32_t x=*(uint32_t*)pix;
231             s += sq[x&0xff];
232             s += sq[(x>>8)&0xff];
233             s += sq[(x>>16)&0xff];
234             s += sq[(x>>24)&0xff];
235             x=*(uint32_t*)(pix+4);
236             s += sq[x&0xff];
237             s += sq[(x>>8)&0xff];
238             s += sq[(x>>16)&0xff];
239             s += sq[(x>>24)&0xff];
240 #endif
241 #endif
242             pix += 8;
243         }
244         pix += line_size - 16;
245     }
246     return s;
247 }
248
249 static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
250     int i;
251
252     for(i=0; i+8<=w; i+=8){
253         dst[i+0]= bswap_32(src[i+0]);
254         dst[i+1]= bswap_32(src[i+1]);
255         dst[i+2]= bswap_32(src[i+2]);
256         dst[i+3]= bswap_32(src[i+3]);
257         dst[i+4]= bswap_32(src[i+4]);
258         dst[i+5]= bswap_32(src[i+5]);
259         dst[i+6]= bswap_32(src[i+6]);
260         dst[i+7]= bswap_32(src[i+7]);
261     }
262     for(;i<w; i++){
263         dst[i+0]= bswap_32(src[i+0]);
264     }
265 }
266
267 static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
268 {
269     int s, i;
270     uint32_t *sq = ff_squareTbl + 256;
271
272     s = 0;
273     for (i = 0; i < h; i++) {
274         s += sq[pix1[0] - pix2[0]];
275         s += sq[pix1[1] - pix2[1]];
276         s += sq[pix1[2] - pix2[2]];
277         s += sq[pix1[3] - pix2[3]];
278         pix1 += line_size;
279         pix2 += line_size;
280     }
281     return s;
282 }
283
284 static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
285 {
286     int s, i;
287     uint32_t *sq = ff_squareTbl + 256;
288
289     s = 0;
290     for (i = 0; i < h; i++) {
291         s += sq[pix1[0] - pix2[0]];
292         s += sq[pix1[1] - pix2[1]];
293         s += sq[pix1[2] - pix2[2]];
294         s += sq[pix1[3] - pix2[3]];
295         s += sq[pix1[4] - pix2[4]];
296         s += sq[pix1[5] - pix2[5]];
297         s += sq[pix1[6] - pix2[6]];
298         s += sq[pix1[7] - pix2[7]];
299         pix1 += line_size;
300         pix2 += line_size;
301     }
302     return s;
303 }
304
305 static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
306 {
307     int s, i;
308     uint32_t *sq = ff_squareTbl + 256;
309
310     s = 0;
311     for (i = 0; i < h; i++) {
312         s += sq[pix1[ 0] - pix2[ 0]];
313         s += sq[pix1[ 1] - pix2[ 1]];
314         s += sq[pix1[ 2] - pix2[ 2]];
315         s += sq[pix1[ 3] - pix2[ 3]];
316         s += sq[pix1[ 4] - pix2[ 4]];
317         s += sq[pix1[ 5] - pix2[ 5]];
318         s += sq[pix1[ 6] - pix2[ 6]];
319         s += sq[pix1[ 7] - pix2[ 7]];
320         s += sq[pix1[ 8] - pix2[ 8]];
321         s += sq[pix1[ 9] - pix2[ 9]];
322         s += sq[pix1[10] - pix2[10]];
323         s += sq[pix1[11] - pix2[11]];
324         s += sq[pix1[12] - pix2[12]];
325         s += sq[pix1[13] - pix2[13]];
326         s += sq[pix1[14] - pix2[14]];
327         s += sq[pix1[15] - pix2[15]];
328
329         pix1 += line_size;
330         pix2 += line_size;
331     }
332     return s;
333 }
334
335
336 #ifdef CONFIG_SNOW_ENCODER //dwt is in snow.c
337 static inline int w_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int w, int h, int type){
338     int s, i, j;
339     const int dec_count= w==8 ? 3 : 4;
340     int tmp[32*32];
341     int level, ori;
342     static const int scale[2][2][4][4]={
343       {
344         {
345             // 9/7 8x8 dec=3
346             {268, 239, 239, 213},
347             {  0, 224, 224, 152},
348             {  0, 135, 135, 110},
349         },{
350             // 9/7 16x16 or 32x32 dec=4
351             {344, 310, 310, 280},
352             {  0, 320, 320, 228},
353             {  0, 175, 175, 136},
354             {  0, 129, 129, 102},
355         }
356       },{
357         {
358             // 5/3 8x8 dec=3
359             {275, 245, 245, 218},
360             {  0, 230, 230, 156},
361             {  0, 138, 138, 113},
362         },{
363             // 5/3 16x16 or 32x32 dec=4
364             {352, 317, 317, 286},
365             {  0, 328, 328, 233},
366             {  0, 180, 180, 140},
367             {  0, 132, 132, 105},
368         }
369       }
370     };
371
372     for (i = 0; i < h; i++) {
373         for (j = 0; j < w; j+=4) {
374             tmp[32*i+j+0] = (pix1[j+0] - pix2[j+0])<<4;
375             tmp[32*i+j+1] = (pix1[j+1] - pix2[j+1])<<4;
376             tmp[32*i+j+2] = (pix1[j+2] - pix2[j+2])<<4;
377             tmp[32*i+j+3] = (pix1[j+3] - pix2[j+3])<<4;
378         }
379         pix1 += line_size;
380         pix2 += line_size;
381     }
382
383     ff_spatial_dwt(tmp, w, h, 32, type, dec_count);
384
385     s=0;
386     assert(w==h);
387     for(level=0; level<dec_count; level++){
388         for(ori= level ? 1 : 0; ori<4; ori++){
389             int size= w>>(dec_count-level);
390             int sx= (ori&1) ? size : 0;
391             int stride= 32<<(dec_count-level);
392             int sy= (ori&2) ? stride>>1 : 0;
393
394             for(i=0; i<size; i++){
395                 for(j=0; j<size; j++){
396                     int v= tmp[sx + sy + i*stride + j] * scale[type][dec_count-3][level][ori];
397                     s += FFABS(v);
398                 }
399             }
400         }
401     }
402     assert(s>=0);
403     return s>>9;
404 }
405
406 static int w53_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
407     return w_c(v, pix1, pix2, line_size,  8, h, 1);
408 }
409
410 static int w97_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
411     return w_c(v, pix1, pix2, line_size,  8, h, 0);
412 }
413
414 static int w53_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
415     return w_c(v, pix1, pix2, line_size, 16, h, 1);
416 }
417
418 static int w97_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
419     return w_c(v, pix1, pix2, line_size, 16, h, 0);
420 }
421
422 int w53_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
423     return w_c(v, pix1, pix2, line_size, 32, h, 1);
424 }
425
426 int w97_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
427     return w_c(v, pix1, pix2, line_size, 32, h, 0);
428 }
429 #endif
430
431 /* draw the edges of width 'w' of an image of size width, height */
432 //FIXME check that this is ok for mpeg4 interlaced
433 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
434 {
435     uint8_t *ptr, *last_line;
436     int i;
437
438     last_line = buf + (height - 1) * wrap;
439     for(i=0;i<w;i++) {
440         /* top and bottom */
441         memcpy(buf - (i + 1) * wrap, buf, width);
442         memcpy(last_line + (i + 1) * wrap, last_line, width);
443     }
444     /* left and right */
445     ptr = buf;
446     for(i=0;i<height;i++) {
447         memset(ptr - w, ptr[0], w);
448         memset(ptr + width, ptr[width-1], w);
449         ptr += wrap;
450     }
451     /* corners */
452     for(i=0;i<w;i++) {
453         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
454         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
455         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
456         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
457     }
458 }
459
460 static void get_pixels_c(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
461 {
462     int i;
463
464     /* read the pixels */
465     for(i=0;i<8;i++) {
466         block[0] = pixels[0];
467         block[1] = pixels[1];
468         block[2] = pixels[2];
469         block[3] = pixels[3];
470         block[4] = pixels[4];
471         block[5] = pixels[5];
472         block[6] = pixels[6];
473         block[7] = pixels[7];
474         pixels += line_size;
475         block += 8;
476     }
477 }
478
479 static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
480                           const uint8_t *s2, int stride){
481     int i;
482
483     /* read the pixels */
484     for(i=0;i<8;i++) {
485         block[0] = s1[0] - s2[0];
486         block[1] = s1[1] - s2[1];
487         block[2] = s1[2] - s2[2];
488         block[3] = s1[3] - s2[3];
489         block[4] = s1[4] - s2[4];
490         block[5] = s1[5] - s2[5];
491         block[6] = s1[6] - s2[6];
492         block[7] = s1[7] - s2[7];
493         s1 += stride;
494         s2 += stride;
495         block += 8;
496     }
497 }
498
499
500 static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
501                                  int line_size)
502 {
503     int i;
504     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
505
506     /* read the pixels */
507     for(i=0;i<8;i++) {
508         pixels[0] = cm[block[0]];
509         pixels[1] = cm[block[1]];
510         pixels[2] = cm[block[2]];
511         pixels[3] = cm[block[3]];
512         pixels[4] = cm[block[4]];
513         pixels[5] = cm[block[5]];
514         pixels[6] = cm[block[6]];
515         pixels[7] = cm[block[7]];
516
517         pixels += line_size;
518         block += 8;
519     }
520 }
521
522 static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
523                                  int line_size)
524 {
525     int i;
526     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
527
528     /* read the pixels */
529     for(i=0;i<4;i++) {
530         pixels[0] = cm[block[0]];
531         pixels[1] = cm[block[1]];
532         pixels[2] = cm[block[2]];
533         pixels[3] = cm[block[3]];
534
535         pixels += line_size;
536         block += 8;
537     }
538 }
539
540 static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
541                                  int line_size)
542 {
543     int i;
544     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
545
546     /* read the pixels */
547     for(i=0;i<2;i++) {
548         pixels[0] = cm[block[0]];
549         pixels[1] = cm[block[1]];
550
551         pixels += line_size;
552         block += 8;
553     }
554 }
555
556 static void put_signed_pixels_clamped_c(const DCTELEM *block,
557                                         uint8_t *restrict pixels,
558                                         int line_size)
559 {
560     int i, j;
561
562     for (i = 0; i < 8; i++) {
563         for (j = 0; j < 8; j++) {
564             if (*block < -128)
565                 *pixels = 0;
566             else if (*block > 127)
567                 *pixels = 255;
568             else
569                 *pixels = (uint8_t)(*block + 128);
570             block++;
571             pixels++;
572         }
573         pixels += (line_size - 8);
574     }
575 }
576
577 static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
578                           int line_size)
579 {
580     int i;
581     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
582
583     /* read the pixels */
584     for(i=0;i<8;i++) {
585         pixels[0] = cm[pixels[0] + block[0]];
586         pixels[1] = cm[pixels[1] + block[1]];
587         pixels[2] = cm[pixels[2] + block[2]];
588         pixels[3] = cm[pixels[3] + block[3]];
589         pixels[4] = cm[pixels[4] + block[4]];
590         pixels[5] = cm[pixels[5] + block[5]];
591         pixels[6] = cm[pixels[6] + block[6]];
592         pixels[7] = cm[pixels[7] + block[7]];
593         pixels += line_size;
594         block += 8;
595     }
596 }
597
598 static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
599                           int line_size)
600 {
601     int i;
602     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
603
604     /* read the pixels */
605     for(i=0;i<4;i++) {
606         pixels[0] = cm[pixels[0] + block[0]];
607         pixels[1] = cm[pixels[1] + block[1]];
608         pixels[2] = cm[pixels[2] + block[2]];
609         pixels[3] = cm[pixels[3] + block[3]];
610         pixels += line_size;
611         block += 8;
612     }
613 }
614
615 static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
616                           int line_size)
617 {
618     int i;
619     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
620
621     /* read the pixels */
622     for(i=0;i<2;i++) {
623         pixels[0] = cm[pixels[0] + block[0]];
624         pixels[1] = cm[pixels[1] + block[1]];
625         pixels += line_size;
626         block += 8;
627     }
628 }
629
630 static void add_pixels8_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)
631 {
632     int i;
633     for(i=0;i<8;i++) {
634         pixels[0] += block[0];
635         pixels[1] += block[1];
636         pixels[2] += block[2];
637         pixels[3] += block[3];
638         pixels[4] += block[4];
639         pixels[5] += block[5];
640         pixels[6] += block[6];
641         pixels[7] += block[7];
642         pixels += line_size;
643         block += 8;
644     }
645 }
646
647 static void add_pixels4_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)
648 {
649     int i;
650     for(i=0;i<4;i++) {
651         pixels[0] += block[0];
652         pixels[1] += block[1];
653         pixels[2] += block[2];
654         pixels[3] += block[3];
655         pixels += line_size;
656         block += 4;
657     }
658 }
659
660 static int sum_abs_dctelem_c(DCTELEM *block)
661 {
662     int sum=0, i;
663     for(i=0; i<64; i++)
664         sum+= FFABS(block[i]);
665     return sum;
666 }
667
668 #if 0
669
670 #define PIXOP2(OPNAME, OP) \
671 static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
672 {\
673     int i;\
674     for(i=0; i<h; i++){\
675         OP(*((uint64_t*)block), AV_RN64(pixels));\
676         pixels+=line_size;\
677         block +=line_size;\
678     }\
679 }\
680 \
681 static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
682 {\
683     int i;\
684     for(i=0; i<h; i++){\
685         const uint64_t a= AV_RN64(pixels  );\
686         const uint64_t b= AV_RN64(pixels+1);\
687         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
688         pixels+=line_size;\
689         block +=line_size;\
690     }\
691 }\
692 \
693 static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
694 {\
695     int i;\
696     for(i=0; i<h; i++){\
697         const uint64_t a= AV_RN64(pixels  );\
698         const uint64_t b= AV_RN64(pixels+1);\
699         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
700         pixels+=line_size;\
701         block +=line_size;\
702     }\
703 }\
704 \
705 static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
706 {\
707     int i;\
708     for(i=0; i<h; i++){\
709         const uint64_t a= AV_RN64(pixels          );\
710         const uint64_t b= AV_RN64(pixels+line_size);\
711         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
712         pixels+=line_size;\
713         block +=line_size;\
714     }\
715 }\
716 \
717 static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
718 {\
719     int i;\
720     for(i=0; i<h; i++){\
721         const uint64_t a= AV_RN64(pixels          );\
722         const uint64_t b= AV_RN64(pixels+line_size);\
723         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
724         pixels+=line_size;\
725         block +=line_size;\
726     }\
727 }\
728 \
729 static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
730 {\
731         int i;\
732         const uint64_t a= AV_RN64(pixels  );\
733         const uint64_t b= AV_RN64(pixels+1);\
734         uint64_t l0=  (a&0x0303030303030303ULL)\
735                     + (b&0x0303030303030303ULL)\
736                     + 0x0202020202020202ULL;\
737         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
738                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
739         uint64_t l1,h1;\
740 \
741         pixels+=line_size;\
742         for(i=0; i<h; i+=2){\
743             uint64_t a= AV_RN64(pixels  );\
744             uint64_t b= AV_RN64(pixels+1);\
745             l1=  (a&0x0303030303030303ULL)\
746                + (b&0x0303030303030303ULL);\
747             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
748               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
749             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
750             pixels+=line_size;\
751             block +=line_size;\
752             a= AV_RN64(pixels  );\
753             b= AV_RN64(pixels+1);\
754             l0=  (a&0x0303030303030303ULL)\
755                + (b&0x0303030303030303ULL)\
756                + 0x0202020202020202ULL;\
757             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
758               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
759             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
760             pixels+=line_size;\
761             block +=line_size;\
762         }\
763 }\
764 \
765 static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
766 {\
767         int i;\
768         const uint64_t a= AV_RN64(pixels  );\
769         const uint64_t b= AV_RN64(pixels+1);\
770         uint64_t l0=  (a&0x0303030303030303ULL)\
771                     + (b&0x0303030303030303ULL)\
772                     + 0x0101010101010101ULL;\
773         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
774                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
775         uint64_t l1,h1;\
776 \
777         pixels+=line_size;\
778         for(i=0; i<h; i+=2){\
779             uint64_t a= AV_RN64(pixels  );\
780             uint64_t b= AV_RN64(pixels+1);\
781             l1=  (a&0x0303030303030303ULL)\
782                + (b&0x0303030303030303ULL);\
783             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
784               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
785             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
786             pixels+=line_size;\
787             block +=line_size;\
788             a= AV_RN64(pixels  );\
789             b= AV_RN64(pixels+1);\
790             l0=  (a&0x0303030303030303ULL)\
791                + (b&0x0303030303030303ULL)\
792                + 0x0101010101010101ULL;\
793             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
794               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
795             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
796             pixels+=line_size;\
797             block +=line_size;\
798         }\
799 }\
800 \
801 CALL_2X_PIXELS(OPNAME ## _pixels16_c    , OPNAME ## _pixels_c    , 8)\
802 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8)\
803 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8)\
804 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8)\
805 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8)\
806 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8)\
807 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8)
808
809 #define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )
810 #else // 64 bit variant
811
812 #define PIXOP2(OPNAME, OP) \
813 static void OPNAME ## _pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
814     int i;\
815     for(i=0; i<h; i++){\
816         OP(*((uint16_t*)(block  )), AV_RN16(pixels  ));\
817         pixels+=line_size;\
818         block +=line_size;\
819     }\
820 }\
821 static void OPNAME ## _pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
822     int i;\
823     for(i=0; i<h; i++){\
824         OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\
825         pixels+=line_size;\
826         block +=line_size;\
827     }\
828 }\
829 static void OPNAME ## _pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
830     int i;\
831     for(i=0; i<h; i++){\
832         OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\
833         OP(*((uint32_t*)(block+4)), AV_RN32(pixels+4));\
834         pixels+=line_size;\
835         block +=line_size;\
836     }\
837 }\
838 static inline void OPNAME ## _no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
839     OPNAME ## _pixels8_c(block, pixels, line_size, h);\
840 }\
841 \
842 static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
843                                                 int src_stride1, int src_stride2, int h){\
844     int i;\
845     for(i=0; i<h; i++){\
846         uint32_t a,b;\
847         a= AV_RN32(&src1[i*src_stride1  ]);\
848         b= AV_RN32(&src2[i*src_stride2  ]);\
849         OP(*((uint32_t*)&dst[i*dst_stride  ]), no_rnd_avg32(a, b));\
850         a= AV_RN32(&src1[i*src_stride1+4]);\
851         b= AV_RN32(&src2[i*src_stride2+4]);\
852         OP(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));\
853     }\
854 }\
855 \
856 static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
857                                                 int src_stride1, int src_stride2, int h){\
858     int i;\
859     for(i=0; i<h; i++){\
860         uint32_t a,b;\
861         a= AV_RN32(&src1[i*src_stride1  ]);\
862         b= AV_RN32(&src2[i*src_stride2  ]);\
863         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
864         a= AV_RN32(&src1[i*src_stride1+4]);\
865         b= AV_RN32(&src2[i*src_stride2+4]);\
866         OP(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));\
867     }\
868 }\
869 \
870 static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
871                                                 int src_stride1, int src_stride2, int h){\
872     int i;\
873     for(i=0; i<h; i++){\
874         uint32_t a,b;\
875         a= AV_RN32(&src1[i*src_stride1  ]);\
876         b= AV_RN32(&src2[i*src_stride2  ]);\
877         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
878     }\
879 }\
880 \
881 static inline void OPNAME ## _pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
882                                                 int src_stride1, int src_stride2, int h){\
883     int i;\
884     for(i=0; i<h; i++){\
885         uint32_t a,b;\
886         a= AV_RN16(&src1[i*src_stride1  ]);\
887         b= AV_RN16(&src2[i*src_stride2  ]);\
888         OP(*((uint16_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
889     }\
890 }\
891 \
892 static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
893                                                 int src_stride1, int src_stride2, int h){\
894     OPNAME ## _pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
895     OPNAME ## _pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
896 }\
897 \
898 static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
899                                                 int src_stride1, int src_stride2, int h){\
900     OPNAME ## _no_rnd_pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
901     OPNAME ## _no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
902 }\
903 \
904 static inline void OPNAME ## _no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
905     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
906 }\
907 \
908 static inline void OPNAME ## _pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
909     OPNAME ## _pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
910 }\
911 \
912 static inline void OPNAME ## _no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
913     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
914 }\
915 \
916 static inline void OPNAME ## _pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
917     OPNAME ## _pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
918 }\
919 \
920 static inline void OPNAME ## _pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
921                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
922     int i;\
923     for(i=0; i<h; i++){\
924         uint32_t a, b, c, d, l0, l1, h0, h1;\
925         a= AV_RN32(&src1[i*src_stride1]);\
926         b= AV_RN32(&src2[i*src_stride2]);\
927         c= AV_RN32(&src3[i*src_stride3]);\
928         d= AV_RN32(&src4[i*src_stride4]);\
929         l0=  (a&0x03030303UL)\
930            + (b&0x03030303UL)\
931            + 0x02020202UL;\
932         h0= ((a&0xFCFCFCFCUL)>>2)\
933           + ((b&0xFCFCFCFCUL)>>2);\
934         l1=  (c&0x03030303UL)\
935            + (d&0x03030303UL);\
936         h1= ((c&0xFCFCFCFCUL)>>2)\
937           + ((d&0xFCFCFCFCUL)>>2);\
938         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
939         a= AV_RN32(&src1[i*src_stride1+4]);\
940         b= AV_RN32(&src2[i*src_stride2+4]);\
941         c= AV_RN32(&src3[i*src_stride3+4]);\
942         d= AV_RN32(&src4[i*src_stride4+4]);\
943         l0=  (a&0x03030303UL)\
944            + (b&0x03030303UL)\
945            + 0x02020202UL;\
946         h0= ((a&0xFCFCFCFCUL)>>2)\
947           + ((b&0xFCFCFCFCUL)>>2);\
948         l1=  (c&0x03030303UL)\
949            + (d&0x03030303UL);\
950         h1= ((c&0xFCFCFCFCUL)>>2)\
951           + ((d&0xFCFCFCFCUL)>>2);\
952         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
953     }\
954 }\
955 \
956 static inline void OPNAME ## _pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
957     OPNAME ## _pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
958 }\
959 \
960 static inline void OPNAME ## _pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
961     OPNAME ## _pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
962 }\
963 \
964 static inline void OPNAME ## _pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
965     OPNAME ## _pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
966 }\
967 \
968 static inline void OPNAME ## _pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
969     OPNAME ## _pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
970 }\
971 \
972 static inline void OPNAME ## _no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
973                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
974     int i;\
975     for(i=0; i<h; i++){\
976         uint32_t a, b, c, d, l0, l1, h0, h1;\
977         a= AV_RN32(&src1[i*src_stride1]);\
978         b= AV_RN32(&src2[i*src_stride2]);\
979         c= AV_RN32(&src3[i*src_stride3]);\
980         d= AV_RN32(&src4[i*src_stride4]);\
981         l0=  (a&0x03030303UL)\
982            + (b&0x03030303UL)\
983            + 0x01010101UL;\
984         h0= ((a&0xFCFCFCFCUL)>>2)\
985           + ((b&0xFCFCFCFCUL)>>2);\
986         l1=  (c&0x03030303UL)\
987            + (d&0x03030303UL);\
988         h1= ((c&0xFCFCFCFCUL)>>2)\
989           + ((d&0xFCFCFCFCUL)>>2);\
990         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
991         a= AV_RN32(&src1[i*src_stride1+4]);\
992         b= AV_RN32(&src2[i*src_stride2+4]);\
993         c= AV_RN32(&src3[i*src_stride3+4]);\
994         d= AV_RN32(&src4[i*src_stride4+4]);\
995         l0=  (a&0x03030303UL)\
996            + (b&0x03030303UL)\
997            + 0x01010101UL;\
998         h0= ((a&0xFCFCFCFCUL)>>2)\
999           + ((b&0xFCFCFCFCUL)>>2);\
1000         l1=  (c&0x03030303UL)\
1001            + (d&0x03030303UL);\
1002         h1= ((c&0xFCFCFCFCUL)>>2)\
1003           + ((d&0xFCFCFCFCUL)>>2);\
1004         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1005     }\
1006 }\
1007 static inline void OPNAME ## _pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1008                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1009     OPNAME ## _pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1010     OPNAME ## _pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1011 }\
1012 static inline void OPNAME ## _no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1013                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1014     OPNAME ## _no_rnd_pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1015     OPNAME ## _no_rnd_pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1016 }\
1017 \
1018 static inline void OPNAME ## _pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1019 {\
1020         int i, a0, b0, a1, b1;\
1021         a0= pixels[0];\
1022         b0= pixels[1] + 2;\
1023         a0 += b0;\
1024         b0 += pixels[2];\
1025 \
1026         pixels+=line_size;\
1027         for(i=0; i<h; i+=2){\
1028             a1= pixels[0];\
1029             b1= pixels[1];\
1030             a1 += b1;\
1031             b1 += pixels[2];\
1032 \
1033             block[0]= (a1+a0)>>2; /* FIXME non put */\
1034             block[1]= (b1+b0)>>2;\
1035 \
1036             pixels+=line_size;\
1037             block +=line_size;\
1038 \
1039             a0= pixels[0];\
1040             b0= pixels[1] + 2;\
1041             a0 += b0;\
1042             b0 += pixels[2];\
1043 \
1044             block[0]= (a1+a0)>>2;\
1045             block[1]= (b1+b0)>>2;\
1046             pixels+=line_size;\
1047             block +=line_size;\
1048         }\
1049 }\
1050 \
1051 static inline void OPNAME ## _pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1052 {\
1053         int i;\
1054         const uint32_t a= AV_RN32(pixels  );\
1055         const uint32_t b= AV_RN32(pixels+1);\
1056         uint32_t l0=  (a&0x03030303UL)\
1057                     + (b&0x03030303UL)\
1058                     + 0x02020202UL;\
1059         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1060                    + ((b&0xFCFCFCFCUL)>>2);\
1061         uint32_t l1,h1;\
1062 \
1063         pixels+=line_size;\
1064         for(i=0; i<h; i+=2){\
1065             uint32_t a= AV_RN32(pixels  );\
1066             uint32_t b= AV_RN32(pixels+1);\
1067             l1=  (a&0x03030303UL)\
1068                + (b&0x03030303UL);\
1069             h1= ((a&0xFCFCFCFCUL)>>2)\
1070               + ((b&0xFCFCFCFCUL)>>2);\
1071             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1072             pixels+=line_size;\
1073             block +=line_size;\
1074             a= AV_RN32(pixels  );\
1075             b= AV_RN32(pixels+1);\
1076             l0=  (a&0x03030303UL)\
1077                + (b&0x03030303UL)\
1078                + 0x02020202UL;\
1079             h0= ((a&0xFCFCFCFCUL)>>2)\
1080               + ((b&0xFCFCFCFCUL)>>2);\
1081             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1082             pixels+=line_size;\
1083             block +=line_size;\
1084         }\
1085 }\
1086 \
1087 static inline void OPNAME ## _pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1088 {\
1089     int j;\
1090     for(j=0; j<2; j++){\
1091         int i;\
1092         const uint32_t a= AV_RN32(pixels  );\
1093         const uint32_t b= AV_RN32(pixels+1);\
1094         uint32_t l0=  (a&0x03030303UL)\
1095                     + (b&0x03030303UL)\
1096                     + 0x02020202UL;\
1097         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1098                    + ((b&0xFCFCFCFCUL)>>2);\
1099         uint32_t l1,h1;\
1100 \
1101         pixels+=line_size;\
1102         for(i=0; i<h; i+=2){\
1103             uint32_t a= AV_RN32(pixels  );\
1104             uint32_t b= AV_RN32(pixels+1);\
1105             l1=  (a&0x03030303UL)\
1106                + (b&0x03030303UL);\
1107             h1= ((a&0xFCFCFCFCUL)>>2)\
1108               + ((b&0xFCFCFCFCUL)>>2);\
1109             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1110             pixels+=line_size;\
1111             block +=line_size;\
1112             a= AV_RN32(pixels  );\
1113             b= AV_RN32(pixels+1);\
1114             l0=  (a&0x03030303UL)\
1115                + (b&0x03030303UL)\
1116                + 0x02020202UL;\
1117             h0= ((a&0xFCFCFCFCUL)>>2)\
1118               + ((b&0xFCFCFCFCUL)>>2);\
1119             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1120             pixels+=line_size;\
1121             block +=line_size;\
1122         }\
1123         pixels+=4-line_size*(h+1);\
1124         block +=4-line_size*h;\
1125     }\
1126 }\
1127 \
1128 static inline void OPNAME ## _no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1129 {\
1130     int j;\
1131     for(j=0; j<2; j++){\
1132         int i;\
1133         const uint32_t a= AV_RN32(pixels  );\
1134         const uint32_t b= AV_RN32(pixels+1);\
1135         uint32_t l0=  (a&0x03030303UL)\
1136                     + (b&0x03030303UL)\
1137                     + 0x01010101UL;\
1138         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1139                    + ((b&0xFCFCFCFCUL)>>2);\
1140         uint32_t l1,h1;\
1141 \
1142         pixels+=line_size;\
1143         for(i=0; i<h; i+=2){\
1144             uint32_t a= AV_RN32(pixels  );\
1145             uint32_t b= AV_RN32(pixels+1);\
1146             l1=  (a&0x03030303UL)\
1147                + (b&0x03030303UL);\
1148             h1= ((a&0xFCFCFCFCUL)>>2)\
1149               + ((b&0xFCFCFCFCUL)>>2);\
1150             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1151             pixels+=line_size;\
1152             block +=line_size;\
1153             a= AV_RN32(pixels  );\
1154             b= AV_RN32(pixels+1);\
1155             l0=  (a&0x03030303UL)\
1156                + (b&0x03030303UL)\
1157                + 0x01010101UL;\
1158             h0= ((a&0xFCFCFCFCUL)>>2)\
1159               + ((b&0xFCFCFCFCUL)>>2);\
1160             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1161             pixels+=line_size;\
1162             block +=line_size;\
1163         }\
1164         pixels+=4-line_size*(h+1);\
1165         block +=4-line_size*h;\
1166     }\
1167 }\
1168 \
1169 CALL_2X_PIXELS(OPNAME ## _pixels16_c  , OPNAME ## _pixels8_c  , 8)\
1170 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels8_x2_c , 8)\
1171 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels8_y2_c , 8)\
1172 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels8_xy2_c, 8)\
1173 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_c  , OPNAME ## _pixels8_c         , 8)\
1174 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels8_x2_c , 8)\
1175 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels8_y2_c , 8)\
1176 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels8_xy2_c, 8)\
1177
1178 #define op_avg(a, b) a = rnd_avg32(a, b)
1179 #endif
1180 #define op_put(a, b) a = b
1181
1182 PIXOP2(avg, op_avg)
1183 PIXOP2(put, op_put)
1184 #undef op_avg
1185 #undef op_put
1186
1187 #define avg2(a,b) ((a+b+1)>>1)
1188 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
1189
1190 static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
1191     put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);
1192 }
1193
1194 static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
1195     put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);
1196 }
1197
1198 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
1199 {
1200     const int A=(16-x16)*(16-y16);
1201     const int B=(   x16)*(16-y16);
1202     const int C=(16-x16)*(   y16);
1203     const int D=(   x16)*(   y16);
1204     int i;
1205
1206     for(i=0; i<h; i++)
1207     {
1208         dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
1209         dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
1210         dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
1211         dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
1212         dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
1213         dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
1214         dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
1215         dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
1216         dst+= stride;
1217         src+= stride;
1218     }
1219 }
1220
1221 void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
1222                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
1223 {
1224     int y, vx, vy;
1225     const int s= 1<<shift;
1226
1227     width--;
1228     height--;
1229
1230     for(y=0; y<h; y++){
1231         int x;
1232
1233         vx= ox;
1234         vy= oy;
1235         for(x=0; x<8; x++){ //XXX FIXME optimize
1236             int src_x, src_y, frac_x, frac_y, index;
1237
1238             src_x= vx>>16;
1239             src_y= vy>>16;
1240             frac_x= src_x&(s-1);
1241             frac_y= src_y&(s-1);
1242             src_x>>=shift;
1243             src_y>>=shift;
1244
1245             if((unsigned)src_x < width){
1246                 if((unsigned)src_y < height){
1247                     index= src_x + src_y*stride;
1248                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
1249                                            + src[index       +1]*   frac_x )*(s-frac_y)
1250                                         + (  src[index+stride  ]*(s-frac_x)
1251                                            + src[index+stride+1]*   frac_x )*   frac_y
1252                                         + r)>>(shift*2);
1253                 }else{
1254                     index= src_x + av_clip(src_y, 0, height)*stride;
1255                     dst[y*stride + x]= ( (  src[index         ]*(s-frac_x)
1256                                           + src[index       +1]*   frac_x )*s
1257                                         + r)>>(shift*2);
1258                 }
1259             }else{
1260                 if((unsigned)src_y < height){
1261                     index= av_clip(src_x, 0, width) + src_y*stride;
1262                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_y)
1263                                            + src[index+stride  ]*   frac_y )*s
1264                                         + r)>>(shift*2);
1265                 }else{
1266                     index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
1267                     dst[y*stride + x]=    src[index         ];
1268                 }
1269             }
1270
1271             vx+= dxx;
1272             vy+= dyx;
1273         }
1274         ox += dxy;
1275         oy += dyy;
1276     }
1277 }
1278
1279 static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1280     switch(width){
1281     case 2: put_pixels2_c (dst, src, stride, height); break;
1282     case 4: put_pixels4_c (dst, src, stride, height); break;
1283     case 8: put_pixels8_c (dst, src, stride, height); break;
1284     case 16:put_pixels16_c(dst, src, stride, height); break;
1285     }
1286 }
1287
1288 static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1289     int i,j;
1290     for (i=0; i < height; i++) {
1291       for (j=0; j < width; j++) {
1292         dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
1293       }
1294       src += stride;
1295       dst += stride;
1296     }
1297 }
1298
1299 static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1300     int i,j;
1301     for (i=0; i < height; i++) {
1302       for (j=0; j < width; j++) {
1303         dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
1304       }
1305       src += stride;
1306       dst += stride;
1307     }
1308 }
1309
1310 static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1311     int i,j;
1312     for (i=0; i < height; i++) {
1313       for (j=0; j < width; j++) {
1314         dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
1315       }
1316       src += stride;
1317       dst += stride;
1318     }
1319 }
1320
1321 static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1322     int i,j;
1323     for (i=0; i < height; i++) {
1324       for (j=0; j < width; j++) {
1325         dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
1326       }
1327       src += stride;
1328       dst += stride;
1329     }
1330 }
1331
1332 static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1333     int i,j;
1334     for (i=0; i < height; i++) {
1335       for (j=0; j < width; j++) {
1336         dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
1337       }
1338       src += stride;
1339       dst += stride;
1340     }
1341 }
1342
1343 static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1344     int i,j;
1345     for (i=0; i < height; i++) {
1346       for (j=0; j < width; j++) {
1347         dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
1348       }
1349       src += stride;
1350       dst += stride;
1351     }
1352 }
1353
1354 static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1355     int i,j;
1356     for (i=0; i < height; i++) {
1357       for (j=0; j < width; j++) {
1358         dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
1359       }
1360       src += stride;
1361       dst += stride;
1362     }
1363 }
1364
1365 static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1366     int i,j;
1367     for (i=0; i < height; i++) {
1368       for (j=0; j < width; j++) {
1369         dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
1370       }
1371       src += stride;
1372       dst += stride;
1373     }
1374 }
1375
1376 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1377     switch(width){
1378     case 2: avg_pixels2_c (dst, src, stride, height); break;
1379     case 4: avg_pixels4_c (dst, src, stride, height); break;
1380     case 8: avg_pixels8_c (dst, src, stride, height); break;
1381     case 16:avg_pixels16_c(dst, src, stride, height); break;
1382     }
1383 }
1384
1385 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1386     int i,j;
1387     for (i=0; i < height; i++) {
1388       for (j=0; j < width; j++) {
1389         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
1390       }
1391       src += stride;
1392       dst += stride;
1393     }
1394 }
1395
1396 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1397     int i,j;
1398     for (i=0; i < height; i++) {
1399       for (j=0; j < width; j++) {
1400         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
1401       }
1402       src += stride;
1403       dst += stride;
1404     }
1405 }
1406
1407 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1408     int i,j;
1409     for (i=0; i < height; i++) {
1410       for (j=0; j < width; j++) {
1411         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
1412       }
1413       src += stride;
1414       dst += stride;
1415     }
1416 }
1417
1418 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1419     int i,j;
1420     for (i=0; i < height; i++) {
1421       for (j=0; j < width; j++) {
1422         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;
1423       }
1424       src += stride;
1425       dst += stride;
1426     }
1427 }
1428
1429 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1430     int i,j;
1431     for (i=0; i < height; i++) {
1432       for (j=0; j < width; j++) {
1433         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;
1434       }
1435       src += stride;
1436       dst += stride;
1437     }
1438 }
1439
1440 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1441     int i,j;
1442     for (i=0; i < height; i++) {
1443       for (j=0; j < width; j++) {
1444         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
1445       }
1446       src += stride;
1447       dst += stride;
1448     }
1449 }
1450
1451 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1452     int i,j;
1453     for (i=0; i < height; i++) {
1454       for (j=0; j < width; j++) {
1455         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;
1456       }
1457       src += stride;
1458       dst += stride;
1459     }
1460 }
1461
1462 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1463     int i,j;
1464     for (i=0; i < height; i++) {
1465       for (j=0; j < width; j++) {
1466         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;
1467       }
1468       src += stride;
1469       dst += stride;
1470     }
1471 }
1472 #if 0
1473 #define TPEL_WIDTH(width)\
1474 static void put_tpel_pixels ## width ## _mc00_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1475     void put_tpel_pixels_mc00_c(dst, src, stride, width, height);}\
1476 static void put_tpel_pixels ## width ## _mc10_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1477     void put_tpel_pixels_mc10_c(dst, src, stride, width, height);}\
1478 static void put_tpel_pixels ## width ## _mc20_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1479     void put_tpel_pixels_mc20_c(dst, src, stride, width, height);}\
1480 static void put_tpel_pixels ## width ## _mc01_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1481     void put_tpel_pixels_mc01_c(dst, src, stride, width, height);}\
1482 static void put_tpel_pixels ## width ## _mc11_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1483     void put_tpel_pixels_mc11_c(dst, src, stride, width, height);}\
1484 static void put_tpel_pixels ## width ## _mc21_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1485     void put_tpel_pixels_mc21_c(dst, src, stride, width, height);}\
1486 static void put_tpel_pixels ## width ## _mc02_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1487     void put_tpel_pixels_mc02_c(dst, src, stride, width, height);}\
1488 static void put_tpel_pixels ## width ## _mc12_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1489     void put_tpel_pixels_mc12_c(dst, src, stride, width, height);}\
1490 static void put_tpel_pixels ## width ## _mc22_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1491     void put_tpel_pixels_mc22_c(dst, src, stride, width, height);}
1492 #endif
1493
1494 #define H264_CHROMA_MC(OPNAME, OP)\
1495 static void OPNAME ## h264_chroma_mc2_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1496     const int A=(8-x)*(8-y);\
1497     const int B=(  x)*(8-y);\
1498     const int C=(8-x)*(  y);\
1499     const int D=(  x)*(  y);\
1500     int i;\
1501     \
1502     assert(x<8 && y<8 && x>=0 && y>=0);\
1503 \
1504     if(D){\
1505         for(i=0; i<h; i++){\
1506             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1507             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1508             dst+= stride;\
1509             src+= stride;\
1510         }\
1511     }else{\
1512         const int E= B+C;\
1513         const int step= C ? stride : 1;\
1514         for(i=0; i<h; i++){\
1515             OP(dst[0], (A*src[0] + E*src[step+0]));\
1516             OP(dst[1], (A*src[1] + E*src[step+1]));\
1517             dst+= stride;\
1518             src+= stride;\
1519         }\
1520     }\
1521 }\
1522 \
1523 static void OPNAME ## h264_chroma_mc4_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1524     const int A=(8-x)*(8-y);\
1525     const int B=(  x)*(8-y);\
1526     const int C=(8-x)*(  y);\
1527     const int D=(  x)*(  y);\
1528     int i;\
1529     \
1530     assert(x<8 && y<8 && x>=0 && y>=0);\
1531 \
1532     if(D){\
1533         for(i=0; i<h; i++){\
1534             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1535             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1536             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1537             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1538             dst+= stride;\
1539             src+= stride;\
1540         }\
1541     }else{\
1542         const int E= B+C;\
1543         const int step= C ? stride : 1;\
1544         for(i=0; i<h; i++){\
1545             OP(dst[0], (A*src[0] + E*src[step+0]));\
1546             OP(dst[1], (A*src[1] + E*src[step+1]));\
1547             OP(dst[2], (A*src[2] + E*src[step+2]));\
1548             OP(dst[3], (A*src[3] + E*src[step+3]));\
1549             dst+= stride;\
1550             src+= stride;\
1551         }\
1552     }\
1553 }\
1554 \
1555 static void OPNAME ## h264_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
1556     const int A=(8-x)*(8-y);\
1557     const int B=(  x)*(8-y);\
1558     const int C=(8-x)*(  y);\
1559     const int D=(  x)*(  y);\
1560     int i;\
1561     \
1562     assert(x<8 && y<8 && x>=0 && y>=0);\
1563 \
1564     if(D){\
1565         for(i=0; i<h; i++){\
1566             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1567             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1568             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1569             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1570             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
1571             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
1572             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
1573             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
1574             dst+= stride;\
1575             src+= stride;\
1576         }\
1577     }else{\
1578         const int E= B+C;\
1579         const int step= C ? stride : 1;\
1580         for(i=0; i<h; i++){\
1581             OP(dst[0], (A*src[0] + E*src[step+0]));\
1582             OP(dst[1], (A*src[1] + E*src[step+1]));\
1583             OP(dst[2], (A*src[2] + E*src[step+2]));\
1584             OP(dst[3], (A*src[3] + E*src[step+3]));\
1585             OP(dst[4], (A*src[4] + E*src[step+4]));\
1586             OP(dst[5], (A*src[5] + E*src[step+5]));\
1587             OP(dst[6], (A*src[6] + E*src[step+6]));\
1588             OP(dst[7], (A*src[7] + E*src[step+7]));\
1589             dst+= stride;\
1590             src+= stride;\
1591         }\
1592     }\
1593 }
1594
1595 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
1596 #define op_put(a, b) a = (((b) + 32)>>6)
1597
1598 H264_CHROMA_MC(put_       , op_put)
1599 H264_CHROMA_MC(avg_       , op_avg)
1600 #undef op_avg
1601 #undef op_put
1602
1603 static void put_no_rnd_h264_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
1604     const int A=(8-x)*(8-y);
1605     const int B=(  x)*(8-y);
1606     const int C=(8-x)*(  y);
1607     const int D=(  x)*(  y);
1608     int i;
1609
1610     assert(x<8 && y<8 && x>=0 && y>=0);
1611
1612     for(i=0; i<h; i++)
1613     {
1614         dst[0] = (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6;
1615         dst[1] = (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6;
1616         dst[2] = (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6;
1617         dst[3] = (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6;
1618         dst[4] = (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6;
1619         dst[5] = (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6;
1620         dst[6] = (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6;
1621         dst[7] = (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6;
1622         dst+= stride;
1623         src+= stride;
1624     }
1625 }
1626
1627 #define QPEL_MC(r, OPNAME, RND, OP) \
1628 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1629     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1630     int i;\
1631     for(i=0; i<h; i++)\
1632     {\
1633         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
1634         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
1635         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
1636         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
1637         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
1638         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
1639         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
1640         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
1641         dst+=dstStride;\
1642         src+=srcStride;\
1643     }\
1644 }\
1645 \
1646 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1647     const int w=8;\
1648     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1649     int i;\
1650     for(i=0; i<w; i++)\
1651     {\
1652         const int src0= src[0*srcStride];\
1653         const int src1= src[1*srcStride];\
1654         const int src2= src[2*srcStride];\
1655         const int src3= src[3*srcStride];\
1656         const int src4= src[4*srcStride];\
1657         const int src5= src[5*srcStride];\
1658         const int src6= src[6*srcStride];\
1659         const int src7= src[7*srcStride];\
1660         const int src8= src[8*srcStride];\
1661         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
1662         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
1663         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
1664         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
1665         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
1666         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
1667         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
1668         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
1669         dst++;\
1670         src++;\
1671     }\
1672 }\
1673 \
1674 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1675     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1676     int i;\
1677     \
1678     for(i=0; i<h; i++)\
1679     {\
1680         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
1681         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
1682         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
1683         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
1684         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
1685         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
1686         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
1687         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
1688         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
1689         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
1690         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
1691         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
1692         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
1693         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
1694         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
1695         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
1696         dst+=dstStride;\
1697         src+=srcStride;\
1698     }\
1699 }\
1700 \
1701 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1702     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1703     int i;\
1704     const int w=16;\
1705     for(i=0; i<w; i++)\
1706     {\
1707         const int src0= src[0*srcStride];\
1708         const int src1= src[1*srcStride];\
1709         const int src2= src[2*srcStride];\
1710         const int src3= src[3*srcStride];\
1711         const int src4= src[4*srcStride];\
1712         const int src5= src[5*srcStride];\
1713         const int src6= src[6*srcStride];\
1714         const int src7= src[7*srcStride];\
1715         const int src8= src[8*srcStride];\
1716         const int src9= src[9*srcStride];\
1717         const int src10= src[10*srcStride];\
1718         const int src11= src[11*srcStride];\
1719         const int src12= src[12*srcStride];\
1720         const int src13= src[13*srcStride];\
1721         const int src14= src[14*srcStride];\
1722         const int src15= src[15*srcStride];\
1723         const int src16= src[16*srcStride];\
1724         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
1725         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
1726         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
1727         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
1728         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
1729         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
1730         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
1731         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
1732         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
1733         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
1734         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
1735         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
1736         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
1737         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
1738         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
1739         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
1740         dst++;\
1741         src++;\
1742     }\
1743 }\
1744 \
1745 static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1746     OPNAME ## pixels8_c(dst, src, stride, 8);\
1747 }\
1748 \
1749 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1750     uint8_t half[64];\
1751     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1752     OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);\
1753 }\
1754 \
1755 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1756     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
1757 }\
1758 \
1759 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1760     uint8_t half[64];\
1761     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1762     OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);\
1763 }\
1764 \
1765 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1766     uint8_t full[16*9];\
1767     uint8_t half[64];\
1768     copy_block9(full, src, 16, stride, 9);\
1769     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1770     OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);\
1771 }\
1772 \
1773 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1774     uint8_t full[16*9];\
1775     copy_block9(full, src, 16, stride, 9);\
1776     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
1777 }\
1778 \
1779 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1780     uint8_t full[16*9];\
1781     uint8_t half[64];\
1782     copy_block9(full, src, 16, stride, 9);\
1783     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1784     OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);\
1785 }\
1786 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1787     uint8_t full[16*9];\
1788     uint8_t halfH[72];\
1789     uint8_t halfV[64];\
1790     uint8_t halfHV[64];\
1791     copy_block9(full, src, 16, stride, 9);\
1792     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1793     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1794     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1795     OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1796 }\
1797 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1798     uint8_t full[16*9];\
1799     uint8_t halfH[72];\
1800     uint8_t halfHV[64];\
1801     copy_block9(full, src, 16, stride, 9);\
1802     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1803     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1804     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1805     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1806 }\
1807 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1808     uint8_t full[16*9];\
1809     uint8_t halfH[72];\
1810     uint8_t halfV[64];\
1811     uint8_t halfHV[64];\
1812     copy_block9(full, src, 16, stride, 9);\
1813     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1814     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1815     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1816     OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1817 }\
1818 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1819     uint8_t full[16*9];\
1820     uint8_t halfH[72];\
1821     uint8_t halfHV[64];\
1822     copy_block9(full, src, 16, stride, 9);\
1823     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1824     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1825     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1826     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1827 }\
1828 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1829     uint8_t full[16*9];\
1830     uint8_t halfH[72];\
1831     uint8_t halfV[64];\
1832     uint8_t halfHV[64];\
1833     copy_block9(full, src, 16, stride, 9);\
1834     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1835     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1836     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1837     OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1838 }\
1839 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1840     uint8_t full[16*9];\
1841     uint8_t halfH[72];\
1842     uint8_t halfHV[64];\
1843     copy_block9(full, src, 16, stride, 9);\
1844     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1845     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1846     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1847     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1848 }\
1849 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1850     uint8_t full[16*9];\
1851     uint8_t halfH[72];\
1852     uint8_t halfV[64];\
1853     uint8_t halfHV[64];\
1854     copy_block9(full, src, 16, stride, 9);\
1855     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
1856     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1857     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1858     OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1859 }\
1860 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1861     uint8_t full[16*9];\
1862     uint8_t halfH[72];\
1863     uint8_t halfHV[64];\
1864     copy_block9(full, src, 16, stride, 9);\
1865     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1866     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1867     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1868     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1869 }\
1870 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1871     uint8_t halfH[72];\
1872     uint8_t halfHV[64];\
1873     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1874     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1875     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1876 }\
1877 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1878     uint8_t halfH[72];\
1879     uint8_t halfHV[64];\
1880     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1881     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1882     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1883 }\
1884 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1885     uint8_t full[16*9];\
1886     uint8_t halfH[72];\
1887     uint8_t halfV[64];\
1888     uint8_t halfHV[64];\
1889     copy_block9(full, src, 16, stride, 9);\
1890     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1891     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1892     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1893     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1894 }\
1895 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1896     uint8_t full[16*9];\
1897     uint8_t halfH[72];\
1898     copy_block9(full, src, 16, stride, 9);\
1899     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1900     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1901     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1902 }\
1903 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1904     uint8_t full[16*9];\
1905     uint8_t halfH[72];\
1906     uint8_t halfV[64];\
1907     uint8_t halfHV[64];\
1908     copy_block9(full, src, 16, stride, 9);\
1909     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1910     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1911     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1912     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1913 }\
1914 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1915     uint8_t full[16*9];\
1916     uint8_t halfH[72];\
1917     copy_block9(full, src, 16, stride, 9);\
1918     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1919     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1920     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1921 }\
1922 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1923     uint8_t halfH[72];\
1924     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1925     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1926 }\
1927 static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1928     OPNAME ## pixels16_c(dst, src, stride, 16);\
1929 }\
1930 \
1931 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1932     uint8_t half[256];\
1933     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1934     OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);\
1935 }\
1936 \
1937 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1938     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1939 }\
1940 \
1941 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1942     uint8_t half[256];\
1943     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1944     OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);\
1945 }\
1946 \
1947 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1948     uint8_t full[24*17];\
1949     uint8_t half[256];\
1950     copy_block17(full, src, 24, stride, 17);\
1951     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1952     OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);\
1953 }\
1954 \
1955 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1956     uint8_t full[24*17];\
1957     copy_block17(full, src, 24, stride, 17);\
1958     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
1959 }\
1960 \
1961 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1962     uint8_t full[24*17];\
1963     uint8_t half[256];\
1964     copy_block17(full, src, 24, stride, 17);\
1965     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1966     OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);\
1967 }\
1968 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1969     uint8_t full[24*17];\
1970     uint8_t halfH[272];\
1971     uint8_t halfV[256];\
1972     uint8_t halfHV[256];\
1973     copy_block17(full, src, 24, stride, 17);\
1974     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1975     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1976     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1977     OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1978 }\
1979 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1980     uint8_t full[24*17];\
1981     uint8_t halfH[272];\
1982     uint8_t halfHV[256];\
1983     copy_block17(full, src, 24, stride, 17);\
1984     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1985     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
1986     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1987     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
1988 }\
1989 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1990     uint8_t full[24*17];\
1991     uint8_t halfH[272];\
1992     uint8_t halfV[256];\
1993     uint8_t halfHV[256];\
1994     copy_block17(full, src, 24, stride, 17);\
1995     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1996     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1997     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1998     OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1999 }\
2000 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2001     uint8_t full[24*17];\
2002     uint8_t halfH[272];\
2003     uint8_t halfHV[256];\
2004     copy_block17(full, src, 24, stride, 17);\
2005     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2006     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2007     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2008     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2009 }\
2010 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
2011     uint8_t full[24*17];\
2012     uint8_t halfH[272];\
2013     uint8_t halfV[256];\
2014     uint8_t halfHV[256];\
2015     copy_block17(full, src, 24, stride, 17);\
2016     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2017     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2018     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2019     OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2020 }\
2021 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2022     uint8_t full[24*17];\
2023     uint8_t halfH[272];\
2024     uint8_t halfHV[256];\
2025     copy_block17(full, src, 24, stride, 17);\
2026     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2027     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2028     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2029     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2030 }\
2031 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
2032     uint8_t full[24*17];\
2033     uint8_t halfH[272];\
2034     uint8_t halfV[256];\
2035     uint8_t halfHV[256];\
2036     copy_block17(full, src, 24, stride, 17);\
2037     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
2038     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2039     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2040     OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2041 }\
2042 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2043     uint8_t full[24*17];\
2044     uint8_t halfH[272];\
2045     uint8_t halfHV[256];\
2046     copy_block17(full, src, 24, stride, 17);\
2047     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2048     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2049     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2050     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2051 }\
2052 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2053     uint8_t halfH[272];\
2054     uint8_t halfHV[256];\
2055     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2056     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2057     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2058 }\
2059 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2060     uint8_t halfH[272];\
2061     uint8_t halfHV[256];\
2062     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2063     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2064     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2065 }\
2066 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
2067     uint8_t full[24*17];\
2068     uint8_t halfH[272];\
2069     uint8_t halfV[256];\
2070     uint8_t halfHV[256];\
2071     copy_block17(full, src, 24, stride, 17);\
2072     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2073     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2074     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2075     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2076 }\
2077 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2078     uint8_t full[24*17];\
2079     uint8_t halfH[272];\
2080     copy_block17(full, src, 24, stride, 17);\
2081     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2082     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2083     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2084 }\
2085 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
2086     uint8_t full[24*17];\
2087     uint8_t halfH[272];\
2088     uint8_t halfV[256];\
2089     uint8_t halfHV[256];\
2090     copy_block17(full, src, 24, stride, 17);\
2091     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2092     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2093     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2094     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2095 }\
2096 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2097     uint8_t full[24*17];\
2098     uint8_t halfH[272];\
2099     copy_block17(full, src, 24, stride, 17);\
2100     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2101     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2102     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2103 }\
2104 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2105     uint8_t halfH[272];\
2106     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2107     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2108 }
2109
2110 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2111 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
2112 #define op_put(a, b) a = cm[((b) + 16)>>5]
2113 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
2114
2115 QPEL_MC(0, put_       , _       , op_put)
2116 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
2117 QPEL_MC(0, avg_       , _       , op_avg)
2118 //QPEL_MC(1, avg_no_rnd , _       , op_avg)
2119 #undef op_avg
2120 #undef op_avg_no_rnd
2121 #undef op_put
2122 #undef op_put_no_rnd
2123
2124 #if 1
2125 #define H264_LOWPASS(OPNAME, OP, OP2) \
2126 static av_unused void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2127     const int h=2;\
2128     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2129     int i;\
2130     for(i=0; i<h; i++)\
2131     {\
2132         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2133         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2134         dst+=dstStride;\
2135         src+=srcStride;\
2136     }\
2137 }\
2138 \
2139 static av_unused void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2140     const int w=2;\
2141     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2142     int i;\
2143     for(i=0; i<w; i++)\
2144     {\
2145         const int srcB= src[-2*srcStride];\
2146         const int srcA= src[-1*srcStride];\
2147         const int src0= src[0 *srcStride];\
2148         const int src1= src[1 *srcStride];\
2149         const int src2= src[2 *srcStride];\
2150         const int src3= src[3 *srcStride];\
2151         const int src4= src[4 *srcStride];\
2152         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2153         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2154         dst++;\
2155         src++;\
2156     }\
2157 }\
2158 \
2159 static av_unused void OPNAME ## h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2160     const int h=2;\
2161     const int w=2;\
2162     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2163     int i;\
2164     src -= 2*srcStride;\
2165     for(i=0; i<h+5; i++)\
2166     {\
2167         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2168         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2169         tmp+=tmpStride;\
2170         src+=srcStride;\
2171     }\
2172     tmp -= tmpStride*(h+5-2);\
2173     for(i=0; i<w; i++)\
2174     {\
2175         const int tmpB= tmp[-2*tmpStride];\
2176         const int tmpA= tmp[-1*tmpStride];\
2177         const int tmp0= tmp[0 *tmpStride];\
2178         const int tmp1= tmp[1 *tmpStride];\
2179         const int tmp2= tmp[2 *tmpStride];\
2180         const int tmp3= tmp[3 *tmpStride];\
2181         const int tmp4= tmp[4 *tmpStride];\
2182         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2183         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2184         dst++;\
2185         tmp++;\
2186     }\
2187 }\
2188 static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2189     const int h=4;\
2190     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2191     int i;\
2192     for(i=0; i<h; i++)\
2193     {\
2194         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2195         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2196         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));\
2197         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));\
2198         dst+=dstStride;\
2199         src+=srcStride;\
2200     }\
2201 }\
2202 \
2203 static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2204     const int w=4;\
2205     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2206     int i;\
2207     for(i=0; i<w; i++)\
2208     {\
2209         const int srcB= src[-2*srcStride];\
2210         const int srcA= src[-1*srcStride];\
2211         const int src0= src[0 *srcStride];\
2212         const int src1= src[1 *srcStride];\
2213         const int src2= src[2 *srcStride];\
2214         const int src3= src[3 *srcStride];\
2215         const int src4= src[4 *srcStride];\
2216         const int src5= src[5 *srcStride];\
2217         const int src6= src[6 *srcStride];\
2218         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2219         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2220         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2221         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2222         dst++;\
2223         src++;\
2224     }\
2225 }\
2226 \
2227 static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2228     const int h=4;\
2229     const int w=4;\
2230     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2231     int i;\
2232     src -= 2*srcStride;\
2233     for(i=0; i<h+5; i++)\
2234     {\
2235         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2236         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2237         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]);\
2238         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]);\
2239         tmp+=tmpStride;\
2240         src+=srcStride;\
2241     }\
2242     tmp -= tmpStride*(h+5-2);\
2243     for(i=0; i<w; i++)\
2244     {\
2245         const int tmpB= tmp[-2*tmpStride];\
2246         const int tmpA= tmp[-1*tmpStride];\
2247         const int tmp0= tmp[0 *tmpStride];\
2248         const int tmp1= tmp[1 *tmpStride];\
2249         const int tmp2= tmp[2 *tmpStride];\
2250         const int tmp3= tmp[3 *tmpStride];\
2251         const int tmp4= tmp[4 *tmpStride];\
2252         const int tmp5= tmp[5 *tmpStride];\
2253         const int tmp6= tmp[6 *tmpStride];\
2254         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2255         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2256         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2257         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2258         dst++;\
2259         tmp++;\
2260     }\
2261 }\
2262 \
2263 static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2264     const int h=8;\
2265     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2266     int i;\
2267     for(i=0; i<h; i++)\
2268     {\
2269         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
2270         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));\
2271         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));\
2272         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));\
2273         OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));\
2274         OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));\
2275         OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));\
2276         OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));\
2277         dst+=dstStride;\
2278         src+=srcStride;\
2279     }\
2280 }\
2281 \
2282 static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2283     const int w=8;\
2284     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2285     int i;\
2286     for(i=0; i<w; i++)\
2287     {\
2288         const int srcB= src[-2*srcStride];\
2289         const int srcA= src[-1*srcStride];\
2290         const int src0= src[0 *srcStride];\
2291         const int src1= src[1 *srcStride];\
2292         const int src2= src[2 *srcStride];\
2293         const int src3= src[3 *srcStride];\
2294         const int src4= src[4 *srcStride];\
2295         const int src5= src[5 *srcStride];\
2296         const int src6= src[6 *srcStride];\
2297         const int src7= src[7 *srcStride];\
2298         const int src8= src[8 *srcStride];\
2299         const int src9= src[9 *srcStride];\
2300         const int src10=src[10*srcStride];\
2301         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2302         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2303         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2304         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2305         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
2306         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
2307         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
2308         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
2309         dst++;\
2310         src++;\
2311     }\
2312 }\
2313 \
2314 static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2315     const int h=8;\
2316     const int w=8;\
2317     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2318     int i;\
2319     src -= 2*srcStride;\
2320     for(i=0; i<h+5; i++)\
2321     {\
2322         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);\
2323         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);\
2324         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);\
2325         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);\
2326         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);\
2327         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);\
2328         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);\
2329         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);\
2330         tmp+=tmpStride;\
2331         src+=srcStride;\
2332     }\
2333     tmp -= tmpStride*(h+5-2);\
2334     for(i=0; i<w; i++)\
2335     {\
2336         const int tmpB= tmp[-2*tmpStride];\
2337         const int tmpA= tmp[-1*tmpStride];\
2338         const int tmp0= tmp[0 *tmpStride];\
2339         const int tmp1= tmp[1 *tmpStride];\
2340         const int tmp2= tmp[2 *tmpStride];\
2341         const int tmp3= tmp[3 *tmpStride];\
2342         const int tmp4= tmp[4 *tmpStride];\
2343         const int tmp5= tmp[5 *tmpStride];\
2344         const int tmp6= tmp[6 *tmpStride];\
2345         const int tmp7= tmp[7 *tmpStride];\
2346         const int tmp8= tmp[8 *tmpStride];\
2347         const int tmp9= tmp[9 *tmpStride];\
2348         const int tmp10=tmp[10*tmpStride];\
2349         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2350         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2351         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2352         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2353         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));\
2354         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));\
2355         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));\
2356         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));\
2357         dst++;\
2358         tmp++;\
2359     }\
2360 }\
2361 \
2362 static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2363     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2364     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2365     src += 8*srcStride;\
2366     dst += 8*dstStride;\
2367     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2368     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2369 }\
2370 \
2371 static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2372     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2373     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2374     src += 8*srcStride;\
2375     dst += 8*dstStride;\
2376     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2377     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2378 }\
2379 \
2380 static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2381     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2382     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2383     src += 8*srcStride;\
2384     dst += 8*dstStride;\
2385     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2386     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2387 }\
2388
2389 #define H264_MC(OPNAME, SIZE) \
2390 static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){\
2391     OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);\
2392 }\
2393 \
2394 static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
2395     uint8_t half[SIZE*SIZE];\
2396     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2397     OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);\
2398 }\
2399 \
2400 static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){\
2401     OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);\
2402 }\
2403 \
2404 static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
2405     uint8_t half[SIZE*SIZE];\
2406     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2407     OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);\
2408 }\
2409 \
2410 static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2411     uint8_t full[SIZE*(SIZE+5)];\
2412     uint8_t * const full_mid= full + SIZE*2;\
2413     uint8_t half[SIZE*SIZE];\
2414     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2415     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2416     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);\
2417 }\
2418 \
2419 static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2420     uint8_t full[SIZE*(SIZE+5)];\
2421     uint8_t * const full_mid= full + SIZE*2;\
2422     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2423     OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);\
2424 }\
2425 \
2426 static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2427     uint8_t full[SIZE*(SIZE+5)];\
2428     uint8_t * const full_mid= full + SIZE*2;\
2429     uint8_t half[SIZE*SIZE];\
2430     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2431     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2432     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);\
2433 }\
2434 \
2435 static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2436     uint8_t full[SIZE*(SIZE+5)];\
2437     uint8_t * const full_mid= full + SIZE*2;\
2438     uint8_t halfH[SIZE*SIZE];\
2439     uint8_t halfV[SIZE*SIZE];\
2440     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2441     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2442     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2443     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2444 }\
2445 \
2446 static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2447     uint8_t full[SIZE*(SIZE+5)];\
2448     uint8_t * const full_mid= full + SIZE*2;\
2449     uint8_t halfH[SIZE*SIZE];\
2450     uint8_t halfV[SIZE*SIZE];\
2451     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2452     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2453     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2454     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2455 }\
2456 \
2457 static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2458     uint8_t full[SIZE*(SIZE+5)];\
2459     uint8_t * const full_mid= full + SIZE*2;\
2460     uint8_t halfH[SIZE*SIZE];\
2461     uint8_t halfV[SIZE*SIZE];\
2462     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2463     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2464     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2465     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2466 }\
2467 \
2468 static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2469     uint8_t full[SIZE*(SIZE+5)];\
2470     uint8_t * const full_mid= full + SIZE*2;\
2471     uint8_t halfH[SIZE*SIZE];\
2472     uint8_t halfV[SIZE*SIZE];\
2473     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2474     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2475     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2476     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2477 }\
2478 \
2479 static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2480     int16_t tmp[SIZE*(SIZE+5)];\
2481     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);\
2482 }\
2483 \
2484 static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2485     int16_t tmp[SIZE*(SIZE+5)];\
2486     uint8_t halfH[SIZE*SIZE];\
2487     uint8_t halfHV[SIZE*SIZE];\
2488     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2489     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2490     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2491 }\
2492 \
2493 static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2494     int16_t tmp[SIZE*(SIZE+5)];\
2495     uint8_t halfH[SIZE*SIZE];\
2496     uint8_t halfHV[SIZE*SIZE];\
2497     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2498     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2499     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2500 }\
2501 \
2502 static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2503     uint8_t full[SIZE*(SIZE+5)];\
2504     uint8_t * const full_mid= full + SIZE*2;\
2505     int16_t tmp[SIZE*(SIZE+5)];\
2506     uint8_t halfV[SIZE*SIZE];\
2507     uint8_t halfHV[SIZE*SIZE];\
2508     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2509     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2510     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2511     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2512 }\
2513 \
2514 static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2515     uint8_t full[SIZE*(SIZE+5)];\
2516     uint8_t * const full_mid= full + SIZE*2;\
2517     int16_t tmp[SIZE*(SIZE+5)];\
2518     uint8_t halfV[SIZE*SIZE];\
2519     uint8_t halfHV[SIZE*SIZE];\
2520     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2521     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2522     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2523     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2524 }\
2525
2526 #define op_avg(a, b)  a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2527 //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
2528 #define op_put(a, b)  a = cm[((b) + 16)>>5]
2529 #define op2_avg(a, b)  a = (((a)+cm[((b) + 512)>>10]+1)>>1)
2530 #define op2_put(a, b)  a = cm[((b) + 512)>>10]
2531
2532 H264_LOWPASS(put_       , op_put, op2_put)
2533 H264_LOWPASS(avg_       , op_avg, op2_avg)
2534 H264_MC(put_, 2)
2535 H264_MC(put_, 4)
2536 H264_MC(put_, 8)
2537 H264_MC(put_, 16)
2538 H264_MC(avg_, 4)
2539 H264_MC(avg_, 8)
2540 H264_MC(avg_, 16)
2541
2542 #undef op_avg
2543 #undef op_put
2544 #undef op2_avg
2545 #undef op2_put
2546 #endif
2547
2548 #define op_scale1(x)  block[x] = av_clip_uint8( (block[x]*weight + offset) >> log2_denom )
2549 #define op_scale2(x)  dst[x] = av_clip_uint8( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
2550 #define H264_WEIGHT(W,H) \
2551 static void weight_h264_pixels ## W ## x ## H ## _c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ \
2552     int y; \
2553     offset <<= log2_denom; \
2554     if(log2_denom) offset += 1<<(log2_denom-1); \
2555     for(y=0; y<H; y++, block += stride){ \
2556         op_scale1(0); \
2557         op_scale1(1); \
2558         if(W==2) continue; \
2559         op_scale1(2); \
2560         op_scale1(3); \
2561         if(W==4) continue; \
2562         op_scale1(4); \
2563         op_scale1(5); \
2564         op_scale1(6); \
2565         op_scale1(7); \
2566         if(W==8) continue; \
2567         op_scale1(8); \
2568         op_scale1(9); \
2569         op_scale1(10); \
2570         op_scale1(11); \
2571         op_scale1(12); \
2572         op_scale1(13); \
2573         op_scale1(14); \
2574         op_scale1(15); \
2575     } \
2576 } \
2577 static void biweight_h264_pixels ## W ## x ## H ## _c(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset){ \
2578     int y; \
2579     offset = ((offset + 1) | 1) << log2_denom; \
2580     for(y=0; y<H; y++, dst += stride, src += stride){ \
2581         op_scale2(0); \
2582         op_scale2(1); \
2583         if(W==2) continue; \
2584         op_scale2(2); \
2585         op_scale2(3); \
2586         if(W==4) continue; \
2587         op_scale2(4); \
2588         op_scale2(5); \
2589         op_scale2(6); \
2590         op_scale2(7); \
2591         if(W==8) continue; \
2592         op_scale2(8); \
2593         op_scale2(9); \
2594         op_scale2(10); \
2595         op_scale2(11); \
2596         op_scale2(12); \
2597         op_scale2(13); \
2598         op_scale2(14); \
2599         op_scale2(15); \
2600     } \
2601 }
2602
2603 H264_WEIGHT(16,16)
2604 H264_WEIGHT(16,8)
2605 H264_WEIGHT(8,16)
2606 H264_WEIGHT(8,8)
2607 H264_WEIGHT(8,4)
2608 H264_WEIGHT(4,8)
2609 H264_WEIGHT(4,4)
2610 H264_WEIGHT(4,2)
2611 H264_WEIGHT(2,4)
2612 H264_WEIGHT(2,2)
2613
2614 #undef op_scale1
2615 #undef op_scale2
2616 #undef H264_WEIGHT
2617
2618 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
2619     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2620     int i;
2621
2622     for(i=0; i<h; i++){
2623         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
2624         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
2625         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
2626         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
2627         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
2628         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
2629         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
2630         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
2631         dst+=dstStride;
2632         src+=srcStride;
2633     }
2634 }
2635
2636 #ifdef CONFIG_CAVS_DECODER
2637 /* AVS specific */
2638 void ff_cavsdsp_init(DSPContext* c, AVCodecContext *avctx);
2639
2640 void ff_put_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2641     put_pixels8_c(dst, src, stride, 8);
2642 }
2643 void ff_avg_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2644     avg_pixels8_c(dst, src, stride, 8);
2645 }
2646 void ff_put_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2647     put_pixels16_c(dst, src, stride, 16);
2648 }
2649 void ff_avg_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2650     avg_pixels16_c(dst, src, stride, 16);
2651 }
2652 #endif /* CONFIG_CAVS_DECODER */
2653
2654 #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
2655 /* VC-1 specific */
2656 void ff_vc1dsp_init(DSPContext* c, AVCodecContext *avctx);
2657
2658 void ff_put_vc1_mspel_mc00_c(uint8_t *dst, uint8_t *src, int stride, int rnd) {
2659     put_pixels8_c(dst, src, stride, 8);
2660 }
2661 #endif /* CONFIG_VC1_DECODER||CONFIG_WMV3_DECODER */
2662
2663 void ff_intrax8dsp_init(DSPContext* c, AVCodecContext *avctx);
2664
2665 /* H264 specific */
2666 void ff_h264dspenc_init(DSPContext* c, AVCodecContext *avctx);
2667
2668 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
2669     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2670     int i;
2671
2672     for(i=0; i<w; i++){
2673         const int src_1= src[ -srcStride];
2674         const int src0 = src[0          ];
2675         const int src1 = src[  srcStride];
2676         const int src2 = src[2*srcStride];
2677         const int src3 = src[3*srcStride];
2678         const int src4 = src[4*srcStride];
2679         const int src5 = src[5*srcStride];
2680         const int src6 = src[6*srcStride];
2681         const int src7 = src[7*srcStride];
2682         const int src8 = src[8*srcStride];
2683         const int src9 = src[9*srcStride];
2684         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
2685         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
2686         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
2687         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
2688         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
2689         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
2690         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
2691         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
2692         src++;
2693         dst++;
2694     }
2695 }
2696
2697 static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
2698     put_pixels8_c(dst, src, stride, 8);
2699 }
2700
2701 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
2702     uint8_t half[64];
2703     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
2704     put_pixels8_l2(dst, src, half, stride, stride, 8, 8);
2705 }
2706
2707 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
2708     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
2709 }
2710
2711 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
2712     uint8_t half[64];
2713     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
2714     put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
2715 }
2716
2717 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
2718     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
2719 }
2720
2721 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
2722     uint8_t halfH[88];
2723     uint8_t halfV[64];
2724     uint8_t halfHV[64];
2725     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2726     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
2727     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
2728     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
2729 }
2730 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
2731     uint8_t halfH[88];
2732     uint8_t halfV[64];
2733     uint8_t halfHV[64];
2734     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2735     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
2736     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
2737     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
2738 }
2739 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
2740     uint8_t halfH[88];
2741     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2742     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
2743 }
2744
2745 static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
2746     if(ENABLE_ANY_H263) {
2747     int x;
2748     const int strength= ff_h263_loop_filter_strength[qscale];
2749
2750     for(x=0; x<8; x++){
2751         int d1, d2, ad1;
2752         int p0= src[x-2*stride];
2753         int p1= src[x-1*stride];
2754         int p2= src[x+0*stride];
2755         int p3= src[x+1*stride];
2756         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
2757
2758         if     (d<-2*strength) d1= 0;
2759         else if(d<-  strength) d1=-2*strength - d;
2760         else if(d<   strength) d1= d;
2761         else if(d< 2*strength) d1= 2*strength - d;
2762         else                   d1= 0;
2763
2764         p1 += d1;
2765         p2 -= d1;
2766         if(p1&256) p1= ~(p1>>31);
2767         if(p2&256) p2= ~(p2>>31);
2768
2769         src[x-1*stride] = p1;
2770         src[x+0*stride] = p2;
2771
2772         ad1= FFABS(d1)>>1;
2773
2774         d2= av_clip((p0-p3)/4, -ad1, ad1);
2775
2776         src[x-2*stride] = p0 - d2;
2777         src[x+  stride] = p3 + d2;
2778     }
2779     }
2780 }
2781
2782 static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
2783     if(ENABLE_ANY_H263) {
2784     int y;
2785     const int strength= ff_h263_loop_filter_strength[qscale];
2786
2787     for(y=0; y<8; y++){
2788         int d1, d2, ad1;
2789         int p0= src[y*stride-2];
2790         int p1= src[y*stride-1];
2791         int p2= src[y*stride+0];
2792         int p3= src[y*stride+1];
2793         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
2794
2795         if     (d<-2*strength) d1= 0;
2796         else if(d<-  strength) d1=-2*strength - d;
2797         else if(d<   strength) d1= d;
2798         else if(d< 2*strength) d1= 2*strength - d;
2799         else                   d1= 0;
2800
2801         p1 += d1;
2802         p2 -= d1;
2803         if(p1&256) p1= ~(p1>>31);
2804         if(p2&256) p2= ~(p2>>31);
2805
2806         src[y*stride-1] = p1;
2807         src[y*stride+0] = p2;
2808
2809         ad1= FFABS(d1)>>1;
2810
2811         d2= av_clip((p0-p3)/4, -ad1, ad1);
2812
2813         src[y*stride-2] = p0 - d2;
2814         src[y*stride+1] = p3 + d2;
2815     }
2816     }
2817 }
2818
2819 static void h261_loop_filter_c(uint8_t *src, int stride){
2820     int x,y,xy,yz;
2821     int temp[64];
2822
2823     for(x=0; x<8; x++){
2824         temp[x      ] = 4*src[x           ];
2825         temp[x + 7*8] = 4*src[x + 7*stride];
2826     }
2827     for(y=1; y<7; y++){
2828         for(x=0; x<8; x++){
2829             xy = y * stride + x;
2830             yz = y * 8 + x;
2831             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
2832         }
2833     }
2834
2835     for(y=0; y<8; y++){
2836         src[  y*stride] = (temp[  y*8] + 2)>>2;
2837         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
2838         for(x=1; x<7; x++){
2839             xy = y * stride + x;
2840             yz = y * 8 + x;
2841             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
2842         }
2843     }
2844 }
2845
2846 static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
2847 {
2848     int i, d;
2849     for( i = 0; i < 4; i++ ) {
2850         if( tc0[i] < 0 ) {
2851             pix += 4*ystride;
2852             continue;
2853         }
2854         for( d = 0; d < 4; d++ ) {
2855             const int p0 = pix[-1*xstride];
2856             const int p1 = pix[-2*xstride];
2857             const int p2 = pix[-3*xstride];
2858             const int q0 = pix[0];
2859             const int q1 = pix[1*xstride];
2860             const int q2 = pix[2*xstride];
2861
2862             if( FFABS( p0 - q0 ) < alpha &&
2863                 FFABS( p1 - p0 ) < beta &&
2864                 FFABS( q1 - q0 ) < beta ) {
2865
2866                 int tc = tc0[i];
2867                 int i_delta;
2868
2869                 if( FFABS( p2 - p0 ) < beta ) {
2870                     pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
2871                     tc++;
2872                 }
2873                 if( FFABS( q2 - q0 ) < beta ) {
2874                     pix[   xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
2875                     tc++;
2876                 }
2877
2878                 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
2879                 pix[-xstride] = av_clip_uint8( p0 + i_delta );    /* p0' */
2880                 pix[0]        = av_clip_uint8( q0 - i_delta );    /* q0' */
2881             }
2882             pix += ystride;
2883         }
2884     }
2885 }
2886 static void h264_v_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2887 {
2888     h264_loop_filter_luma_c(pix, stride, 1, alpha, beta, tc0);
2889 }
2890 static void h264_h_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2891 {
2892     h264_loop_filter_luma_c(pix, 1, stride, alpha, beta, tc0);
2893 }
2894
2895 static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
2896 {
2897     int i, d;
2898     for( i = 0; i < 4; i++ ) {
2899         const int tc = tc0[i];
2900         if( tc <= 0 ) {
2901             pix += 2*ystride;
2902             continue;
2903         }
2904         for( d = 0; d < 2; d++ ) {
2905             const int p0 = pix[-1*xstride];
2906             const int p1 = pix[-2*xstride];
2907             const int q0 = pix[0];
2908             const int q1 = pix[1*xstride];
2909
2910             if( FFABS( p0 - q0 ) < alpha &&
2911                 FFABS( p1 - p0 ) < beta &&
2912                 FFABS( q1 - q0 ) < beta ) {
2913
2914                 int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
2915
2916                 pix[-xstride] = av_clip_uint8( p0 + delta );    /* p0' */
2917                 pix[0]        = av_clip_uint8( q0 - delta );    /* q0' */
2918             }
2919             pix += ystride;
2920         }
2921     }
2922 }
2923 static void h264_v_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2924 {
2925     h264_loop_filter_chroma_c(pix, stride, 1, alpha, beta, tc0);
2926 }
2927 static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2928 {
2929     h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
2930 }
2931
2932 static inline void h264_loop_filter_chroma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
2933 {
2934     int d;
2935     for( d = 0; d < 8; d++ ) {
2936         const int p0 = pix[-1*xstride];
2937         const int p1 = pix[-2*xstride];
2938         const int q0 = pix[0];
2939         const int q1 = pix[1*xstride];
2940
2941         if( FFABS( p0 - q0 ) < alpha &&
2942             FFABS( p1 - p0 ) < beta &&
2943             FFABS( q1 - q0 ) < beta ) {
2944
2945             pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
2946             pix[0]        = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
2947         }
2948         pix += ystride;
2949     }
2950 }
2951 static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
2952 {
2953     h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);
2954 }
2955 static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
2956 {
2957     h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
2958 }
2959
2960 static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2961 {
2962     int s, i;
2963
2964     s = 0;
2965     for(i=0;i<h;i++) {
2966         s += abs(pix1[0] - pix2[0]);
2967         s += abs(pix1[1] - pix2[1]);
2968         s += abs(pix1[2] - pix2[2]);
2969         s += abs(pix1[3] - pix2[3]);
2970         s += abs(pix1[4] - pix2[4]);
2971         s += abs(pix1[5] - pix2[5]);
2972         s += abs(pix1[6] - pix2[6]);
2973         s += abs(pix1[7] - pix2[7]);
2974         s += abs(pix1[8] - pix2[8]);
2975         s += abs(pix1[9] - pix2[9]);
2976         s += abs(pix1[10] - pix2[10]);
2977         s += abs(pix1[11] - pix2[11]);
2978         s += abs(pix1[12] - pix2[12]);
2979         s += abs(pix1[13] - pix2[13]);
2980         s += abs(pix1[14] - pix2[14]);
2981         s += abs(pix1[15] - pix2[15]);
2982         pix1 += line_size;
2983         pix2 += line_size;
2984     }
2985     return s;
2986 }
2987
2988 static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2989 {
2990     int s, i;
2991
2992     s = 0;
2993     for(i=0;i<h;i++) {
2994         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
2995         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
2996         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
2997         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
2998         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
2999         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
3000         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
3001         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
3002         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
3003         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
3004         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
3005         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
3006         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
3007         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
3008         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
3009         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
3010         pix1 += line_size;
3011         pix2 += line_size;
3012     }
3013     return s;
3014 }
3015
3016 static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3017 {
3018     int s, i;
3019     uint8_t *pix3 = pix2 + line_size;
3020
3021     s = 0;
3022     for(i=0;i<h;i++) {
3023         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
3024         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
3025         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
3026         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
3027         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
3028         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
3029         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
3030         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
3031         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
3032         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
3033         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
3034         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
3035         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
3036         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
3037         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
3038         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
3039         pix1 += line_size;
3040         pix2 += line_size;
3041         pix3 += line_size;
3042     }
3043     return s;
3044 }
3045
3046 static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3047 {
3048     int s, i;
3049     uint8_t *pix3 = pix2 + line_size;
3050
3051     s = 0;
3052     for(i=0;i<h;i++) {
3053         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
3054         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
3055         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
3056         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
3057         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
3058         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
3059         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
3060         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
3061         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
3062         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
3063         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
3064         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
3065         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
3066         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
3067         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
3068         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
3069         pix1 += line_size;
3070         pix2 += line_size;
3071         pix3 += line_size;
3072     }
3073     return s;
3074 }
3075
3076 static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3077 {
3078     int s, i;
3079
3080     s = 0;
3081     for(i=0;i<h;i++) {
3082         s += abs(pix1[0] - pix2[0]);
3083         s += abs(pix1[1] - pix2[1]);
3084         s += abs(pix1[2] - pix2[2]);
3085         s += abs(pix1[3] - pix2[3]);
3086         s += abs(pix1[4] - pix2[4]);
3087         s += abs(pix1[5] - pix2[5]);
3088         s += abs(pix1[6] - pix2[6]);
3089         s += abs(pix1[7] - pix2[7]);
3090         pix1 += line_size;
3091         pix2 += line_size;
3092     }
3093     return s;
3094 }
3095
3096 static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3097 {
3098     int s, i;
3099
3100     s = 0;
3101     for(i=0;i<h;i++) {
3102         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
3103         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
3104         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
3105         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
3106         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
3107         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
3108         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
3109         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
3110         pix1 += line_size;
3111         pix2 += line_size;
3112     }
3113     return s;
3114 }
3115
3116 static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3117 {
3118     int s, i;
3119     uint8_t *pix3 = pix2 + line_size;
3120
3121     s = 0;
3122     for(i=0;i<h;i++) {
3123         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
3124         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
3125         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
3126         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
3127         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
3128         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
3129         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
3130         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
3131         pix1 += line_size;
3132         pix2 += line_size;
3133         pix3 += line_size;
3134     }
3135     return s;
3136 }
3137
3138 static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3139 {
3140     int s, i;
3141     uint8_t *pix3 = pix2 + line_size;
3142
3143     s = 0;
3144     for(i=0;i<h;i++) {
3145         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
3146         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
3147         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
3148         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
3149         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
3150         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
3151         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
3152         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
3153         pix1 += line_size;
3154         pix2 += line_size;
3155         pix3 += line_size;
3156     }
3157     return s;
3158 }
3159
3160 static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
3161     MpegEncContext *c = v;
3162     int score1=0;
3163     int score2=0;
3164     int x,y;
3165
3166     for(y=0; y<h; y++){
3167         for(x=0; x<16; x++){
3168             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
3169         }
3170         if(y+1<h){
3171             for(x=0; x<15; x++){
3172                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
3173                              - s1[x+1] + s1[x+1+stride])
3174                         -FFABS(  s2[x  ] - s2[x  +stride]
3175                              - s2[x+1] + s2[x+1+stride]);
3176             }
3177         }
3178         s1+= stride;
3179         s2+= stride;
3180     }
3181
3182     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
3183     else  return score1 + FFABS(score2)*8;
3184 }
3185
3186 static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
3187     MpegEncContext *c = v;
3188     int score1=0;
3189     int score2=0;
3190     int x,y;
3191
3192     for(y=0; y<h; y++){
3193         for(x=0; x<8; x++){
3194             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
3195         }
3196         if(y+1<h){
3197             for(x=0; x<7; x++){
3198                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
3199                              - s1[x+1] + s1[x+1+stride])
3200                         -FFABS(  s2[x  ] - s2[x  +stride]
3201                              - s2[x+1] + s2[x+1+stride]);
3202             }
3203         }
3204         s1+= stride;
3205         s2+= stride;
3206     }
3207
3208     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
3209     else  return score1 + FFABS(score2)*8;
3210 }
3211
3212 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
3213     int i;
3214     unsigned int sum=0;
3215
3216     for(i=0; i<8*8; i++){
3217         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
3218         int w= weight[i];
3219         b>>= RECON_SHIFT;
3220         assert(-512<b && b<512);
3221
3222         sum += (w*b)*(w*b)>>4;
3223     }
3224     return sum>>2;
3225 }
3226
3227 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
3228     int i;
3229
3230     for(i=0; i<8*8; i++){
3231         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
3232     }
3233 }
3234
3235 /**
3236  * permutes an 8x8 block.
3237  * @param block the block which will be permuted according to the given permutation vector
3238  * @param permutation the permutation vector
3239  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3240  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3241  *                  (inverse) permutated to scantable order!
3242  */
3243 void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
3244 {
3245     int i;
3246     DCTELEM temp[64];
3247
3248     if(last<=0) return;
3249     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3250
3251     for(i=0; i<=last; i++){
3252         const int j= scantable[i];
3253         temp[j]= block[j];
3254         block[j]=0;
3255     }
3256
3257     for(i=0; i<=last; i++){
3258         const int j= scantable[i];
3259         const int perm_j= permutation[j];
3260         block[perm_j]= temp[j];
3261     }
3262 }
3263
3264 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
3265     return 0;
3266 }
3267
3268 void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
3269     int i;
3270
3271     memset(cmp, 0, sizeof(void*)*5);
3272
3273     for(i=0; i<5; i++){
3274         switch(type&0xFF){
3275         case FF_CMP_SAD:
3276             cmp[i]= c->sad[i];
3277             break;
3278         case FF_CMP_SATD:
3279             cmp[i]= c->hadamard8_diff[i];
3280             break;
3281         case FF_CMP_SSE:
3282             cmp[i]= c->sse[i];
3283             break;
3284         case FF_CMP_DCT:
3285             cmp[i]= c->dct_sad[i];
3286             break;
3287         case FF_CMP_DCT264:
3288             cmp[i]= c->dct264_sad[i];
3289             break;
3290         case FF_CMP_DCTMAX:
3291             cmp[i]= c->dct_max[i];
3292             break;
3293         case FF_CMP_PSNR:
3294             cmp[i]= c->quant_psnr[i];
3295             break;
3296         case FF_CMP_BIT:
3297             cmp[i]= c->bit[i];
3298             break;
3299         case FF_CMP_RD:
3300             cmp[i]= c->rd[i];
3301             break;
3302         case FF_CMP_VSAD:
3303             cmp[i]= c->vsad[i];
3304             break;
3305         case FF_CMP_VSSE:
3306             cmp[i]= c->vsse[i];
3307             break;
3308         case FF_CMP_ZERO:
3309             cmp[i]= zero_cmp;
3310             break;
3311         case FF_CMP_NSSE:
3312             cmp[i]= c->nsse[i];
3313             break;
3314 #ifdef CONFIG_SNOW_ENCODER
3315         case FF_CMP_W53:
3316             cmp[i]= c->w53[i];
3317             break;
3318         case FF_CMP_W97:
3319             cmp[i]= c->w97[i];
3320             break;
3321 #endif
3322         default:
3323             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selection\n");
3324         }
3325     }
3326 }
3327
3328 /**
3329  * memset(blocks, 0, sizeof(DCTELEM)*6*64)
3330  */
3331 static void clear_blocks_c(DCTELEM *blocks)
3332 {
3333     memset(blocks, 0, sizeof(DCTELEM)*6*64);
3334 }
3335
3336 static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
3337     long i;
3338     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
3339         long a = *(long*)(src+i);
3340         long b = *(long*)(dst+i);
3341         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
3342     }
3343     for(; i<w; i++)
3344         dst[i+0] += src[i+0];
3345 }
3346
3347 static void add_bytes_l2_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
3348     long i;
3349     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
3350         long a = *(long*)(src1+i);
3351         long b = *(long*)(src2+i);
3352         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
3353     }
3354     for(; i<w; i++)
3355         dst[i] = src1[i]+src2[i];
3356 }
3357
3358 static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
3359     long i;
3360 #ifndef HAVE_FAST_UNALIGNED
3361     if((long)src2 & (sizeof(long)-1)){
3362         for(i=0; i+7<w; i+=8){
3363             dst[i+0] = src1[i+0]-src2[i+0];
3364             dst[i+1] = src1[i+1]-src2[i+1];
3365             dst[i+2] = src1[i+2]-src2[i+2];
3366             dst[i+3] = src1[i+3]-src2[i+3];
3367             dst[i+4] = src1[i+4]-src2[i+4];
3368             dst[i+5] = src1[i+5]-src2[i+5];
3369             dst[i+6] = src1[i+6]-src2[i+6];
3370             dst[i+7] = src1[i+7]-src2[i+7];
3371         }
3372     }else
3373 #endif
3374     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
3375         long a = *(long*)(src1+i);
3376         long b = *(long*)(src2+i);
3377         *(long*)(dst+i) = ((a|pb_80) - (b&pb_7f)) ^ ((a^b^pb_80)&pb_80);
3378     }
3379     for(; i<w; i++)
3380         dst[i+0] = src1[i+0]-src2[i+0];
3381 }
3382
3383 static void sub_hfyu_median_prediction_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
3384     int i;
3385     uint8_t l, lt;
3386
3387     l= *left;
3388     lt= *left_top;
3389
3390     for(i=0; i<w; i++){
3391         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
3392         lt= src1[i];
3393         l= src2[i];
3394         dst[i]= l - pred;
3395     }
3396
3397     *left= l;
3398     *left_top= lt;
3399 }
3400
3401 #define BUTTERFLY2(o1,o2,i1,i2) \
3402 o1= (i1)+(i2);\
3403 o2= (i1)-(i2);
3404
3405 #define BUTTERFLY1(x,y) \
3406 {\
3407     int a,b;\
3408     a= x;\
3409     b= y;\
3410     x= a+b;\
3411     y= a-b;\
3412 }
3413
3414 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
3415
3416 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
3417     int i;
3418     int temp[64];
3419     int sum=0;
3420
3421     assert(h==8);
3422
3423     for(i=0; i<8; i++){
3424         //FIXME try pointer walks
3425         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]);
3426         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]);
3427         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]);
3428         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]);
3429
3430         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
3431         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
3432         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
3433         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
3434
3435         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
3436         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
3437         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
3438         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
3439     }
3440
3441     for(i=0; i<8; i++){
3442         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
3443         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
3444         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
3445         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
3446
3447         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
3448         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
3449         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
3450         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
3451
3452         sum +=
3453              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
3454             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
3455             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
3456             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
3457     }
3458 #if 0
3459 static int maxi=0;
3460 if(sum>maxi){
3461     maxi=sum;
3462     printf("MAX:%d\n", maxi);
3463 }
3464 #endif
3465     return sum;
3466 }
3467
3468 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
3469     int i;
3470     int temp[64];
3471     int sum=0;
3472
3473     assert(h==8);
3474
3475     for(i=0; i<8; i++){
3476         //FIXME try pointer walks
3477         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
3478         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
3479         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
3480         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
3481
3482         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
3483         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
3484         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
3485         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
3486
3487         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
3488         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
3489         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
3490         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
3491     }
3492
3493     for(i=0; i<8; i++){
3494         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
3495         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
3496         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
3497         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
3498
3499         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
3500         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
3501         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
3502         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
3503
3504         sum +=
3505              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
3506             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
3507             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
3508             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
3509     }
3510
3511     sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
3512
3513     return sum;
3514 }
3515
3516 static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3517     MpegEncContext * const s= (MpegEncContext *)c;
3518     DECLARE_ALIGNED_16(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3519     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3520
3521     assert(h==8);
3522
3523     s->dsp.diff_pixels(temp, src1, src2, stride);
3524     s->dsp.fdct(temp);
3525     return s->dsp.sum_abs_dctelem(temp);
3526 }
3527
3528 #ifdef CONFIG_GPL
3529 #define DCT8_1D {\
3530     const int s07 = SRC(0) + SRC(7);\
3531     const int s16 = SRC(1) + SRC(6);\
3532     const int s25 = SRC(2) + SRC(5);\
3533     const int s34 = SRC(3) + SRC(4);\
3534     const int a0 = s07 + s34;\
3535     const int a1 = s16 + s25;\
3536     const int a2 = s07 - s34;\
3537     const int a3 = s16 - s25;\
3538     const int d07 = SRC(0) - SRC(7);\
3539     const int d16 = SRC(1) - SRC(6);\
3540     const int d25 = SRC(2) - SRC(5);\
3541     const int d34 = SRC(3) - SRC(4);\
3542     const int a4 = d16 + d25 + (d07 + (d07>>1));\
3543     const int a5 = d07 - d34 - (d25 + (d25>>1));\
3544     const int a6 = d07 + d34 - (d16 + (d16>>1));\
3545     const int a7 = d16 - d25 + (d34 + (d34>>1));\
3546     DST(0,  a0 + a1     ) ;\
3547     DST(1,  a4 + (a7>>2)) ;\
3548     DST(2,  a2 + (a3>>1)) ;\
3549     DST(3,  a5 + (a6>>2)) ;\
3550     DST(4,  a0 - a1     ) ;\
3551     DST(5,  a6 - (a5>>2)) ;\
3552     DST(6, (a2>>1) - a3 ) ;\
3553     DST(7, (a4>>2) - a7 ) ;\
3554 }
3555
3556 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3557     MpegEncContext * const s= (MpegEncContext *)c;
3558     DCTELEM dct[8][8];
3559     int i;
3560     int sum=0;
3561
3562     s->dsp.diff_pixels(dct[0], src1, src2, stride);
3563
3564 #define SRC(x) dct[i][x]
3565 #define DST(x,v) dct[i][x]= v
3566     for( i = 0; i < 8; i++ )
3567         DCT8_1D
3568 #undef SRC
3569 #undef DST
3570
3571 #define SRC(x) dct[x][i]
3572 #define DST(x,v) sum += FFABS(v)
3573     for( i = 0; i < 8; i++ )
3574         DCT8_1D
3575 #undef SRC
3576 #undef DST
3577     return sum;
3578 }
3579 #endif
3580
3581 static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3582     MpegEncContext * const s= (MpegEncContext *)c;
3583     DECLARE_ALIGNED_8(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3584     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3585     int sum=0, i;
3586
3587     assert(h==8);
3588
3589     s->dsp.diff_pixels(temp, src1, src2, stride);
3590     s->dsp.fdct(temp);
3591
3592     for(i=0; i<64; i++)
3593         sum= FFMAX(sum, FFABS(temp[i]));
3594
3595     return sum;
3596 }
3597
3598 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3599     MpegEncContext * const s= (MpegEncContext *)c;
3600     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64*2/8]);
3601     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3602     DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;
3603     int sum=0, i;
3604
3605     assert(h==8);
3606     s->mb_intra=0;
3607
3608     s->dsp.diff_pixels(temp, src1, src2, stride);
3609
3610     memcpy(bak, temp, 64*sizeof(DCTELEM));
3611
3612     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3613     s->dct_unquantize_inter(s, temp, 0, s->qscale);
3614     ff_simple_idct(temp); //FIXME
3615
3616     for(i=0; i<64; i++)
3617         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
3618
3619     return sum;
3620 }
3621
3622 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3623     MpegEncContext * const s= (MpegEncContext *)c;
3624     const uint8_t *scantable= s->intra_scantable.permutated;
3625     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3626     DECLARE_ALIGNED_8 (uint64_t, aligned_bak[stride]);
3627     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3628     uint8_t * const bak= (uint8_t*)aligned_bak;
3629     int i, last, run, bits, level, distoration, start_i;
3630     const int esc_length= s->ac_esc_length;
3631     uint8_t * length;
3632     uint8_t * last_length;
3633
3634     assert(h==8);
3635
3636     for(i=0; i<8; i++){
3637         ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];
3638         ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];
3639     }
3640
3641     s->dsp.diff_pixels(temp, src1, src2, stride);
3642
3643     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3644
3645     bits=0;
3646
3647     if (s->mb_intra) {
3648         start_i = 1;
3649         length     = s->intra_ac_vlc_length;
3650         last_length= s->intra_ac_vlc_last_length;
3651         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
3652     } else {
3653         start_i = 0;
3654         length     = s->inter_ac_vlc_length;
3655         last_length= s->inter_ac_vlc_last_length;
3656     }
3657
3658     if(last>=start_i){
3659         run=0;
3660         for(i=start_i; i<last; i++){
3661             int j= scantable[i];
3662             level= temp[j];
3663
3664             if(level){
3665                 level+=64;
3666                 if((level&(~127)) == 0){
3667                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
3668                 }else
3669                     bits+= esc_length;
3670                 run=0;
3671             }else
3672                 run++;
3673         }
3674         i= scantable[last];
3675
3676         level= temp[i] + 64;
3677
3678         assert(level - 64);
3679
3680         if((level&(~127)) == 0){
3681             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
3682         }else
3683             bits+= esc_length;
3684
3685     }
3686
3687     if(last>=0){
3688         if(s->mb_intra)
3689             s->dct_unquantize_intra(s, temp, 0, s->qscale);
3690         else
3691             s->dct_unquantize_inter(s, temp, 0, s->qscale);
3692     }
3693
3694     s->dsp.idct_add(bak, stride, temp);
3695
3696     distoration= s->dsp.sse[1](NULL, bak, src1, stride, 8);
3697
3698     return distoration + ((bits*s->qscale*s->qscale*109 + 64)>>7);
3699 }
3700
3701 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3702     MpegEncContext * const s= (MpegEncContext *)c;
3703     const uint8_t *scantable= s->intra_scantable.permutated;
3704     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3705     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3706     int i, last, run, bits, level, start_i;
3707     const int esc_length= s->ac_esc_length;
3708     uint8_t * length;
3709     uint8_t * last_length;
3710
3711     assert(h==8);
3712
3713     s->dsp.diff_pixels(temp, src1, src2, stride);
3714
3715     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3716
3717     bits=0;
3718
3719     if (s->mb_intra) {
3720         start_i = 1;
3721         length     = s->intra_ac_vlc_length;
3722         last_length= s->intra_ac_vlc_last_length;
3723         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
3724     } else {
3725         start_i = 0;
3726         length     = s->inter_ac_vlc_length;
3727         last_length= s->inter_ac_vlc_last_length;
3728     }
3729
3730     if(last>=start_i){
3731         run=0;
3732         for(i=start_i; i<last; i++){
3733             int j= scantable[i];
3734             level= temp[j];
3735
3736             if(level){
3737                 level+=64;
3738                 if((level&(~127)) == 0){
3739                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
3740                 }else
3741                     bits+= esc_length;
3742                 run=0;
3743             }else
3744                 run++;
3745         }
3746         i= scantable[last];
3747
3748         level= temp[i] + 64;
3749
3750         assert(level - 64);
3751
3752         if((level&(~127)) == 0){
3753             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
3754         }else
3755             bits+= esc_length;
3756     }
3757
3758     return bits;
3759 }
3760
3761 static int vsad_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
3762     int score=0;
3763     int x,y;
3764
3765     for(y=1; y<h; y++){
3766         for(x=0; x<16; x+=4){
3767             score+= FFABS(s[x  ] - s[x  +stride]) + FFABS(s[x+1] - s[x+1+stride])
3768                    +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]);
3769         }
3770         s+= stride;
3771     }
3772
3773     return score;
3774 }
3775
3776 static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
3777     int score=0;
3778     int x,y;
3779
3780     for(y=1; y<h; y++){
3781         for(x=0; x<16; x++){
3782             score+= FFABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3783         }
3784         s1+= stride;
3785         s2+= stride;
3786     }
3787
3788     return score;
3789 }
3790
3791 #define SQ(a) ((a)*(a))
3792 static int vsse_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
3793     int score=0;
3794     int x,y;
3795
3796     for(y=1; y<h; y++){
3797         for(x=0; x<16; x+=4){
3798             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])
3799                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
3800         }
3801         s+= stride;
3802     }
3803
3804     return score;
3805 }
3806
3807 static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
3808     int score=0;
3809     int x,y;
3810
3811     for(y=1; y<h; y++){
3812         for(x=0; x<16; x++){
3813             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3814         }
3815         s1+= stride;
3816         s2+= stride;
3817     }
3818
3819     return score;
3820 }
3821
3822 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
3823                                int size){
3824     int score=0;
3825     int i;
3826     for(i=0; i<size; i++)
3827         score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
3828     return score;
3829 }
3830
3831 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
3832 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
3833 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
3834 #ifdef CONFIG_GPL
3835 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
3836 #endif
3837 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
3838 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
3839 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
3840 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
3841
3842 static void vector_fmul_c(float *dst, const float *src, int len){
3843     int i;
3844     for(i=0; i<len; i++)
3845         dst[i] *= src[i];
3846 }
3847
3848 static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
3849     int i;
3850     src1 += len-1;
3851     for(i=0; i<len; i++)
3852         dst[i] = src0[i] * src1[-i];
3853 }
3854
3855 void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step){
3856     int i;
3857     for(i=0; i<len; i++)
3858         dst[i*step] = src0[i] * src1[i] + src2[i] + src3;
3859 }
3860
3861 void ff_float_to_int16_c(int16_t *dst, const float *src, int len){
3862     int i;
3863     for(i=0; i<len; i++) {
3864         int_fast32_t tmp = ((const int32_t*)src)[i];
3865         if(tmp & 0xf0000){
3866             tmp = (0x43c0ffff - tmp)>>31;
3867             // is this faster on some gcc/cpu combinations?
3868 //          if(tmp > 0x43c0ffff) tmp = 0xFFFF;
3869 //          else                 tmp = 0;
3870         }
3871         dst[i] = tmp - 0x8000;
3872     }
3873 }
3874
3875 #define W0 2048
3876 #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
3877 #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
3878 #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
3879 #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
3880 #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
3881 #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
3882 #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
3883
3884 static void wmv2_idct_row(short * b)
3885 {
3886     int s1,s2;
3887     int a0,a1,a2,a3,a4,a5,a6,a7;
3888     /*step 1*/
3889     a1 = W1*b[1]+W7*b[7];
3890     a7 = W7*b[1]-W1*b[7];
3891     a5 = W5*b[5]+W3*b[3];
3892     a3 = W3*b[5]-W5*b[3];
3893     a2 = W2*b[2]+W6*b[6];
3894     a6 = W6*b[2]-W2*b[6];
3895     a0 = W0*b[0]+W0*b[4];
3896     a4 = W0*b[0]-W0*b[4];
3897     /*step 2*/
3898     s1 = (181*(a1-a5+a7-a3)+128)>>8;//1,3,5,7,
3899     s2 = (181*(a1-a5-a7+a3)+128)>>8;
3900     /*step 3*/
3901     b[0] = (a0+a2+a1+a5 + (1<<7))>>8;
3902     b[1] = (a4+a6 +s1   + (1<<7))>>8;
3903     b[2] = (a4-a6 +s2   + (1<<7))>>8;
3904     b[3] = (a0-a2+a7+a3 + (1<<7))>>8;
3905     b[4] = (a0-a2-a7-a3 + (1<<7))>>8;
3906     b[5] = (a4-a6 -s2   + (1<<7))>>8;
3907     b[6] = (a4+a6 -s1   + (1<<7))>>8;
3908     b[7] = (a0+a2-a1-a5 + (1<<7))>>8;
3909 }
3910 static void wmv2_idct_col(short * b)
3911 {
3912     int s1,s2;
3913     int a0,a1,a2,a3,a4,a5,a6,a7;
3914     /*step 1, with extended precision*/
3915     a1 = (W1*b[8*1]+W7*b[8*7] + 4)>>3;
3916     a7 = (W7*b[8*1]-W1*b[8*7] + 4)>>3;
3917     a5 = (W5*b[8*5]+W3*b[8*3] + 4)>>3;
3918     a3 = (W3*b[8*5]-W5*b[8*3] + 4)>>3;
3919     a2 = (W2*b[8*2]+W6*b[8*6] + 4)>>3;
3920     a6 = (W6*b[8*2]-W2*b[8*6] + 4)>>3;
3921     a0 = (W0*b[8*0]+W0*b[8*4]    )>>3;
3922     a4 = (W0*b[8*0]-W0*b[8*4]    )>>3;
3923     /*step 2*/
3924     s1 = (181*(a1-a5+a7-a3)+128)>>8;
3925     s2 = (181*(a1-a5-a7+a3)+128)>>8;
3926     /*step 3*/
3927     b[8*0] = (a0+a2+a1+a5 + (1<<13))>>14;
3928     b[8*1] = (a4+a6 +s1   + (1<<13))>>14;
3929     b[8*2] = (a4-a6 +s2   + (1<<13))>>14;
3930     b[8*3] = (a0-a2+a7+a3 + (1<<13))>>14;
3931
3932     b[8*4] = (a0-a2-a7-a3 + (1<<13))>>14;
3933     b[8*5] = (a4-a6 -s2   + (1<<13))>>14;
3934     b[8*6] = (a4+a6 -s1   + (1<<13))>>14;
3935     b[8*7] = (a0+a2-a1-a5 + (1<<13))>>14;
3936 }
3937 void ff_wmv2_idct_c(short * block){
3938     int i;
3939
3940     for(i=0;i<64;i+=8){
3941         wmv2_idct_row(block+i);
3942     }
3943     for(i=0;i<8;i++){
3944         wmv2_idct_col(block+i);
3945     }
3946 }
3947 /* XXX: those functions should be suppressed ASAP when all IDCTs are
3948  converted */
3949 static void ff_wmv2_idct_put_c(uint8_t *dest, int line_size, DCTELEM *block)
3950 {
3951     ff_wmv2_idct_c(block);
3952     put_pixels_clamped_c(block, dest, line_size);
3953 }
3954 static void ff_wmv2_idct_add_c(uint8_t *dest, int line_size, DCTELEM *block)
3955 {
3956     ff_wmv2_idct_c(block);
3957     add_pixels_clamped_c(block, dest, line_size);
3958 }
3959 static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
3960 {
3961     j_rev_dct (block);
3962     put_pixels_clamped_c(block, dest, line_size);
3963 }
3964 static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
3965 {
3966     j_rev_dct (block);
3967     add_pixels_clamped_c(block, dest, line_size);
3968 }
3969
3970 static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
3971 {
3972     j_rev_dct4 (block);
3973     put_pixels_clamped4_c(block, dest, line_size);
3974 }
3975 static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
3976 {
3977     j_rev_dct4 (block);
3978     add_pixels_clamped4_c(block, dest, line_size);
3979 }
3980
3981 static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
3982 {
3983     j_rev_dct2 (block);
3984     put_pixels_clamped2_c(block, dest, line_size);
3985 }
3986 static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
3987 {
3988     j_rev_dct2 (block);
3989     add_pixels_clamped2_c(block, dest, line_size);
3990 }
3991
3992 static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
3993 {
3994     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
3995
3996     dest[0] = cm[(block[0] + 4)>>3];
3997 }
3998 static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
3999 {
4000     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
4001
4002     dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
4003 }
4004
4005 static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
4006
4007 /* init static data */
4008 void dsputil_static_init(void)
4009 {
4010     int i;
4011
4012     for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
4013     for(i=0;i<MAX_NEG_CROP;i++) {
4014         ff_cropTbl[i] = 0;
4015         ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
4016     }
4017
4018     for(i=0;i<512;i++) {
4019         ff_squareTbl[i] = (i - 256) * (i - 256);
4020     }
4021
4022     for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
4023 }
4024
4025 int ff_check_alignment(void){
4026     static int did_fail=0;
4027     DECLARE_ALIGNED_16(int, aligned);
4028
4029     if((long)&aligned & 15){
4030         if(!did_fail){
4031 #if defined(HAVE_MMX) || defined(HAVE_ALTIVEC)
4032             av_log(NULL, AV_LOG_ERROR,
4033                 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
4034                 "and may be very slow or crash. This is not a bug in libavcodec,\n"
4035                 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
4036                 "Do not report crashes to FFmpeg developers.\n");
4037 #endif
4038             did_fail=1;
4039         }
4040         return -1;
4041     }
4042     return 0;
4043 }
4044
4045 void dsputil_init(DSPContext* c, AVCodecContext *avctx)
4046 {
4047     int i;
4048
4049     ff_check_alignment();
4050
4051 #ifdef CONFIG_ENCODERS
4052     if(avctx->dct_algo==FF_DCT_FASTINT) {
4053         c->fdct = fdct_ifast;
4054         c->fdct248 = fdct_ifast248;
4055     }
4056     else if(avctx->dct_algo==FF_DCT_FAAN) {
4057         c->fdct = ff_faandct;
4058         c->fdct248 = ff_faandct248;
4059     }
4060     else {
4061         c->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
4062         c->fdct248 = ff_fdct248_islow;
4063     }
4064 #endif //CONFIG_ENCODERS
4065
4066     if(avctx->lowres==1){
4067         if(avctx->idct_algo==FF_IDCT_INT || avctx->idct_algo==FF_IDCT_AUTO || !ENABLE_H264_DECODER){
4068             c->idct_put= ff_jref_idct4_put;
4069             c->idct_add= ff_jref_idct4_add;
4070         }else{
4071             c->idct_put= ff_h264_lowres_idct_put_c;
4072             c->idct_add= ff_h264_lowres_idct_add_c;
4073         }
4074         c->idct    = j_rev_dct4;
4075         c->idct_permutation_type= FF_NO_IDCT_PERM;
4076     }else if(avctx->lowres==2){
4077         c->idct_put= ff_jref_idct2_put;
4078         c->idct_add= ff_jref_idct2_add;
4079         c->idct    = j_rev_dct2;
4080         c->idct_permutation_type= FF_NO_IDCT_PERM;
4081     }else if(avctx->lowres==3){
4082         c->idct_put= ff_jref_idct1_put;
4083         c->idct_add= ff_jref_idct1_add;
4084         c->idct    = j_rev_dct1;
4085         c->idct_permutation_type= FF_NO_IDCT_PERM;
4086     }else{
4087         if(avctx->idct_algo==FF_IDCT_INT){
4088             c->idct_put= ff_jref_idct_put;
4089             c->idct_add= ff_jref_idct_add;
4090             c->idct    = j_rev_dct;
4091             c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
4092         }else if((ENABLE_VP3_DECODER || ENABLE_VP5_DECODER || ENABLE_VP6_DECODER || ENABLE_THEORA_DECODER ) &&
4093                 avctx->idct_algo==FF_IDCT_VP3){
4094             c->idct_put= ff_vp3_idct_put_c;
4095             c->idct_add= ff_vp3_idct_add_c;
4096             c->idct    = ff_vp3_idct_c;
4097             c->idct_permutation_type= FF_NO_IDCT_PERM;
4098         }else if(avctx->idct_algo==FF_IDCT_WMV2){
4099             c->idct_put= ff_wmv2_idct_put_c;
4100             c->idct_add= ff_wmv2_idct_add_c;
4101             c->idct    = ff_wmv2_idct_c;
4102             c->idct_permutation_type= FF_NO_IDCT_PERM;
4103         }else if(avctx->idct_algo==FF_IDCT_FAAN){
4104             c->idct_put= ff_faanidct_put;
4105             c->idct_add= ff_faanidct_add;
4106             c->idct    = ff_faanidct;
4107             c->idct_permutation_type= FF_NO_IDCT_PERM;
4108         }else{ //accurate/default
4109             c->idct_put= ff_simple_idct_put;
4110             c->idct_add= ff_simple_idct_add;
4111             c->idct    = ff_simple_idct;
4112             c->idct_permutation_type= FF_NO_IDCT_PERM;
4113         }
4114     }
4115
4116     if (ENABLE_H264_DECODER) {
4117         c->h264_idct_add= ff_h264_idct_add_c;
4118         c->h264_idct8_add= ff_h264_idct8_add_c;
4119         c->h264_idct_dc_add= ff_h264_idct_dc_add_c;
4120         c->h264_idct8_dc_add= ff_h264_idct8_dc_add_c;
4121     }
4122
4123     c->get_pixels = get_pixels_c;
4124     c->diff_pixels = diff_pixels_c;
4125     c->put_pixels_clamped = put_pixels_clamped_c;
4126     c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
4127     c->add_pixels_clamped = add_pixels_clamped_c;
4128     c->add_pixels8 = add_pixels8_c;
4129     c->add_pixels4 = add_pixels4_c;
4130     c->sum_abs_dctelem = sum_abs_dctelem_c;
4131     c->gmc1 = gmc1_c;
4132     c->gmc = ff_gmc_c;
4133     c->clear_blocks = clear_blocks_c;
4134     c->pix_sum = pix_sum_c;
4135     c->pix_norm1 = pix_norm1_c;
4136
4137     /* TODO [0] 16  [1] 8 */
4138     c->pix_abs[0][0] = pix_abs16_c;
4139     c->pix_abs[0][1] = pix_abs16_x2_c;
4140     c->pix_abs[0][2] = pix_abs16_y2_c;
4141     c->pix_abs[0][3] = pix_abs16_xy2_c;
4142     c->pix_abs[1][0] = pix_abs8_c;
4143     c->pix_abs[1][1] = pix_abs8_x2_c;
4144     c->pix_abs[1][2] = pix_abs8_y2_c;
4145     c->pix_abs[1][3] = pix_abs8_xy2_c;
4146
4147 #define dspfunc(PFX, IDX, NUM) \
4148     c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c;     \
4149     c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## NUM ## _x2_c;  \
4150     c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## NUM ## _y2_c;  \
4151     c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## NUM ## _xy2_c
4152
4153     dspfunc(put, 0, 16);
4154     dspfunc(put_no_rnd, 0, 16);
4155     dspfunc(put, 1, 8);
4156     dspfunc(put_no_rnd, 1, 8);
4157     dspfunc(put, 2, 4);
4158     dspfunc(put, 3, 2);
4159
4160     dspfunc(avg, 0, 16);
4161     dspfunc(avg_no_rnd, 0, 16);
4162     dspfunc(avg, 1, 8);
4163     dspfunc(avg_no_rnd, 1, 8);
4164     dspfunc(avg, 2, 4);
4165     dspfunc(avg, 3, 2);
4166 #undef dspfunc
4167
4168     c->put_no_rnd_pixels_l2[0]= put_no_rnd_pixels16_l2_c;
4169     c->put_no_rnd_pixels_l2[1]= put_no_rnd_pixels8_l2_c;
4170
4171     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
4172     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
4173     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
4174     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
4175     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
4176     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
4177     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
4178     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
4179     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
4180
4181     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
4182     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
4183     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
4184     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
4185     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
4186     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
4187     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
4188     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
4189     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
4190
4191 #define dspfunc(PFX, IDX, NUM) \
4192     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
4193     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
4194     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
4195     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
4196     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
4197     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
4198     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
4199     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
4200     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
4201     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
4202     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
4203     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
4204     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
4205     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
4206     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
4207     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
4208
4209     dspfunc(put_qpel, 0, 16);
4210     dspfunc(put_no_rnd_qpel, 0, 16);
4211
4212     dspfunc(avg_qpel, 0, 16);
4213     /* dspfunc(avg_no_rnd_qpel, 0, 16); */
4214
4215     dspfunc(put_qpel, 1, 8);
4216     dspfunc(put_no_rnd_qpel, 1, 8);
4217
4218     dspfunc(avg_qpel, 1, 8);
4219     /* dspfunc(avg_no_rnd_qpel, 1, 8); */
4220
4221     dspfunc(put_h264_qpel, 0, 16);
4222     dspfunc(put_h264_qpel, 1, 8);
4223     dspfunc(put_h264_qpel, 2, 4);
4224     dspfunc(put_h264_qpel, 3, 2);
4225     dspfunc(avg_h264_qpel, 0, 16);
4226     dspfunc(avg_h264_qpel, 1, 8);
4227     dspfunc(avg_h264_qpel, 2, 4);
4228
4229 #undef dspfunc
4230     c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_c;
4231     c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_c;
4232     c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_c;
4233     c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_c;
4234     c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_c;
4235     c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_c;
4236     c->put_no_rnd_h264_chroma_pixels_tab[0]= put_no_rnd_h264_chroma_mc8_c;
4237
4238     c->weight_h264_pixels_tab[0]= weight_h264_pixels16x16_c;
4239     c->weight_h264_pixels_tab[1]= weight_h264_pixels16x8_c;
4240     c->weight_h264_pixels_tab[2]= weight_h264_pixels8x16_c;
4241     c->weight_h264_pixels_tab[3]= weight_h264_pixels8x8_c;
4242     c->weight_h264_pixels_tab[4]= weight_h264_pixels8x4_c;
4243     c->weight_h264_pixels_tab[5]= weight_h264_pixels4x8_c;
4244     c->weight_h264_pixels_tab[6]= weight_h264_pixels4x4_c;
4245     c->weight_h264_pixels_tab[7]= weight_h264_pixels4x2_c;
4246     c->weight_h264_pixels_tab[8]= weight_h264_pixels2x4_c;
4247     c->weight_h264_pixels_tab[9]= weight_h264_pixels2x2_c;
4248     c->biweight_h264_pixels_tab[0]= biweight_h264_pixels16x16_c;
4249     c->biweight_h264_pixels_tab[1]= biweight_h264_pixels16x8_c;
4250     c->biweight_h264_pixels_tab[2]= biweight_h264_pixels8x16_c;
4251     c->biweight_h264_pixels_tab[3]= biweight_h264_pixels8x8_c;
4252     c->biweight_h264_pixels_tab[4]= biweight_h264_pixels8x4_c;
4253     c->biweight_h264_pixels_tab[5]= biweight_h264_pixels4x8_c;
4254     c->biweight_h264_pixels_tab[6]= biweight_h264_pixels4x4_c;
4255     c->biweight_h264_pixels_tab[7]= biweight_h264_pixels4x2_c;
4256     c->biweight_h264_pixels_tab[8]= biweight_h264_pixels2x4_c;
4257     c->biweight_h264_pixels_tab[9]= biweight_h264_pixels2x2_c;
4258
4259     c->draw_edges = draw_edges_c;
4260
4261 #ifdef CONFIG_CAVS_DECODER
4262     ff_cavsdsp_init(c,avctx);
4263 #endif
4264 #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
4265     ff_vc1dsp_init(c,avctx);
4266 #endif
4267 #if defined(CONFIG_WMV2_DECODER) || defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
4268     ff_intrax8dsp_init(c,avctx);
4269 #endif
4270 #if defined(CONFIG_H264_ENCODER)
4271     ff_h264dspenc_init(c,avctx);
4272 #endif
4273
4274     c->put_mspel_pixels_tab[0]= put_mspel8_mc00_c;
4275     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
4276     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
4277     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
4278     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
4279     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
4280     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
4281     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
4282
4283 #define SET_CMP_FUNC(name) \
4284     c->name[0]= name ## 16_c;\
4285     c->name[1]= name ## 8x8_c;
4286
4287     SET_CMP_FUNC(hadamard8_diff)
4288     c->hadamard8_diff[4]= hadamard8_intra16_c;
4289     SET_CMP_FUNC(dct_sad)
4290     SET_CMP_FUNC(dct_max)
4291 #ifdef CONFIG_GPL
4292     SET_CMP_FUNC(dct264_sad)
4293 #endif
4294     c->sad[0]= pix_abs16_c;
4295     c->sad[1]= pix_abs8_c;
4296     c->sse[0]= sse16_c;
4297     c->sse[1]= sse8_c;
4298     c->sse[2]= sse4_c;
4299     SET_CMP_FUNC(quant_psnr)
4300     SET_CMP_FUNC(rd)
4301     SET_CMP_FUNC(bit)
4302     c->vsad[0]= vsad16_c;
4303     c->vsad[4]= vsad_intra16_c;
4304     c->vsse[0]= vsse16_c;
4305     c->vsse[4]= vsse_intra16_c;
4306     c->nsse[0]= nsse16_c;
4307     c->nsse[1]= nsse8_c;
4308 #ifdef CONFIG_SNOW_ENCODER
4309     c->w53[0]= w53_16_c;
4310     c->w53[1]= w53_8_c;
4311     c->w97[0]= w97_16_c;
4312     c->w97[1]= w97_8_c;
4313 #endif
4314
4315     c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
4316
4317     c->add_bytes= add_bytes_c;
4318     c->add_bytes_l2= add_bytes_l2_c;
4319     c->diff_bytes= diff_bytes_c;
4320     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;