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