Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / libavcodec / .svn / text-base / dsputil.c.svn-base
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 libavcodec/dsputil.c
27  * DSP utils
28  */
29
30 #include "avcodec.h"
31 #include "dsputil.h"
32 #include "simple_idct.h"
33 #include "faandct.h"
34 #include "faanidct.h"
35 #include "mathops.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 /* ac3dec.c */
46 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len);
47
48 /* flacenc.c */
49 void ff_flac_compute_autocorr(const int32_t *data, int len, int lag, double *autoc);
50
51 /* pngdec.c */
52 void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp);
53
54 /* eaidct.c */
55 void ff_ea_idct_put_c(uint8_t *dest, int linesize, DCTELEM *block);
56
57 uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
58 uint32_t ff_squareTbl[512] = {0, };
59
60 // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
61 #define pb_7f (~0UL/255 * 0x7f)
62 #define pb_80 (~0UL/255 * 0x80)
63
64 const uint8_t ff_zigzag_direct[64] = {
65     0,   1,  8, 16,  9,  2,  3, 10,
66     17, 24, 32, 25, 18, 11,  4,  5,
67     12, 19, 26, 33, 40, 48, 41, 34,
68     27, 20, 13,  6,  7, 14, 21, 28,
69     35, 42, 49, 56, 57, 50, 43, 36,
70     29, 22, 15, 23, 30, 37, 44, 51,
71     58, 59, 52, 45, 38, 31, 39, 46,
72     53, 60, 61, 54, 47, 55, 62, 63
73 };
74
75 /* Specific zigzag scan for 248 idct. NOTE that unlike the
76    specification, we interleave the fields */
77 const uint8_t ff_zigzag248_direct[64] = {
78      0,  8,  1,  9, 16, 24,  2, 10,
79     17, 25, 32, 40, 48, 56, 33, 41,
80     18, 26,  3, 11,  4, 12, 19, 27,
81     34, 42, 49, 57, 50, 58, 35, 43,
82     20, 28,  5, 13,  6, 14, 21, 29,
83     36, 44, 51, 59, 52, 60, 37, 45,
84     22, 30,  7, 15, 23, 31, 38, 46,
85     53, 61, 54, 62, 39, 47, 55, 63,
86 };
87
88 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
89 DECLARE_ALIGNED_8(uint16_t, inv_zigzag_direct16[64]) = {0, };
90
91 const uint8_t ff_alternate_horizontal_scan[64] = {
92     0,  1,   2,  3,  8,  9, 16, 17,
93     10, 11,  4,  5,  6,  7, 15, 14,
94     13, 12, 19, 18, 24, 25, 32, 33,
95     26, 27, 20, 21, 22, 23, 28, 29,
96     30, 31, 34, 35, 40, 41, 48, 49,
97     42, 43, 36, 37, 38, 39, 44, 45,
98     46, 47, 50, 51, 56, 57, 58, 59,
99     52, 53, 54, 55, 60, 61, 62, 63,
100 };
101
102 const uint8_t ff_alternate_vertical_scan[64] = {
103     0,  8,  16, 24,  1,  9,  2, 10,
104     17, 25, 32, 40, 48, 56, 57, 49,
105     41, 33, 26, 18,  3, 11,  4, 12,
106     19, 27, 34, 42, 50, 58, 35, 43,
107     51, 59, 20, 28,  5, 13,  6, 14,
108     21, 29, 36, 44, 52, 60, 37, 45,
109     53, 61, 22, 30,  7, 15, 23, 31,
110     38, 46, 54, 62, 39, 47, 55, 63,
111 };
112
113 /* a*inverse[b]>>32 == a/b for all 0<=a<=65536 && 2<=b<=255 */
114 const uint32_t ff_inverse[256]={
115          0, 4294967295U,2147483648U,1431655766, 1073741824,  858993460,  715827883,  613566757,
116  536870912,  477218589,  429496730,  390451573,  357913942,  330382100,  306783379,  286331154,
117  268435456,  252645136,  238609295,  226050911,  214748365,  204522253,  195225787,  186737709,
118  178956971,  171798692,  165191050,  159072863,  153391690,  148102321,  143165577,  138547333,
119  134217728,  130150525,  126322568,  122713352,  119304648,  116080198,  113025456,  110127367,
120  107374183,  104755300,  102261127,   99882961,   97612894,   95443718,   93368855,   91382283,
121   89478486,   87652394,   85899346,   84215046,   82595525,   81037119,   79536432,   78090315,
122   76695845,   75350304,   74051161,   72796056,   71582789,   70409300,   69273667,   68174085,
123   67108864,   66076420,   65075263,   64103990,   63161284,   62245903,   61356676,   60492498,
124   59652324,   58835169,   58040099,   57266231,   56512728,   55778797,   55063684,   54366675,
125   53687092,   53024288,   52377650,   51746594,   51130564,   50529028,   49941481,   49367441,
126   48806447,   48258060,   47721859,   47197443,   46684428,   46182445,   45691142,   45210183,
127   44739243,   44278014,   43826197,   43383509,   42949673,   42524429,   42107523,   41698712,
128   41297763,   40904451,   40518560,   40139882,   39768216,   39403370,   39045158,   38693400,
129   38347923,   38008561,   37675152,   37347542,   37025581,   36709123,   36398028,   36092163,
130   35791395,   35495598,   35204650,   34918434,   34636834,   34359739,   34087043,   33818641,
131   33554432,   33294321,   33038210,   32786010,   32537632,   32292988,   32051995,   31814573,
132   31580642,   31350127,   31122952,   30899046,   30678338,   30460761,   30246249,   30034737,
133   29826162,   29620465,   29417585,   29217465,   29020050,   28825284,   28633116,   28443493,
134   28256364,   28071682,   27889399,   27709467,   27531842,   27356480,   27183338,   27012373,
135   26843546,   26676816,   26512144,   26349493,   26188825,   26030105,   25873297,   25718368,
136   25565282,   25414008,   25264514,   25116768,   24970741,   24826401,   24683721,   24542671,
137   24403224,   24265352,   24129030,   23994231,   23860930,   23729102,   23598722,   23469767,
138   23342214,   23216040,   23091223,   22967740,   22845571,   22724695,   22605092,   22486740,
139   22369622,   22253717,   22139007,   22025474,   21913099,   21801865,   21691755,   21582751,
140   21474837,   21367997,   21262215,   21157475,   21053762,   20951060,   20849356,   20748635,
141   20648882,   20550083,   20452226,   20355296,   20259280,   20164166,   20069941,   19976593,
142   19884108,   19792477,   19701685,   19611723,   19522579,   19434242,   19346700,   19259944,
143   19173962,   19088744,   19004281,   18920561,   18837576,   18755316,   18673771,   18592933,
144   18512791,   18433337,   18354562,   18276457,   18199014,   18122225,   18046082,   17970575,
145   17895698,   17821442,   17747799,   17674763,   17602325,   17530479,   17459217,   17388532,
146   17318417,   17248865,   17179870,   17111424,   17043522,   16976156,   16909321,   16843010,
147 };
148
149 /* Input permutation for the simple_idct_mmx */
150 static const uint8_t simple_mmx_permutation[64]={
151         0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
152         0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
153         0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
154         0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
155         0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
156         0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
157         0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
158         0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
159 };
160
161 static const uint8_t idct_sse2_row_perm[8] = {0, 4, 1, 5, 2, 6, 3, 7};
162
163 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
164     int i;
165     int end;
166
167     st->scantable= src_scantable;
168
169     for(i=0; i<64; i++){
170         int j;
171         j = src_scantable[i];
172         st->permutated[i] = permutation[j];
173 #if ARCH_PPC
174         st->inverse[j] = i;
175 #endif
176     }
177
178     end=-1;
179     for(i=0; i<64; i++){
180         int j;
181         j = st->permutated[i];
182         if(j>end) end=j;
183         st->raster_end[i]= end;
184     }
185 }
186
187 static int pix_sum_c(uint8_t * pix, int line_size)
188 {
189     int s, i, j;
190
191     s = 0;
192     for (i = 0; i < 16; i++) {
193         for (j = 0; j < 16; j += 8) {
194             s += pix[0];
195             s += pix[1];
196             s += pix[2];
197             s += pix[3];
198             s += pix[4];
199             s += pix[5];
200             s += pix[6];
201             s += pix[7];
202             pix += 8;
203         }
204         pix += line_size - 16;
205     }
206     return s;
207 }
208
209 static int pix_norm1_c(uint8_t * pix, int line_size)
210 {
211     int s, i, j;
212     uint32_t *sq = ff_squareTbl + 256;
213
214     s = 0;
215     for (i = 0; i < 16; i++) {
216         for (j = 0; j < 16; j += 8) {
217 #if 0
218             s += sq[pix[0]];
219             s += sq[pix[1]];
220             s += sq[pix[2]];
221             s += sq[pix[3]];
222             s += sq[pix[4]];
223             s += sq[pix[5]];
224             s += sq[pix[6]];
225             s += sq[pix[7]];
226 #else
227 #if LONG_MAX > 2147483647
228             register uint64_t x=*(uint64_t*)pix;
229             s += sq[x&0xff];
230             s += sq[(x>>8)&0xff];
231             s += sq[(x>>16)&0xff];
232             s += sq[(x>>24)&0xff];
233             s += sq[(x>>32)&0xff];
234             s += sq[(x>>40)&0xff];
235             s += sq[(x>>48)&0xff];
236             s += sq[(x>>56)&0xff];
237 #else
238             register uint32_t x=*(uint32_t*)pix;
239             s += sq[x&0xff];
240             s += sq[(x>>8)&0xff];
241             s += sq[(x>>16)&0xff];
242             s += sq[(x>>24)&0xff];
243             x=*(uint32_t*)(pix+4);
244             s += sq[x&0xff];
245             s += sq[(x>>8)&0xff];
246             s += sq[(x>>16)&0xff];
247             s += sq[(x>>24)&0xff];
248 #endif
249 #endif
250             pix += 8;
251         }
252         pix += line_size - 16;
253     }
254     return s;
255 }
256
257 static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
258     int i;
259
260     for(i=0; i+8<=w; i+=8){
261         dst[i+0]= bswap_32(src[i+0]);
262         dst[i+1]= bswap_32(src[i+1]);
263         dst[i+2]= bswap_32(src[i+2]);
264         dst[i+3]= bswap_32(src[i+3]);
265         dst[i+4]= bswap_32(src[i+4]);
266         dst[i+5]= bswap_32(src[i+5]);
267         dst[i+6]= bswap_32(src[i+6]);
268         dst[i+7]= bswap_32(src[i+7]);
269     }
270     for(;i<w; i++){
271         dst[i+0]= bswap_32(src[i+0]);
272     }
273 }
274
275 static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
276 {
277     int s, i;
278     uint32_t *sq = ff_squareTbl + 256;
279
280     s = 0;
281     for (i = 0; i < h; i++) {
282         s += sq[pix1[0] - pix2[0]];
283         s += sq[pix1[1] - pix2[1]];
284         s += sq[pix1[2] - pix2[2]];
285         s += sq[pix1[3] - pix2[3]];
286         pix1 += line_size;
287         pix2 += line_size;
288     }
289     return s;
290 }
291
292 static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
293 {
294     int s, i;
295     uint32_t *sq = ff_squareTbl + 256;
296
297     s = 0;
298     for (i = 0; i < h; i++) {
299         s += sq[pix1[0] - pix2[0]];
300         s += sq[pix1[1] - pix2[1]];
301         s += sq[pix1[2] - pix2[2]];
302         s += sq[pix1[3] - pix2[3]];
303         s += sq[pix1[4] - pix2[4]];
304         s += sq[pix1[5] - pix2[5]];
305         s += sq[pix1[6] - pix2[6]];
306         s += sq[pix1[7] - pix2[7]];
307         pix1 += line_size;
308         pix2 += line_size;
309     }
310     return s;
311 }
312
313 static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
314 {
315     int s, i;
316     uint32_t *sq = ff_squareTbl + 256;
317
318     s = 0;
319     for (i = 0; i < h; i++) {
320         s += sq[pix1[ 0] - pix2[ 0]];
321         s += sq[pix1[ 1] - pix2[ 1]];
322         s += sq[pix1[ 2] - pix2[ 2]];
323         s += sq[pix1[ 3] - pix2[ 3]];
324         s += sq[pix1[ 4] - pix2[ 4]];
325         s += sq[pix1[ 5] - pix2[ 5]];
326         s += sq[pix1[ 6] - pix2[ 6]];
327         s += sq[pix1[ 7] - pix2[ 7]];
328         s += sq[pix1[ 8] - pix2[ 8]];
329         s += sq[pix1[ 9] - pix2[ 9]];
330         s += sq[pix1[10] - pix2[10]];
331         s += sq[pix1[11] - pix2[11]];
332         s += sq[pix1[12] - pix2[12]];
333         s += sq[pix1[13] - pix2[13]];
334         s += sq[pix1[14] - pix2[14]];
335         s += sq[pix1[15] - pix2[15]];
336
337         pix1 += line_size;
338         pix2 += line_size;
339     }
340     return s;
341 }
342
343
344 #if CONFIG_SNOW_ENCODER //dwt is in snow.c
345 static inline int w_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int w, int h, int type){
346     int s, i, j;
347     const int dec_count= w==8 ? 3 : 4;
348     int tmp[32*32];
349     int level, ori;
350     static const int scale[2][2][4][4]={
351       {
352         {
353             // 9/7 8x8 dec=3
354             {268, 239, 239, 213},
355             {  0, 224, 224, 152},
356             {  0, 135, 135, 110},
357         },{
358             // 9/7 16x16 or 32x32 dec=4
359             {344, 310, 310, 280},
360             {  0, 320, 320, 228},
361             {  0, 175, 175, 136},
362             {  0, 129, 129, 102},
363         }
364       },{
365         {
366             // 5/3 8x8 dec=3
367             {275, 245, 245, 218},
368             {  0, 230, 230, 156},
369             {  0, 138, 138, 113},
370         },{
371             // 5/3 16x16 or 32x32 dec=4
372             {352, 317, 317, 286},
373             {  0, 328, 328, 233},
374             {  0, 180, 180, 140},
375             {  0, 132, 132, 105},
376         }
377       }
378     };
379
380     for (i = 0; i < h; i++) {
381         for (j = 0; j < w; j+=4) {
382             tmp[32*i+j+0] = (pix1[j+0] - pix2[j+0])<<4;
383             tmp[32*i+j+1] = (pix1[j+1] - pix2[j+1])<<4;
384             tmp[32*i+j+2] = (pix1[j+2] - pix2[j+2])<<4;
385             tmp[32*i+j+3] = (pix1[j+3] - pix2[j+3])<<4;
386         }
387         pix1 += line_size;
388         pix2 += line_size;
389     }
390
391     ff_spatial_dwt(tmp, w, h, 32, type, dec_count);
392
393     s=0;
394     assert(w==h);
395     for(level=0; level<dec_count; level++){
396         for(ori= level ? 1 : 0; ori<4; ori++){
397             int size= w>>(dec_count-level);
398             int sx= (ori&1) ? size : 0;
399             int stride= 32<<(dec_count-level);
400             int sy= (ori&2) ? stride>>1 : 0;
401
402             for(i=0; i<size; i++){
403                 for(j=0; j<size; j++){
404                     int v= tmp[sx + sy + i*stride + j] * scale[type][dec_count-3][level][ori];
405                     s += FFABS(v);
406                 }
407             }
408         }
409     }
410     assert(s>=0);
411     return s>>9;
412 }
413
414 static int w53_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
415     return w_c(v, pix1, pix2, line_size,  8, h, 1);
416 }
417
418 static int w97_8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
419     return w_c(v, pix1, pix2, line_size,  8, h, 0);
420 }
421
422 static int w53_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
423     return w_c(v, pix1, pix2, line_size, 16, h, 1);
424 }
425
426 static int w97_16_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
427     return w_c(v, pix1, pix2, line_size, 16, h, 0);
428 }
429
430 int w53_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
431     return w_c(v, pix1, pix2, line_size, 32, h, 1);
432 }
433
434 int w97_32_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h){
435     return w_c(v, pix1, pix2, line_size, 32, h, 0);
436 }
437 #endif
438
439 /* draw the edges of width 'w' of an image of size width, height */
440 //FIXME check that this is ok for mpeg4 interlaced
441 static void draw_edges_c(uint8_t *buf, int wrap, int width, int height, int w)
442 {
443     uint8_t *ptr, *last_line;
444     int i;
445
446     last_line = buf + (height - 1) * wrap;
447     for(i=0;i<w;i++) {
448         /* top and bottom */
449         memcpy(buf - (i + 1) * wrap, buf, width);
450         memcpy(last_line + (i + 1) * wrap, last_line, width);
451     }
452     /* left and right */
453     ptr = buf;
454     for(i=0;i<height;i++) {
455         memset(ptr - w, ptr[0], w);
456         memset(ptr + width, ptr[width-1], w);
457         ptr += wrap;
458     }
459     /* corners */
460     for(i=0;i<w;i++) {
461         memset(buf - (i + 1) * wrap - w, buf[0], w); /* top left */
462         memset(buf - (i + 1) * wrap + width, buf[width-1], w); /* top right */
463         memset(last_line + (i + 1) * wrap - w, last_line[0], w); /* top left */
464         memset(last_line + (i + 1) * wrap + width, last_line[width-1], w); /* top right */
465     }
466 }
467
468 /**
469  * Copies a rectangular area of samples to a temporary buffer and replicates the boarder samples.
470  * @param buf destination buffer
471  * @param src source buffer
472  * @param linesize number of bytes between 2 vertically adjacent samples in both the source and destination buffers
473  * @param block_w width of block
474  * @param block_h height of block
475  * @param src_x x coordinate of the top left sample of the block in the source buffer
476  * @param src_y y coordinate of the top left sample of the block in the source buffer
477  * @param w width of the source buffer
478  * @param h height of the source buffer
479  */
480 void ff_emulated_edge_mc(uint8_t *buf, uint8_t *src, int linesize, int block_w, int block_h,
481                                     int src_x, int src_y, int w, int h){
482     int x, y;
483     int start_y, start_x, end_y, end_x;
484
485     if(src_y>= h){
486         src+= (h-1-src_y)*linesize;
487         src_y=h-1;
488     }else if(src_y<=-block_h){
489         src+= (1-block_h-src_y)*linesize;
490         src_y=1-block_h;
491     }
492     if(src_x>= w){
493         src+= (w-1-src_x);
494         src_x=w-1;
495     }else if(src_x<=-block_w){
496         src+= (1-block_w-src_x);
497         src_x=1-block_w;
498     }
499
500     start_y= FFMAX(0, -src_y);
501     start_x= FFMAX(0, -src_x);
502     end_y= FFMIN(block_h, h-src_y);
503     end_x= FFMIN(block_w, w-src_x);
504
505     // copy existing part
506     for(y=start_y; y<end_y; y++){
507         for(x=start_x; x<end_x; x++){
508             buf[x + y*linesize]= src[x + y*linesize];
509         }
510     }
511
512     //top
513     for(y=0; y<start_y; y++){
514         for(x=start_x; x<end_x; x++){
515             buf[x + y*linesize]= buf[x + start_y*linesize];
516         }
517     }
518
519     //bottom
520     for(y=end_y; y<block_h; y++){
521         for(x=start_x; x<end_x; x++){
522             buf[x + y*linesize]= buf[x + (end_y-1)*linesize];
523         }
524     }
525
526     for(y=0; y<block_h; y++){
527        //left
528         for(x=0; x<start_x; x++){
529             buf[x + y*linesize]= buf[start_x + y*linesize];
530         }
531
532        //right
533         for(x=end_x; x<block_w; x++){
534             buf[x + y*linesize]= buf[end_x - 1 + y*linesize];
535         }
536     }
537 }
538
539 static void get_pixels_c(DCTELEM *restrict block, const uint8_t *pixels, int line_size)
540 {
541     int i;
542
543     /* read the pixels */
544     for(i=0;i<8;i++) {
545         block[0] = pixels[0];
546         block[1] = pixels[1];
547         block[2] = pixels[2];
548         block[3] = pixels[3];
549         block[4] = pixels[4];
550         block[5] = pixels[5];
551         block[6] = pixels[6];
552         block[7] = pixels[7];
553         pixels += line_size;
554         block += 8;
555     }
556 }
557
558 static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
559                           const uint8_t *s2, int stride){
560     int i;
561
562     /* read the pixels */
563     for(i=0;i<8;i++) {
564         block[0] = s1[0] - s2[0];
565         block[1] = s1[1] - s2[1];
566         block[2] = s1[2] - s2[2];
567         block[3] = s1[3] - s2[3];
568         block[4] = s1[4] - s2[4];
569         block[5] = s1[5] - s2[5];
570         block[6] = s1[6] - s2[6];
571         block[7] = s1[7] - s2[7];
572         s1 += stride;
573         s2 += stride;
574         block += 8;
575     }
576 }
577
578
579 static void put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
580                                  int line_size)
581 {
582     int i;
583     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
584
585     /* read the pixels */
586     for(i=0;i<8;i++) {
587         pixels[0] = cm[block[0]];
588         pixels[1] = cm[block[1]];
589         pixels[2] = cm[block[2]];
590         pixels[3] = cm[block[3]];
591         pixels[4] = cm[block[4]];
592         pixels[5] = cm[block[5]];
593         pixels[6] = cm[block[6]];
594         pixels[7] = cm[block[7]];
595
596         pixels += line_size;
597         block += 8;
598     }
599 }
600
601 static void put_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
602                                  int line_size)
603 {
604     int i;
605     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
606
607     /* read the pixels */
608     for(i=0;i<4;i++) {
609         pixels[0] = cm[block[0]];
610         pixels[1] = cm[block[1]];
611         pixels[2] = cm[block[2]];
612         pixels[3] = cm[block[3]];
613
614         pixels += line_size;
615         block += 8;
616     }
617 }
618
619 static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
620                                  int line_size)
621 {
622     int i;
623     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
624
625     /* read the pixels */
626     for(i=0;i<2;i++) {
627         pixels[0] = cm[block[0]];
628         pixels[1] = cm[block[1]];
629
630         pixels += line_size;
631         block += 8;
632     }
633 }
634
635 static void put_signed_pixels_clamped_c(const DCTELEM *block,
636                                         uint8_t *restrict pixels,
637                                         int line_size)
638 {
639     int i, j;
640
641     for (i = 0; i < 8; i++) {
642         for (j = 0; j < 8; j++) {
643             if (*block < -128)
644                 *pixels = 0;
645             else if (*block > 127)
646                 *pixels = 255;
647             else
648                 *pixels = (uint8_t)(*block + 128);
649             block++;
650             pixels++;
651         }
652         pixels += (line_size - 8);
653     }
654 }
655
656 static void add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
657                           int line_size)
658 {
659     int i;
660     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
661
662     /* read the pixels */
663     for(i=0;i<8;i++) {
664         pixels[0] = cm[pixels[0] + block[0]];
665         pixels[1] = cm[pixels[1] + block[1]];
666         pixels[2] = cm[pixels[2] + block[2]];
667         pixels[3] = cm[pixels[3] + block[3]];
668         pixels[4] = cm[pixels[4] + block[4]];
669         pixels[5] = cm[pixels[5] + block[5]];
670         pixels[6] = cm[pixels[6] + block[6]];
671         pixels[7] = cm[pixels[7] + block[7]];
672         pixels += line_size;
673         block += 8;
674     }
675 }
676
677 static void add_pixels_clamped4_c(const DCTELEM *block, uint8_t *restrict pixels,
678                           int line_size)
679 {
680     int i;
681     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
682
683     /* read the pixels */
684     for(i=0;i<4;i++) {
685         pixels[0] = cm[pixels[0] + block[0]];
686         pixels[1] = cm[pixels[1] + block[1]];
687         pixels[2] = cm[pixels[2] + block[2]];
688         pixels[3] = cm[pixels[3] + block[3]];
689         pixels += line_size;
690         block += 8;
691     }
692 }
693
694 static void add_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
695                           int line_size)
696 {
697     int i;
698     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
699
700     /* read the pixels */
701     for(i=0;i<2;i++) {
702         pixels[0] = cm[pixels[0] + block[0]];
703         pixels[1] = cm[pixels[1] + block[1]];
704         pixels += line_size;
705         block += 8;
706     }
707 }
708
709 static void add_pixels8_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)
710 {
711     int i;
712     for(i=0;i<8;i++) {
713         pixels[0] += block[0];
714         pixels[1] += block[1];
715         pixels[2] += block[2];
716         pixels[3] += block[3];
717         pixels[4] += block[4];
718         pixels[5] += block[5];
719         pixels[6] += block[6];
720         pixels[7] += block[7];
721         pixels += line_size;
722         block += 8;
723     }
724 }
725
726 static void add_pixels4_c(uint8_t *restrict pixels, DCTELEM *block, int line_size)
727 {
728     int i;
729     for(i=0;i<4;i++) {
730         pixels[0] += block[0];
731         pixels[1] += block[1];
732         pixels[2] += block[2];
733         pixels[3] += block[3];
734         pixels += line_size;
735         block += 4;
736     }
737 }
738
739 static int sum_abs_dctelem_c(DCTELEM *block)
740 {
741     int sum=0, i;
742     for(i=0; i<64; i++)
743         sum+= FFABS(block[i]);
744     return sum;
745 }
746
747 #if 0
748
749 #define PIXOP2(OPNAME, OP) \
750 static void OPNAME ## _pixels(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
751 {\
752     int i;\
753     for(i=0; i<h; i++){\
754         OP(*((uint64_t*)block), AV_RN64(pixels));\
755         pixels+=line_size;\
756         block +=line_size;\
757     }\
758 }\
759 \
760 static void OPNAME ## _no_rnd_pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
761 {\
762     int i;\
763     for(i=0; i<h; i++){\
764         const uint64_t a= AV_RN64(pixels  );\
765         const uint64_t b= AV_RN64(pixels+1);\
766         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
767         pixels+=line_size;\
768         block +=line_size;\
769     }\
770 }\
771 \
772 static void OPNAME ## _pixels_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
773 {\
774     int i;\
775     for(i=0; i<h; i++){\
776         const uint64_t a= AV_RN64(pixels  );\
777         const uint64_t b= AV_RN64(pixels+1);\
778         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
779         pixels+=line_size;\
780         block +=line_size;\
781     }\
782 }\
783 \
784 static void OPNAME ## _no_rnd_pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
785 {\
786     int i;\
787     for(i=0; i<h; i++){\
788         const uint64_t a= AV_RN64(pixels          );\
789         const uint64_t b= AV_RN64(pixels+line_size);\
790         OP(*((uint64_t*)block), (a&b) + (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
791         pixels+=line_size;\
792         block +=line_size;\
793     }\
794 }\
795 \
796 static void OPNAME ## _pixels_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
797 {\
798     int i;\
799     for(i=0; i<h; i++){\
800         const uint64_t a= AV_RN64(pixels          );\
801         const uint64_t b= AV_RN64(pixels+line_size);\
802         OP(*((uint64_t*)block), (a|b) - (((a^b)&0xFEFEFEFEFEFEFEFEULL)>>1));\
803         pixels+=line_size;\
804         block +=line_size;\
805     }\
806 }\
807 \
808 static void OPNAME ## _pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
809 {\
810         int i;\
811         const uint64_t a= AV_RN64(pixels  );\
812         const uint64_t b= AV_RN64(pixels+1);\
813         uint64_t l0=  (a&0x0303030303030303ULL)\
814                     + (b&0x0303030303030303ULL)\
815                     + 0x0202020202020202ULL;\
816         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
817                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
818         uint64_t l1,h1;\
819 \
820         pixels+=line_size;\
821         for(i=0; i<h; i+=2){\
822             uint64_t a= AV_RN64(pixels  );\
823             uint64_t b= AV_RN64(pixels+1);\
824             l1=  (a&0x0303030303030303ULL)\
825                + (b&0x0303030303030303ULL);\
826             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
827               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
828             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
829             pixels+=line_size;\
830             block +=line_size;\
831             a= AV_RN64(pixels  );\
832             b= AV_RN64(pixels+1);\
833             l0=  (a&0x0303030303030303ULL)\
834                + (b&0x0303030303030303ULL)\
835                + 0x0202020202020202ULL;\
836             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
837               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
838             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
839             pixels+=line_size;\
840             block +=line_size;\
841         }\
842 }\
843 \
844 static void OPNAME ## _no_rnd_pixels_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
845 {\
846         int i;\
847         const uint64_t a= AV_RN64(pixels  );\
848         const uint64_t b= AV_RN64(pixels+1);\
849         uint64_t l0=  (a&0x0303030303030303ULL)\
850                     + (b&0x0303030303030303ULL)\
851                     + 0x0101010101010101ULL;\
852         uint64_t h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
853                    + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
854         uint64_t l1,h1;\
855 \
856         pixels+=line_size;\
857         for(i=0; i<h; i+=2){\
858             uint64_t a= AV_RN64(pixels  );\
859             uint64_t b= AV_RN64(pixels+1);\
860             l1=  (a&0x0303030303030303ULL)\
861                + (b&0x0303030303030303ULL);\
862             h1= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
863               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
864             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
865             pixels+=line_size;\
866             block +=line_size;\
867             a= AV_RN64(pixels  );\
868             b= AV_RN64(pixels+1);\
869             l0=  (a&0x0303030303030303ULL)\
870                + (b&0x0303030303030303ULL)\
871                + 0x0101010101010101ULL;\
872             h0= ((a&0xFCFCFCFCFCFCFCFCULL)>>2)\
873               + ((b&0xFCFCFCFCFCFCFCFCULL)>>2);\
874             OP(*((uint64_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0F0F0F0F0FULL));\
875             pixels+=line_size;\
876             block +=line_size;\
877         }\
878 }\
879 \
880 CALL_2X_PIXELS(OPNAME ## _pixels16_c    , OPNAME ## _pixels_c    , 8)\
881 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels_x2_c , 8)\
882 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels_y2_c , 8)\
883 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels_xy2_c, 8)\
884 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels_x2_c , 8)\
885 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels_y2_c , 8)\
886 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels_xy2_c, 8)
887
888 #define op_avg(a, b) a = ( ((a)|(b)) - ((((a)^(b))&0xFEFEFEFEFEFEFEFEULL)>>1) )
889 #else // 64 bit variant
890
891 #define PIXOP2(OPNAME, OP) \
892 static void OPNAME ## _pixels2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
893     int i;\
894     for(i=0; i<h; i++){\
895         OP(*((uint16_t*)(block  )), AV_RN16(pixels  ));\
896         pixels+=line_size;\
897         block +=line_size;\
898     }\
899 }\
900 static void OPNAME ## _pixels4_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
901     int i;\
902     for(i=0; i<h; i++){\
903         OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\
904         pixels+=line_size;\
905         block +=line_size;\
906     }\
907 }\
908 static void OPNAME ## _pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
909     int i;\
910     for(i=0; i<h; i++){\
911         OP(*((uint32_t*)(block  )), AV_RN32(pixels  ));\
912         OP(*((uint32_t*)(block+4)), AV_RN32(pixels+4));\
913         pixels+=line_size;\
914         block +=line_size;\
915     }\
916 }\
917 static inline void OPNAME ## _no_rnd_pixels8_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
918     OPNAME ## _pixels8_c(block, pixels, line_size, h);\
919 }\
920 \
921 static inline void OPNAME ## _no_rnd_pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
922                                                 int src_stride1, int src_stride2, int h){\
923     int i;\
924     for(i=0; i<h; i++){\
925         uint32_t a,b;\
926         a= AV_RN32(&src1[i*src_stride1  ]);\
927         b= AV_RN32(&src2[i*src_stride2  ]);\
928         OP(*((uint32_t*)&dst[i*dst_stride  ]), no_rnd_avg32(a, b));\
929         a= AV_RN32(&src1[i*src_stride1+4]);\
930         b= AV_RN32(&src2[i*src_stride2+4]);\
931         OP(*((uint32_t*)&dst[i*dst_stride+4]), no_rnd_avg32(a, b));\
932     }\
933 }\
934 \
935 static inline void OPNAME ## _pixels8_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
936                                                 int src_stride1, int src_stride2, int h){\
937     int i;\
938     for(i=0; i<h; i++){\
939         uint32_t a,b;\
940         a= AV_RN32(&src1[i*src_stride1  ]);\
941         b= AV_RN32(&src2[i*src_stride2  ]);\
942         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
943         a= AV_RN32(&src1[i*src_stride1+4]);\
944         b= AV_RN32(&src2[i*src_stride2+4]);\
945         OP(*((uint32_t*)&dst[i*dst_stride+4]), rnd_avg32(a, b));\
946     }\
947 }\
948 \
949 static inline void OPNAME ## _pixels4_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
950                                                 int src_stride1, int src_stride2, int h){\
951     int i;\
952     for(i=0; i<h; i++){\
953         uint32_t a,b;\
954         a= AV_RN32(&src1[i*src_stride1  ]);\
955         b= AV_RN32(&src2[i*src_stride2  ]);\
956         OP(*((uint32_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
957     }\
958 }\
959 \
960 static inline void OPNAME ## _pixels2_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
961                                                 int src_stride1, int src_stride2, int h){\
962     int i;\
963     for(i=0; i<h; i++){\
964         uint32_t a,b;\
965         a= AV_RN16(&src1[i*src_stride1  ]);\
966         b= AV_RN16(&src2[i*src_stride2  ]);\
967         OP(*((uint16_t*)&dst[i*dst_stride  ]), rnd_avg32(a, b));\
968     }\
969 }\
970 \
971 static inline void OPNAME ## _pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
972                                                 int src_stride1, int src_stride2, int h){\
973     OPNAME ## _pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
974     OPNAME ## _pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
975 }\
976 \
977 static inline void OPNAME ## _no_rnd_pixels16_l2(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int dst_stride, \
978                                                 int src_stride1, int src_stride2, int h){\
979     OPNAME ## _no_rnd_pixels8_l2(dst  , src1  , src2  , dst_stride, src_stride1, src_stride2, h);\
980     OPNAME ## _no_rnd_pixels8_l2(dst+8, src1+8, src2+8, dst_stride, src_stride1, src_stride2, h);\
981 }\
982 \
983 static inline void OPNAME ## _no_rnd_pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
984     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
985 }\
986 \
987 static inline void OPNAME ## _pixels8_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
988     OPNAME ## _pixels8_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
989 }\
990 \
991 static inline void OPNAME ## _no_rnd_pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
992     OPNAME ## _no_rnd_pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
993 }\
994 \
995 static inline void OPNAME ## _pixels8_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
996     OPNAME ## _pixels8_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
997 }\
998 \
999 static inline void OPNAME ## _pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1000                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1001     int i;\
1002     for(i=0; i<h; i++){\
1003         uint32_t a, b, c, d, l0, l1, h0, h1;\
1004         a= AV_RN32(&src1[i*src_stride1]);\
1005         b= AV_RN32(&src2[i*src_stride2]);\
1006         c= AV_RN32(&src3[i*src_stride3]);\
1007         d= AV_RN32(&src4[i*src_stride4]);\
1008         l0=  (a&0x03030303UL)\
1009            + (b&0x03030303UL)\
1010            + 0x02020202UL;\
1011         h0= ((a&0xFCFCFCFCUL)>>2)\
1012           + ((b&0xFCFCFCFCUL)>>2);\
1013         l1=  (c&0x03030303UL)\
1014            + (d&0x03030303UL);\
1015         h1= ((c&0xFCFCFCFCUL)>>2)\
1016           + ((d&0xFCFCFCFCUL)>>2);\
1017         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1018         a= AV_RN32(&src1[i*src_stride1+4]);\
1019         b= AV_RN32(&src2[i*src_stride2+4]);\
1020         c= AV_RN32(&src3[i*src_stride3+4]);\
1021         d= AV_RN32(&src4[i*src_stride4+4]);\
1022         l0=  (a&0x03030303UL)\
1023            + (b&0x03030303UL)\
1024            + 0x02020202UL;\
1025         h0= ((a&0xFCFCFCFCUL)>>2)\
1026           + ((b&0xFCFCFCFCUL)>>2);\
1027         l1=  (c&0x03030303UL)\
1028            + (d&0x03030303UL);\
1029         h1= ((c&0xFCFCFCFCUL)>>2)\
1030           + ((d&0xFCFCFCFCUL)>>2);\
1031         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1032     }\
1033 }\
1034 \
1035 static inline void OPNAME ## _pixels4_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
1036     OPNAME ## _pixels4_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
1037 }\
1038 \
1039 static inline void OPNAME ## _pixels4_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
1040     OPNAME ## _pixels4_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
1041 }\
1042 \
1043 static inline void OPNAME ## _pixels2_x2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
1044     OPNAME ## _pixels2_l2(block, pixels, pixels+1, line_size, line_size, line_size, h);\
1045 }\
1046 \
1047 static inline void OPNAME ## _pixels2_y2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h){\
1048     OPNAME ## _pixels2_l2(block, pixels, pixels+line_size, line_size, line_size, line_size, h);\
1049 }\
1050 \
1051 static inline void OPNAME ## _no_rnd_pixels8_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1052                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1053     int i;\
1054     for(i=0; i<h; i++){\
1055         uint32_t a, b, c, d, l0, l1, h0, h1;\
1056         a= AV_RN32(&src1[i*src_stride1]);\
1057         b= AV_RN32(&src2[i*src_stride2]);\
1058         c= AV_RN32(&src3[i*src_stride3]);\
1059         d= AV_RN32(&src4[i*src_stride4]);\
1060         l0=  (a&0x03030303UL)\
1061            + (b&0x03030303UL)\
1062            + 0x01010101UL;\
1063         h0= ((a&0xFCFCFCFCUL)>>2)\
1064           + ((b&0xFCFCFCFCUL)>>2);\
1065         l1=  (c&0x03030303UL)\
1066            + (d&0x03030303UL);\
1067         h1= ((c&0xFCFCFCFCUL)>>2)\
1068           + ((d&0xFCFCFCFCUL)>>2);\
1069         OP(*((uint32_t*)&dst[i*dst_stride]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1070         a= AV_RN32(&src1[i*src_stride1+4]);\
1071         b= AV_RN32(&src2[i*src_stride2+4]);\
1072         c= AV_RN32(&src3[i*src_stride3+4]);\
1073         d= AV_RN32(&src4[i*src_stride4+4]);\
1074         l0=  (a&0x03030303UL)\
1075            + (b&0x03030303UL)\
1076            + 0x01010101UL;\
1077         h0= ((a&0xFCFCFCFCUL)>>2)\
1078           + ((b&0xFCFCFCFCUL)>>2);\
1079         l1=  (c&0x03030303UL)\
1080            + (d&0x03030303UL);\
1081         h1= ((c&0xFCFCFCFCUL)>>2)\
1082           + ((d&0xFCFCFCFCUL)>>2);\
1083         OP(*((uint32_t*)&dst[i*dst_stride+4]), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1084     }\
1085 }\
1086 static inline void OPNAME ## _pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1087                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1088     OPNAME ## _pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1089     OPNAME ## _pixels8_l4(dst+8, src1+8, src2+8, src3+8, src4+8, dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1090 }\
1091 static inline void OPNAME ## _no_rnd_pixels16_l4(uint8_t *dst, const uint8_t *src1, uint8_t *src2, uint8_t *src3, uint8_t *src4,\
1092                  int dst_stride, int src_stride1, int src_stride2,int src_stride3,int src_stride4, int h){\
1093     OPNAME ## _no_rnd_pixels8_l4(dst  , src1  , src2  , src3  , src4  , dst_stride, src_stride1, src_stride2, src_stride3, src_stride4, h);\
1094     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);\
1095 }\
1096 \
1097 static inline void OPNAME ## _pixels2_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1098 {\
1099         int i, a0, b0, a1, b1;\
1100         a0= pixels[0];\
1101         b0= pixels[1] + 2;\
1102         a0 += b0;\
1103         b0 += pixels[2];\
1104 \
1105         pixels+=line_size;\
1106         for(i=0; i<h; i+=2){\
1107             a1= pixels[0];\
1108             b1= pixels[1];\
1109             a1 += b1;\
1110             b1 += pixels[2];\
1111 \
1112             block[0]= (a1+a0)>>2; /* FIXME non put */\
1113             block[1]= (b1+b0)>>2;\
1114 \
1115             pixels+=line_size;\
1116             block +=line_size;\
1117 \
1118             a0= pixels[0];\
1119             b0= pixels[1] + 2;\
1120             a0 += b0;\
1121             b0 += pixels[2];\
1122 \
1123             block[0]= (a1+a0)>>2;\
1124             block[1]= (b1+b0)>>2;\
1125             pixels+=line_size;\
1126             block +=line_size;\
1127         }\
1128 }\
1129 \
1130 static inline void OPNAME ## _pixels4_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1131 {\
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                     + 0x02020202UL;\
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                + 0x02020202UL;\
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 }\
1165 \
1166 static inline void OPNAME ## _pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1167 {\
1168     int j;\
1169     for(j=0; j<2; j++){\
1170         int i;\
1171         const uint32_t a= AV_RN32(pixels  );\
1172         const uint32_t b= AV_RN32(pixels+1);\
1173         uint32_t l0=  (a&0x03030303UL)\
1174                     + (b&0x03030303UL)\
1175                     + 0x02020202UL;\
1176         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1177                    + ((b&0xFCFCFCFCUL)>>2);\
1178         uint32_t l1,h1;\
1179 \
1180         pixels+=line_size;\
1181         for(i=0; i<h; i+=2){\
1182             uint32_t a= AV_RN32(pixels  );\
1183             uint32_t b= AV_RN32(pixels+1);\
1184             l1=  (a&0x03030303UL)\
1185                + (b&0x03030303UL);\
1186             h1= ((a&0xFCFCFCFCUL)>>2)\
1187               + ((b&0xFCFCFCFCUL)>>2);\
1188             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1189             pixels+=line_size;\
1190             block +=line_size;\
1191             a= AV_RN32(pixels  );\
1192             b= AV_RN32(pixels+1);\
1193             l0=  (a&0x03030303UL)\
1194                + (b&0x03030303UL)\
1195                + 0x02020202UL;\
1196             h0= ((a&0xFCFCFCFCUL)>>2)\
1197               + ((b&0xFCFCFCFCUL)>>2);\
1198             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1199             pixels+=line_size;\
1200             block +=line_size;\
1201         }\
1202         pixels+=4-line_size*(h+1);\
1203         block +=4-line_size*h;\
1204     }\
1205 }\
1206 \
1207 static inline void OPNAME ## _no_rnd_pixels8_xy2_c(uint8_t *block, const uint8_t *pixels, int line_size, int h)\
1208 {\
1209     int j;\
1210     for(j=0; j<2; j++){\
1211         int i;\
1212         const uint32_t a= AV_RN32(pixels  );\
1213         const uint32_t b= AV_RN32(pixels+1);\
1214         uint32_t l0=  (a&0x03030303UL)\
1215                     + (b&0x03030303UL)\
1216                     + 0x01010101UL;\
1217         uint32_t h0= ((a&0xFCFCFCFCUL)>>2)\
1218                    + ((b&0xFCFCFCFCUL)>>2);\
1219         uint32_t l1,h1;\
1220 \
1221         pixels+=line_size;\
1222         for(i=0; i<h; i+=2){\
1223             uint32_t a= AV_RN32(pixels  );\
1224             uint32_t b= AV_RN32(pixels+1);\
1225             l1=  (a&0x03030303UL)\
1226                + (b&0x03030303UL);\
1227             h1= ((a&0xFCFCFCFCUL)>>2)\
1228               + ((b&0xFCFCFCFCUL)>>2);\
1229             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1230             pixels+=line_size;\
1231             block +=line_size;\
1232             a= AV_RN32(pixels  );\
1233             b= AV_RN32(pixels+1);\
1234             l0=  (a&0x03030303UL)\
1235                + (b&0x03030303UL)\
1236                + 0x01010101UL;\
1237             h0= ((a&0xFCFCFCFCUL)>>2)\
1238               + ((b&0xFCFCFCFCUL)>>2);\
1239             OP(*((uint32_t*)block), h0+h1+(((l0+l1)>>2)&0x0F0F0F0FUL));\
1240             pixels+=line_size;\
1241             block +=line_size;\
1242         }\
1243         pixels+=4-line_size*(h+1);\
1244         block +=4-line_size*h;\
1245     }\
1246 }\
1247 \
1248 CALL_2X_PIXELS(OPNAME ## _pixels16_c  , OPNAME ## _pixels8_c  , 8)\
1249 CALL_2X_PIXELS(OPNAME ## _pixels16_x2_c , OPNAME ## _pixels8_x2_c , 8)\
1250 CALL_2X_PIXELS(OPNAME ## _pixels16_y2_c , OPNAME ## _pixels8_y2_c , 8)\
1251 CALL_2X_PIXELS(OPNAME ## _pixels16_xy2_c, OPNAME ## _pixels8_xy2_c, 8)\
1252 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_c  , OPNAME ## _pixels8_c         , 8)\
1253 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_x2_c , OPNAME ## _no_rnd_pixels8_x2_c , 8)\
1254 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_y2_c , OPNAME ## _no_rnd_pixels8_y2_c , 8)\
1255 CALL_2X_PIXELS(OPNAME ## _no_rnd_pixels16_xy2_c, OPNAME ## _no_rnd_pixels8_xy2_c, 8)\
1256
1257 #define op_avg(a, b) a = rnd_avg32(a, b)
1258 #endif
1259 #define op_put(a, b) a = b
1260
1261 PIXOP2(avg, op_avg)
1262 PIXOP2(put, op_put)
1263 #undef op_avg
1264 #undef op_put
1265
1266 #define avg2(a,b) ((a+b+1)>>1)
1267 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
1268
1269 static void put_no_rnd_pixels16_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
1270     put_no_rnd_pixels16_l2(dst, a, b, stride, stride, stride, h);
1271 }
1272
1273 static void put_no_rnd_pixels8_l2_c(uint8_t *dst, const uint8_t *a, const uint8_t *b, int stride, int h){
1274     put_no_rnd_pixels8_l2(dst, a, b, stride, stride, stride, h);
1275 }
1276
1277 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
1278 {
1279     const int A=(16-x16)*(16-y16);
1280     const int B=(   x16)*(16-y16);
1281     const int C=(16-x16)*(   y16);
1282     const int D=(   x16)*(   y16);
1283     int i;
1284
1285     for(i=0; i<h; i++)
1286     {
1287         dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
1288         dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
1289         dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
1290         dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
1291         dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
1292         dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
1293         dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
1294         dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
1295         dst+= stride;
1296         src+= stride;
1297     }
1298 }
1299
1300 void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
1301                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
1302 {
1303     int y, vx, vy;
1304     const int s= 1<<shift;
1305
1306     width--;
1307     height--;
1308
1309     for(y=0; y<h; y++){
1310         int x;
1311
1312         vx= ox;
1313         vy= oy;
1314         for(x=0; x<8; x++){ //XXX FIXME optimize
1315             int src_x, src_y, frac_x, frac_y, index;
1316
1317             src_x= vx>>16;
1318             src_y= vy>>16;
1319             frac_x= src_x&(s-1);
1320             frac_y= src_y&(s-1);
1321             src_x>>=shift;
1322             src_y>>=shift;
1323
1324             if((unsigned)src_x < width){
1325                 if((unsigned)src_y < height){
1326                     index= src_x + src_y*stride;
1327                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
1328                                            + src[index       +1]*   frac_x )*(s-frac_y)
1329                                         + (  src[index+stride  ]*(s-frac_x)
1330                                            + src[index+stride+1]*   frac_x )*   frac_y
1331                                         + r)>>(shift*2);
1332                 }else{
1333                     index= src_x + av_clip(src_y, 0, height)*stride;
1334                     dst[y*stride + x]= ( (  src[index         ]*(s-frac_x)
1335                                           + src[index       +1]*   frac_x )*s
1336                                         + r)>>(shift*2);
1337                 }
1338             }else{
1339                 if((unsigned)src_y < height){
1340                     index= av_clip(src_x, 0, width) + src_y*stride;
1341                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_y)
1342                                            + src[index+stride  ]*   frac_y )*s
1343                                         + r)>>(shift*2);
1344                 }else{
1345                     index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
1346                     dst[y*stride + x]=    src[index         ];
1347                 }
1348             }
1349
1350             vx+= dxx;
1351             vy+= dyx;
1352         }
1353         ox += dxy;
1354         oy += dyy;
1355     }
1356 }
1357
1358 static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1359     switch(width){
1360     case 2: put_pixels2_c (dst, src, stride, height); break;
1361     case 4: put_pixels4_c (dst, src, stride, height); break;
1362     case 8: put_pixels8_c (dst, src, stride, height); break;
1363     case 16:put_pixels16_c(dst, src, stride, height); break;
1364     }
1365 }
1366
1367 static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1368     int i,j;
1369     for (i=0; i < height; i++) {
1370       for (j=0; j < width; j++) {
1371         dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
1372       }
1373       src += stride;
1374       dst += stride;
1375     }
1376 }
1377
1378 static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1379     int i,j;
1380     for (i=0; i < height; i++) {
1381       for (j=0; j < width; j++) {
1382         dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
1383       }
1384       src += stride;
1385       dst += stride;
1386     }
1387 }
1388
1389 static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1390     int i,j;
1391     for (i=0; i < height; i++) {
1392       for (j=0; j < width; j++) {
1393         dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
1394       }
1395       src += stride;
1396       dst += stride;
1397     }
1398 }
1399
1400 static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1401     int i,j;
1402     for (i=0; i < height; i++) {
1403       for (j=0; j < width; j++) {
1404         dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
1405       }
1406       src += stride;
1407       dst += stride;
1408     }
1409 }
1410
1411 static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1412     int i,j;
1413     for (i=0; i < height; i++) {
1414       for (j=0; j < width; j++) {
1415         dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
1416       }
1417       src += stride;
1418       dst += stride;
1419     }
1420 }
1421
1422 static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1423     int i,j;
1424     for (i=0; i < height; i++) {
1425       for (j=0; j < width; j++) {
1426         dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
1427       }
1428       src += stride;
1429       dst += stride;
1430     }
1431 }
1432
1433 static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1434     int i,j;
1435     for (i=0; i < height; i++) {
1436       for (j=0; j < width; j++) {
1437         dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
1438       }
1439       src += stride;
1440       dst += stride;
1441     }
1442 }
1443
1444 static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1445     int i,j;
1446     for (i=0; i < height; i++) {
1447       for (j=0; j < width; j++) {
1448         dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
1449       }
1450       src += stride;
1451       dst += stride;
1452     }
1453 }
1454
1455 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1456     switch(width){
1457     case 2: avg_pixels2_c (dst, src, stride, height); break;
1458     case 4: avg_pixels4_c (dst, src, stride, height); break;
1459     case 8: avg_pixels8_c (dst, src, stride, height); break;
1460     case 16:avg_pixels16_c(dst, src, stride, height); break;
1461     }
1462 }
1463
1464 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1465     int i,j;
1466     for (i=0; i < height; i++) {
1467       for (j=0; j < width; j++) {
1468         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
1469       }
1470       src += stride;
1471       dst += stride;
1472     }
1473 }
1474
1475 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1476     int i,j;
1477     for (i=0; i < height; i++) {
1478       for (j=0; j < width; j++) {
1479         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
1480       }
1481       src += stride;
1482       dst += stride;
1483     }
1484 }
1485
1486 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1487     int i,j;
1488     for (i=0; i < height; i++) {
1489       for (j=0; j < width; j++) {
1490         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
1491       }
1492       src += stride;
1493       dst += stride;
1494     }
1495 }
1496
1497 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1498     int i,j;
1499     for (i=0; i < height; i++) {
1500       for (j=0; j < width; j++) {
1501         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;
1502       }
1503       src += stride;
1504       dst += stride;
1505     }
1506 }
1507
1508 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1509     int i,j;
1510     for (i=0; i < height; i++) {
1511       for (j=0; j < width; j++) {
1512         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;
1513       }
1514       src += stride;
1515       dst += stride;
1516     }
1517 }
1518
1519 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1520     int i,j;
1521     for (i=0; i < height; i++) {
1522       for (j=0; j < width; j++) {
1523         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
1524       }
1525       src += stride;
1526       dst += stride;
1527     }
1528 }
1529
1530 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1531     int i,j;
1532     for (i=0; i < height; i++) {
1533       for (j=0; j < width; j++) {
1534         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;
1535       }
1536       src += stride;
1537       dst += stride;
1538     }
1539 }
1540
1541 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
1542     int i,j;
1543     for (i=0; i < height; i++) {
1544       for (j=0; j < width; j++) {
1545         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;
1546       }
1547       src += stride;
1548       dst += stride;
1549     }
1550 }
1551 #if 0
1552 #define TPEL_WIDTH(width)\
1553 static void put_tpel_pixels ## width ## _mc00_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1554     void put_tpel_pixels_mc00_c(dst, src, stride, width, height);}\
1555 static void put_tpel_pixels ## width ## _mc10_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1556     void put_tpel_pixels_mc10_c(dst, src, stride, width, height);}\
1557 static void put_tpel_pixels ## width ## _mc20_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1558     void put_tpel_pixels_mc20_c(dst, src, stride, width, height);}\
1559 static void put_tpel_pixels ## width ## _mc01_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1560     void put_tpel_pixels_mc01_c(dst, src, stride, width, height);}\
1561 static void put_tpel_pixels ## width ## _mc11_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1562     void put_tpel_pixels_mc11_c(dst, src, stride, width, height);}\
1563 static void put_tpel_pixels ## width ## _mc21_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1564     void put_tpel_pixels_mc21_c(dst, src, stride, width, height);}\
1565 static void put_tpel_pixels ## width ## _mc02_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1566     void put_tpel_pixels_mc02_c(dst, src, stride, width, height);}\
1567 static void put_tpel_pixels ## width ## _mc12_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1568     void put_tpel_pixels_mc12_c(dst, src, stride, width, height);}\
1569 static void put_tpel_pixels ## width ## _mc22_c(uint8_t *dst, const uint8_t *src, int stride, int height){\
1570     void put_tpel_pixels_mc22_c(dst, src, stride, width, height);}
1571 #endif
1572
1573 #define H264_CHROMA_MC(OPNAME, OP)\
1574 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){\
1575     const int A=(8-x)*(8-y);\
1576     const int B=(  x)*(8-y);\
1577     const int C=(8-x)*(  y);\
1578     const int D=(  x)*(  y);\
1579     int i;\
1580     \
1581     assert(x<8 && y<8 && x>=0 && y>=0);\
1582 \
1583     if(D){\
1584         for(i=0; i<h; i++){\
1585             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1586             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1587             dst+= stride;\
1588             src+= stride;\
1589         }\
1590     }else{\
1591         const int E= B+C;\
1592         const int step= C ? stride : 1;\
1593         for(i=0; i<h; i++){\
1594             OP(dst[0], (A*src[0] + E*src[step+0]));\
1595             OP(dst[1], (A*src[1] + E*src[step+1]));\
1596             dst+= stride;\
1597             src+= stride;\
1598         }\
1599     }\
1600 }\
1601 \
1602 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){\
1603     const int A=(8-x)*(8-y);\
1604     const int B=(  x)*(8-y);\
1605     const int C=(8-x)*(  y);\
1606     const int D=(  x)*(  y);\
1607     int i;\
1608     \
1609     assert(x<8 && y<8 && x>=0 && y>=0);\
1610 \
1611     if(D){\
1612         for(i=0; i<h; i++){\
1613             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1614             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1615             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1616             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1617             dst+= stride;\
1618             src+= stride;\
1619         }\
1620     }else{\
1621         const int E= B+C;\
1622         const int step= C ? stride : 1;\
1623         for(i=0; i<h; i++){\
1624             OP(dst[0], (A*src[0] + E*src[step+0]));\
1625             OP(dst[1], (A*src[1] + E*src[step+1]));\
1626             OP(dst[2], (A*src[2] + E*src[step+2]));\
1627             OP(dst[3], (A*src[3] + E*src[step+3]));\
1628             dst+= stride;\
1629             src+= stride;\
1630         }\
1631     }\
1632 }\
1633 \
1634 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){\
1635     const int A=(8-x)*(8-y);\
1636     const int B=(  x)*(8-y);\
1637     const int C=(8-x)*(  y);\
1638     const int D=(  x)*(  y);\
1639     int i;\
1640     \
1641     assert(x<8 && y<8 && x>=0 && y>=0);\
1642 \
1643     if(D){\
1644         for(i=0; i<h; i++){\
1645             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1646             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1647             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1648             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1649             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
1650             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
1651             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
1652             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
1653             dst+= stride;\
1654             src+= stride;\
1655         }\
1656     }else{\
1657         const int E= B+C;\
1658         const int step= C ? stride : 1;\
1659         for(i=0; i<h; i++){\
1660             OP(dst[0], (A*src[0] + E*src[step+0]));\
1661             OP(dst[1], (A*src[1] + E*src[step+1]));\
1662             OP(dst[2], (A*src[2] + E*src[step+2]));\
1663             OP(dst[3], (A*src[3] + E*src[step+3]));\
1664             OP(dst[4], (A*src[4] + E*src[step+4]));\
1665             OP(dst[5], (A*src[5] + E*src[step+5]));\
1666             OP(dst[6], (A*src[6] + E*src[step+6]));\
1667             OP(dst[7], (A*src[7] + E*src[step+7]));\
1668             dst+= stride;\
1669             src+= stride;\
1670         }\
1671     }\
1672 }
1673
1674 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
1675 #define op_put(a, b) a = (((b) + 32)>>6)
1676
1677 H264_CHROMA_MC(put_       , op_put)
1678 H264_CHROMA_MC(avg_       , op_avg)
1679 #undef op_avg
1680 #undef op_put
1681
1682 static void put_no_rnd_vc1_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
1683     const int A=(8-x)*(8-y);
1684     const int B=(  x)*(8-y);
1685     const int C=(8-x)*(  y);
1686     const int D=(  x)*(  y);
1687     int i;
1688
1689     assert(x<8 && y<8 && x>=0 && y>=0);
1690
1691     for(i=0; i<h; i++)
1692     {
1693         dst[0] = (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6;
1694         dst[1] = (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6;
1695         dst[2] = (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6;
1696         dst[3] = (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6;
1697         dst[4] = (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6;
1698         dst[5] = (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6;
1699         dst[6] = (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6;
1700         dst[7] = (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6;
1701         dst+= stride;
1702         src+= stride;
1703     }
1704 }
1705
1706 static void avg_no_rnd_vc1_chroma_mc8_c(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){
1707     const int A=(8-x)*(8-y);
1708     const int B=(  x)*(8-y);
1709     const int C=(8-x)*(  y);
1710     const int D=(  x)*(  y);
1711     int i;
1712
1713     assert(x<8 && y<8 && x>=0 && y>=0);
1714
1715     for(i=0; i<h; i++)
1716     {
1717         dst[0] = avg2(dst[0], ((A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6));
1718         dst[1] = avg2(dst[1], ((A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6));
1719         dst[2] = avg2(dst[2], ((A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6));
1720         dst[3] = avg2(dst[3], ((A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6));
1721         dst[4] = avg2(dst[4], ((A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6));
1722         dst[5] = avg2(dst[5], ((A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6));
1723         dst[6] = avg2(dst[6], ((A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6));
1724         dst[7] = avg2(dst[7], ((A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6));
1725         dst+= stride;
1726         src+= stride;
1727     }
1728 }
1729
1730 #define QPEL_MC(r, OPNAME, RND, OP) \
1731 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1732     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1733     int i;\
1734     for(i=0; i<h; i++)\
1735     {\
1736         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
1737         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
1738         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
1739         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
1740         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
1741         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
1742         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
1743         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
1744         dst+=dstStride;\
1745         src+=srcStride;\
1746     }\
1747 }\
1748 \
1749 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1750     const int w=8;\
1751     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1752     int i;\
1753     for(i=0; i<w; i++)\
1754     {\
1755         const int src0= src[0*srcStride];\
1756         const int src1= src[1*srcStride];\
1757         const int src2= src[2*srcStride];\
1758         const int src3= src[3*srcStride];\
1759         const int src4= src[4*srcStride];\
1760         const int src5= src[5*srcStride];\
1761         const int src6= src[6*srcStride];\
1762         const int src7= src[7*srcStride];\
1763         const int src8= src[8*srcStride];\
1764         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
1765         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
1766         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
1767         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
1768         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
1769         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
1770         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
1771         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
1772         dst++;\
1773         src++;\
1774     }\
1775 }\
1776 \
1777 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1778     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1779     int i;\
1780     \
1781     for(i=0; i<h; i++)\
1782     {\
1783         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
1784         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
1785         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
1786         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
1787         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
1788         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
1789         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
1790         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
1791         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
1792         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
1793         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
1794         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
1795         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
1796         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
1797         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
1798         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
1799         dst+=dstStride;\
1800         src+=srcStride;\
1801     }\
1802 }\
1803 \
1804 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1805     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1806     int i;\
1807     const int w=16;\
1808     for(i=0; i<w; i++)\
1809     {\
1810         const int src0= src[0*srcStride];\
1811         const int src1= src[1*srcStride];\
1812         const int src2= src[2*srcStride];\
1813         const int src3= src[3*srcStride];\
1814         const int src4= src[4*srcStride];\
1815         const int src5= src[5*srcStride];\
1816         const int src6= src[6*srcStride];\
1817         const int src7= src[7*srcStride];\
1818         const int src8= src[8*srcStride];\
1819         const int src9= src[9*srcStride];\
1820         const int src10= src[10*srcStride];\
1821         const int src11= src[11*srcStride];\
1822         const int src12= src[12*srcStride];\
1823         const int src13= src[13*srcStride];\
1824         const int src14= src[14*srcStride];\
1825         const int src15= src[15*srcStride];\
1826         const int src16= src[16*srcStride];\
1827         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
1828         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
1829         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
1830         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
1831         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
1832         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
1833         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
1834         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
1835         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
1836         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
1837         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
1838         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
1839         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
1840         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
1841         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
1842         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
1843         dst++;\
1844         src++;\
1845     }\
1846 }\
1847 \
1848 static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1849     OPNAME ## pixels8_c(dst, src, stride, 8);\
1850 }\
1851 \
1852 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1853     uint8_t half[64];\
1854     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1855     OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);\
1856 }\
1857 \
1858 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1859     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
1860 }\
1861 \
1862 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1863     uint8_t half[64];\
1864     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1865     OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);\
1866 }\
1867 \
1868 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1869     uint8_t full[16*9];\
1870     uint8_t half[64];\
1871     copy_block9(full, src, 16, stride, 9);\
1872     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1873     OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);\
1874 }\
1875 \
1876 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1877     uint8_t full[16*9];\
1878     copy_block9(full, src, 16, stride, 9);\
1879     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
1880 }\
1881 \
1882 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1883     uint8_t full[16*9];\
1884     uint8_t half[64];\
1885     copy_block9(full, src, 16, stride, 9);\
1886     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1887     OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);\
1888 }\
1889 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1890     uint8_t full[16*9];\
1891     uint8_t halfH[72];\
1892     uint8_t halfV[64];\
1893     uint8_t halfHV[64];\
1894     copy_block9(full, src, 16, stride, 9);\
1895     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1896     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1897     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1898     OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1899 }\
1900 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1901     uint8_t full[16*9];\
1902     uint8_t halfH[72];\
1903     uint8_t halfHV[64];\
1904     copy_block9(full, src, 16, stride, 9);\
1905     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1906     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1907     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1908     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1909 }\
1910 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1911     uint8_t full[16*9];\
1912     uint8_t halfH[72];\
1913     uint8_t halfV[64];\
1914     uint8_t halfHV[64];\
1915     copy_block9(full, src, 16, stride, 9);\
1916     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1917     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1918     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1919     OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1920 }\
1921 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1922     uint8_t full[16*9];\
1923     uint8_t halfH[72];\
1924     uint8_t halfHV[64];\
1925     copy_block9(full, src, 16, stride, 9);\
1926     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1927     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1928     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1929     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1930 }\
1931 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1932     uint8_t full[16*9];\
1933     uint8_t halfH[72];\
1934     uint8_t halfV[64];\
1935     uint8_t halfHV[64];\
1936     copy_block9(full, src, 16, stride, 9);\
1937     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1938     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1939     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1940     OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1941 }\
1942 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1943     uint8_t full[16*9];\
1944     uint8_t halfH[72];\
1945     uint8_t halfHV[64];\
1946     copy_block9(full, src, 16, stride, 9);\
1947     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1948     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1949     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1950     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1951 }\
1952 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1953     uint8_t full[16*9];\
1954     uint8_t halfH[72];\
1955     uint8_t halfV[64];\
1956     uint8_t halfHV[64];\
1957     copy_block9(full, src, 16, stride, 9);\
1958     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
1959     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1960     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1961     OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1962 }\
1963 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1964     uint8_t full[16*9];\
1965     uint8_t halfH[72];\
1966     uint8_t halfHV[64];\
1967     copy_block9(full, src, 16, stride, 9);\
1968     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1969     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1970     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1971     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1972 }\
1973 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1974     uint8_t halfH[72];\
1975     uint8_t halfHV[64];\
1976     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1977     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1978     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1979 }\
1980 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1981     uint8_t halfH[72];\
1982     uint8_t halfHV[64];\
1983     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1984     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1985     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1986 }\
1987 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1988     uint8_t full[16*9];\
1989     uint8_t halfH[72];\
1990     uint8_t halfV[64];\
1991     uint8_t halfHV[64];\
1992     copy_block9(full, src, 16, stride, 9);\
1993     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1994     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1995     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1996     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1997 }\
1998 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1999     uint8_t full[16*9];\
2000     uint8_t halfH[72];\
2001     copy_block9(full, src, 16, stride, 9);\
2002     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
2003     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
2004     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
2005 }\
2006 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
2007     uint8_t full[16*9];\
2008     uint8_t halfH[72];\
2009     uint8_t halfV[64];\
2010     uint8_t halfHV[64];\
2011     copy_block9(full, src, 16, stride, 9);\
2012     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
2013     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
2014     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
2015     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
2016 }\
2017 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2018     uint8_t full[16*9];\
2019     uint8_t halfH[72];\
2020     copy_block9(full, src, 16, stride, 9);\
2021     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
2022     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
2023     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
2024 }\
2025 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2026     uint8_t halfH[72];\
2027     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
2028     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
2029 }\
2030 static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
2031     OPNAME ## pixels16_c(dst, src, stride, 16);\
2032 }\
2033 \
2034 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
2035     uint8_t half[256];\
2036     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
2037     OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);\
2038 }\
2039 \
2040 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
2041     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
2042 }\
2043 \
2044 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
2045     uint8_t half[256];\
2046     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
2047     OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);\
2048 }\
2049 \
2050 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2051     uint8_t full[24*17];\
2052     uint8_t half[256];\
2053     copy_block17(full, src, 24, stride, 17);\
2054     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
2055     OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);\
2056 }\
2057 \
2058 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2059     uint8_t full[24*17];\
2060     copy_block17(full, src, 24, stride, 17);\
2061     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
2062 }\
2063 \
2064 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2065     uint8_t full[24*17];\
2066     uint8_t half[256];\
2067     copy_block17(full, src, 24, stride, 17);\
2068     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
2069     OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);\
2070 }\
2071 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
2072     uint8_t full[24*17];\
2073     uint8_t halfH[272];\
2074     uint8_t halfV[256];\
2075     uint8_t halfHV[256];\
2076     copy_block17(full, src, 24, stride, 17);\
2077     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2078     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2079     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2080     OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2081 }\
2082 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2083     uint8_t full[24*17];\
2084     uint8_t halfH[272];\
2085     uint8_t halfHV[256];\
2086     copy_block17(full, src, 24, stride, 17);\
2087     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2088     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2089     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2090     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2091 }\
2092 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
2093     uint8_t full[24*17];\
2094     uint8_t halfH[272];\
2095     uint8_t halfV[256];\
2096     uint8_t halfHV[256];\
2097     copy_block17(full, src, 24, stride, 17);\
2098     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2099     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2100     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2101     OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2102 }\
2103 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2104     uint8_t full[24*17];\
2105     uint8_t halfH[272];\
2106     uint8_t halfHV[256];\
2107     copy_block17(full, src, 24, stride, 17);\
2108     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2109     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2110     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2111     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2112 }\
2113 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
2114     uint8_t full[24*17];\
2115     uint8_t halfH[272];\
2116     uint8_t halfV[256];\
2117     uint8_t halfHV[256];\
2118     copy_block17(full, src, 24, stride, 17);\
2119     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2120     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2121     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2122     OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2123 }\
2124 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2125     uint8_t full[24*17];\
2126     uint8_t halfH[272];\
2127     uint8_t halfHV[256];\
2128     copy_block17(full, src, 24, stride, 17);\
2129     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2130     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2131     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2132     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2133 }\
2134 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
2135     uint8_t full[24*17];\
2136     uint8_t halfH[272];\
2137     uint8_t halfV[256];\
2138     uint8_t halfHV[256];\
2139     copy_block17(full, src, 24, stride, 17);\
2140     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
2141     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2142     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2143     OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
2144 }\
2145 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2146     uint8_t full[24*17];\
2147     uint8_t halfH[272];\
2148     uint8_t halfHV[256];\
2149     copy_block17(full, src, 24, stride, 17);\
2150     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2151     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2152     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2153     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2154 }\
2155 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2156     uint8_t halfH[272];\
2157     uint8_t halfHV[256];\
2158     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2159     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2160     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
2161 }\
2162 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2163     uint8_t halfH[272];\
2164     uint8_t halfHV[256];\
2165     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2166     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2167     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
2168 }\
2169 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
2170     uint8_t full[24*17];\
2171     uint8_t halfH[272];\
2172     uint8_t halfV[256];\
2173     uint8_t halfHV[256];\
2174     copy_block17(full, src, 24, stride, 17);\
2175     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2176     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
2177     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2178     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2179 }\
2180 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2181     uint8_t full[24*17];\
2182     uint8_t halfH[272];\
2183     copy_block17(full, src, 24, stride, 17);\
2184     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2185     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
2186     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2187 }\
2188 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
2189     uint8_t full[24*17];\
2190     uint8_t halfH[272];\
2191     uint8_t halfV[256];\
2192     uint8_t halfHV[256];\
2193     copy_block17(full, src, 24, stride, 17);\
2194     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2195     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
2196     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
2197     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
2198 }\
2199 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2200     uint8_t full[24*17];\
2201     uint8_t halfH[272];\
2202     copy_block17(full, src, 24, stride, 17);\
2203     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2204     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2205     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2206 }\
2207 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2208     uint8_t halfH[272];\
2209     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2210     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2211 }
2212
2213 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2214 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
2215 #define op_put(a, b) a = cm[((b) + 16)>>5]
2216 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
2217
2218 QPEL_MC(0, put_       , _       , op_put)
2219 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
2220 QPEL_MC(0, avg_       , _       , op_avg)
2221 //QPEL_MC(1, avg_no_rnd , _       , op_avg)
2222 #undef op_avg
2223 #undef op_avg_no_rnd
2224 #undef op_put
2225 #undef op_put_no_rnd
2226
2227 #if 1
2228 #define H264_LOWPASS(OPNAME, OP, OP2) \
2229 static av_unused void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2230     const int h=2;\
2231     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2232     int i;\
2233     for(i=0; i<h; i++)\
2234     {\
2235         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2236         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2237         dst+=dstStride;\
2238         src+=srcStride;\
2239     }\
2240 }\
2241 \
2242 static av_unused void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2243     const int w=2;\
2244     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2245     int i;\
2246     for(i=0; i<w; i++)\
2247     {\
2248         const int srcB= src[-2*srcStride];\
2249         const int srcA= src[-1*srcStride];\
2250         const int src0= src[0 *srcStride];\
2251         const int src1= src[1 *srcStride];\
2252         const int src2= src[2 *srcStride];\
2253         const int src3= src[3 *srcStride];\
2254         const int src4= src[4 *srcStride];\
2255         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2256         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2257         dst++;\
2258         src++;\
2259     }\
2260 }\
2261 \
2262 static av_unused void OPNAME ## h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2263     const int h=2;\
2264     const int w=2;\
2265     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2266     int i;\
2267     src -= 2*srcStride;\
2268     for(i=0; i<h+5; i++)\
2269     {\
2270         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2271         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2272         tmp+=tmpStride;\
2273         src+=srcStride;\
2274     }\
2275     tmp -= tmpStride*(h+5-2);\
2276     for(i=0; i<w; i++)\
2277     {\
2278         const int tmpB= tmp[-2*tmpStride];\
2279         const int tmpA= tmp[-1*tmpStride];\
2280         const int tmp0= tmp[0 *tmpStride];\
2281         const int tmp1= tmp[1 *tmpStride];\
2282         const int tmp2= tmp[2 *tmpStride];\
2283         const int tmp3= tmp[3 *tmpStride];\
2284         const int tmp4= tmp[4 *tmpStride];\
2285         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2286         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2287         dst++;\
2288         tmp++;\
2289     }\
2290 }\
2291 static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2292     const int h=4;\
2293     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2294     int i;\
2295     for(i=0; i<h; i++)\
2296     {\
2297         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2298         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2299         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));\
2300         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));\
2301         dst+=dstStride;\
2302         src+=srcStride;\
2303     }\
2304 }\
2305 \
2306 static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2307     const int w=4;\
2308     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2309     int i;\
2310     for(i=0; i<w; i++)\
2311     {\
2312         const int srcB= src[-2*srcStride];\
2313         const int srcA= src[-1*srcStride];\
2314         const int src0= src[0 *srcStride];\
2315         const int src1= src[1 *srcStride];\
2316         const int src2= src[2 *srcStride];\
2317         const int src3= src[3 *srcStride];\
2318         const int src4= src[4 *srcStride];\
2319         const int src5= src[5 *srcStride];\
2320         const int src6= src[6 *srcStride];\
2321         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2322         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2323         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2324         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2325         dst++;\
2326         src++;\
2327     }\
2328 }\
2329 \
2330 static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2331     const int h=4;\
2332     const int w=4;\
2333     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2334     int i;\
2335     src -= 2*srcStride;\
2336     for(i=0; i<h+5; i++)\
2337     {\
2338         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2339         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2340         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]);\
2341         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]);\
2342         tmp+=tmpStride;\
2343         src+=srcStride;\
2344     }\
2345     tmp -= tmpStride*(h+5-2);\
2346     for(i=0; i<w; i++)\
2347     {\
2348         const int tmpB= tmp[-2*tmpStride];\
2349         const int tmpA= tmp[-1*tmpStride];\
2350         const int tmp0= tmp[0 *tmpStride];\
2351         const int tmp1= tmp[1 *tmpStride];\
2352         const int tmp2= tmp[2 *tmpStride];\
2353         const int tmp3= tmp[3 *tmpStride];\
2354         const int tmp4= tmp[4 *tmpStride];\
2355         const int tmp5= tmp[5 *tmpStride];\
2356         const int tmp6= tmp[6 *tmpStride];\
2357         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2358         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2359         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2360         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2361         dst++;\
2362         tmp++;\
2363     }\
2364 }\
2365 \
2366 static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2367     const int h=8;\
2368     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2369     int i;\
2370     for(i=0; i<h; i++)\
2371     {\
2372         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
2373         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));\
2374         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));\
2375         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));\
2376         OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));\
2377         OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));\
2378         OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));\
2379         OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));\
2380         dst+=dstStride;\
2381         src+=srcStride;\
2382     }\
2383 }\
2384 \
2385 static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2386     const int w=8;\
2387     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2388     int i;\
2389     for(i=0; i<w; i++)\
2390     {\
2391         const int srcB= src[-2*srcStride];\
2392         const int srcA= src[-1*srcStride];\
2393         const int src0= src[0 *srcStride];\
2394         const int src1= src[1 *srcStride];\
2395         const int src2= src[2 *srcStride];\
2396         const int src3= src[3 *srcStride];\
2397         const int src4= src[4 *srcStride];\
2398         const int src5= src[5 *srcStride];\
2399         const int src6= src[6 *srcStride];\
2400         const int src7= src[7 *srcStride];\
2401         const int src8= src[8 *srcStride];\
2402         const int src9= src[9 *srcStride];\
2403         const int src10=src[10*srcStride];\
2404         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2405         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2406         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2407         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2408         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
2409         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
2410         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
2411         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
2412         dst++;\
2413         src++;\
2414     }\
2415 }\
2416 \
2417 static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2418     const int h=8;\
2419     const int w=8;\
2420     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2421     int i;\
2422     src -= 2*srcStride;\
2423     for(i=0; i<h+5; i++)\
2424     {\
2425         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);\
2426         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);\
2427         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);\
2428         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);\
2429         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);\
2430         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);\
2431         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);\
2432         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);\
2433         tmp+=tmpStride;\
2434         src+=srcStride;\
2435     }\
2436     tmp -= tmpStride*(h+5-2);\
2437     for(i=0; i<w; i++)\
2438     {\
2439         const int tmpB= tmp[-2*tmpStride];\
2440         const int tmpA= tmp[-1*tmpStride];\
2441         const int tmp0= tmp[0 *tmpStride];\
2442         const int tmp1= tmp[1 *tmpStride];\
2443         const int tmp2= tmp[2 *tmpStride];\
2444         const int tmp3= tmp[3 *tmpStride];\
2445         const int tmp4= tmp[4 *tmpStride];\
2446         const int tmp5= tmp[5 *tmpStride];\
2447         const int tmp6= tmp[6 *tmpStride];\
2448         const int tmp7= tmp[7 *tmpStride];\
2449         const int tmp8= tmp[8 *tmpStride];\
2450         const int tmp9= tmp[9 *tmpStride];\
2451         const int tmp10=tmp[10*tmpStride];\
2452         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2453         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2454         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2455         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2456         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));\
2457         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));\
2458         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));\
2459         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));\
2460         dst++;\
2461         tmp++;\
2462     }\
2463 }\
2464 \
2465 static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2466     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2467     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2468     src += 8*srcStride;\
2469     dst += 8*dstStride;\
2470     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2471     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2472 }\
2473 \
2474 static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2475     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2476     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2477     src += 8*srcStride;\
2478     dst += 8*dstStride;\
2479     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2480     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2481 }\
2482 \
2483 static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2484     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2485     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2486     src += 8*srcStride;\
2487     dst += 8*dstStride;\
2488     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2489     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2490 }\
2491
2492 #define H264_MC(OPNAME, SIZE) \
2493 static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){\
2494     OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);\
2495 }\
2496 \
2497 static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
2498     uint8_t half[SIZE*SIZE];\
2499     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2500     OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);\
2501 }\
2502 \
2503 static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){\
2504     OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);\
2505 }\
2506 \
2507 static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
2508     uint8_t half[SIZE*SIZE];\
2509     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2510     OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);\
2511 }\
2512 \
2513 static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2514     uint8_t full[SIZE*(SIZE+5)];\
2515     uint8_t * const full_mid= full + SIZE*2;\
2516     uint8_t half[SIZE*SIZE];\
2517     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2518     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2519     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);\
2520 }\
2521 \
2522 static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2523     uint8_t full[SIZE*(SIZE+5)];\
2524     uint8_t * const full_mid= full + SIZE*2;\
2525     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2526     OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);\
2527 }\
2528 \
2529 static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2530     uint8_t full[SIZE*(SIZE+5)];\
2531     uint8_t * const full_mid= full + SIZE*2;\
2532     uint8_t half[SIZE*SIZE];\
2533     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2534     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2535     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);\
2536 }\
2537 \
2538 static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2539     uint8_t full[SIZE*(SIZE+5)];\
2540     uint8_t * const full_mid= full + SIZE*2;\
2541     uint8_t halfH[SIZE*SIZE];\
2542     uint8_t halfV[SIZE*SIZE];\
2543     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2544     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2545     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2546     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2547 }\
2548 \
2549 static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2550     uint8_t full[SIZE*(SIZE+5)];\
2551     uint8_t * const full_mid= full + SIZE*2;\
2552     uint8_t halfH[SIZE*SIZE];\
2553     uint8_t halfV[SIZE*SIZE];\
2554     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2555     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2556     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2557     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2558 }\
2559 \
2560 static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2561     uint8_t full[SIZE*(SIZE+5)];\
2562     uint8_t * const full_mid= full + SIZE*2;\
2563     uint8_t halfH[SIZE*SIZE];\
2564     uint8_t halfV[SIZE*SIZE];\
2565     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2566     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2567     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2568     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2569 }\
2570 \
2571 static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2572     uint8_t full[SIZE*(SIZE+5)];\
2573     uint8_t * const full_mid= full + SIZE*2;\
2574     uint8_t halfH[SIZE*SIZE];\
2575     uint8_t halfV[SIZE*SIZE];\
2576     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2577     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2578     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2579     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2580 }\
2581 \
2582 static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2583     int16_t tmp[SIZE*(SIZE+5)];\
2584     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);\
2585 }\
2586 \
2587 static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2588     int16_t tmp[SIZE*(SIZE+5)];\