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