git.sesse.net Git - ffmpeg/blob - 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     for(i=0; i<h; i++)\
1482     {\
1483         OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
1484         OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
1485         OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
1486         OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
1487         OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
1488         OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
1489         OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
1490         OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
1491         dst+= stride;\
1492         src+= stride;\
1493     }\
1494 }
1495
1496 #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
1497 #define op_put(a, b) a = (((b) + 32)>>6)
1498
1499 H264_CHROMA_MC(put_       , op_put)
1500 H264_CHROMA_MC(avg_       , op_avg)
1501 #undef op_avg
1502 #undef op_put
1503
1504 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){
1505     const int A=(8-x)*(8-y);
1506     const int B=(  x)*(8-y);
1507     const int C=(8-x)*(  y);
1508     const int D=(  x)*(  y);
1509     int i;
1510
1511     assert(x<8 && y<8 && x>=0 && y>=0);
1512
1513     for(i=0; i<h; i++)
1514     {
1515         dst[0] = (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + 32 - 4) >> 6;
1516         dst[1] = (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + 32 - 4) >> 6;
1517         dst[2] = (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + 32 - 4) >> 6;
1518         dst[3] = (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + 32 - 4) >> 6;
1519         dst[4] = (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + 32 - 4) >> 6;
1520         dst[5] = (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + 32 - 4) >> 6;
1521         dst[6] = (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + 32 - 4) >> 6;
1522         dst[7] = (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + 32 - 4) >> 6;
1523         dst+= stride;
1524         src+= stride;
1525     }
1526 }
1527
1528 #define QPEL_MC(r, OPNAME, RND, OP) \
1529 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1530     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1531     int i;\
1532     for(i=0; i<h; i++)\
1533     {\
1534         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
1535         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
1536         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
1537         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
1538         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
1539         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
1540         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
1541         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
1542         dst+=dstStride;\
1543         src+=srcStride;\
1544     }\
1545 }\
1546 \
1547 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1548     const int w=8;\
1549     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1550     int i;\
1551     for(i=0; i<w; i++)\
1552     {\
1553         const int src0= src[0*srcStride];\
1554         const int src1= src[1*srcStride];\
1555         const int src2= src[2*srcStride];\
1556         const int src3= src[3*srcStride];\
1557         const int src4= src[4*srcStride];\
1558         const int src5= src[5*srcStride];\
1559         const int src6= src[6*srcStride];\
1560         const int src7= src[7*srcStride];\
1561         const int src8= src[8*srcStride];\
1562         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
1563         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
1564         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
1565         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
1566         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
1567         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
1568         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
1569         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
1570         dst++;\
1571         src++;\
1572     }\
1573 }\
1574 \
1575 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
1576     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1577     int i;\
1578     \
1579     for(i=0; i<h; i++)\
1580     {\
1581         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
1582         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
1583         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
1584         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
1585         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
1586         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
1587         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
1588         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
1589         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
1590         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
1591         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
1592         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
1593         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
1594         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
1595         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
1596         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
1597         dst+=dstStride;\
1598         src+=srcStride;\
1599     }\
1600 }\
1601 \
1602 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
1603     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
1604     int i;\
1605     const int w=16;\
1606     for(i=0; i<w; i++)\
1607     {\
1608         const int src0= src[0*srcStride];\
1609         const int src1= src[1*srcStride];\
1610         const int src2= src[2*srcStride];\
1611         const int src3= src[3*srcStride];\
1612         const int src4= src[4*srcStride];\
1613         const int src5= src[5*srcStride];\
1614         const int src6= src[6*srcStride];\
1615         const int src7= src[7*srcStride];\
1616         const int src8= src[8*srcStride];\
1617         const int src9= src[9*srcStride];\
1618         const int src10= src[10*srcStride];\
1619         const int src11= src[11*srcStride];\
1620         const int src12= src[12*srcStride];\
1621         const int src13= src[13*srcStride];\
1622         const int src14= src[14*srcStride];\
1623         const int src15= src[15*srcStride];\
1624         const int src16= src[16*srcStride];\
1625         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
1626         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
1627         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
1628         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
1629         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
1630         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
1631         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
1632         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
1633         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
1634         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
1635         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
1636         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
1637         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
1638         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
1639         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
1640         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
1641         dst++;\
1642         src++;\
1643     }\
1644 }\
1645 \
1646 static void OPNAME ## qpel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1647     OPNAME ## pixels8_c(dst, src, stride, 8);\
1648 }\
1649 \
1650 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1651     uint8_t half[64];\
1652     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1653     OPNAME ## pixels8_l2(dst, src, half, stride, stride, 8, 8);\
1654 }\
1655 \
1656 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1657     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
1658 }\
1659 \
1660 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1661     uint8_t half[64];\
1662     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
1663     OPNAME ## pixels8_l2(dst, src+1, half, stride, stride, 8, 8);\
1664 }\
1665 \
1666 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1667     uint8_t full[16*9];\
1668     uint8_t half[64];\
1669     copy_block9(full, src, 16, stride, 9);\
1670     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1671     OPNAME ## pixels8_l2(dst, full, half, stride, 16, 8, 8);\
1672 }\
1673 \
1674 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1675     uint8_t full[16*9];\
1676     copy_block9(full, src, 16, stride, 9);\
1677     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
1678 }\
1679 \
1680 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1681     uint8_t full[16*9];\
1682     uint8_t half[64];\
1683     copy_block9(full, src, 16, stride, 9);\
1684     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
1685     OPNAME ## pixels8_l2(dst, full+16, half, stride, 16, 8, 8);\
1686 }\
1687 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1688     uint8_t full[16*9];\
1689     uint8_t halfH[72];\
1690     uint8_t halfV[64];\
1691     uint8_t halfHV[64];\
1692     copy_block9(full, src, 16, stride, 9);\
1693     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1694     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1695     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1696     OPNAME ## pixels8_l4(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1697 }\
1698 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1699     uint8_t full[16*9];\
1700     uint8_t halfH[72];\
1701     uint8_t halfHV[64];\
1702     copy_block9(full, src, 16, stride, 9);\
1703     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1704     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1705     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1706     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1707 }\
1708 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1709     uint8_t full[16*9];\
1710     uint8_t halfH[72];\
1711     uint8_t halfV[64];\
1712     uint8_t halfHV[64];\
1713     copy_block9(full, src, 16, stride, 9);\
1714     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1715     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1716     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1717     OPNAME ## pixels8_l4(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1718 }\
1719 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1720     uint8_t full[16*9];\
1721     uint8_t halfH[72];\
1722     uint8_t halfHV[64];\
1723     copy_block9(full, src, 16, stride, 9);\
1724     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1725     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1726     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1727     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1728 }\
1729 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1730     uint8_t full[16*9];\
1731     uint8_t halfH[72];\
1732     uint8_t halfV[64];\
1733     uint8_t halfHV[64];\
1734     copy_block9(full, src, 16, stride, 9);\
1735     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1736     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1737     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1738     OPNAME ## pixels8_l4(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1739 }\
1740 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1741     uint8_t full[16*9];\
1742     uint8_t halfH[72];\
1743     uint8_t halfHV[64];\
1744     copy_block9(full, src, 16, stride, 9);\
1745     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1746     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1747     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1748     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1749 }\
1750 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1751     uint8_t full[16*9];\
1752     uint8_t halfH[72];\
1753     uint8_t halfV[64];\
1754     uint8_t halfHV[64];\
1755     copy_block9(full, src, 16, stride, 9);\
1756     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
1757     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1758     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1759     OPNAME ## pixels8_l4(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
1760 }\
1761 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1762     uint8_t full[16*9];\
1763     uint8_t halfH[72];\
1764     uint8_t halfHV[64];\
1765     copy_block9(full, src, 16, stride, 9);\
1766     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1767     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1768     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1769     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1770 }\
1771 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1772     uint8_t halfH[72];\
1773     uint8_t halfHV[64];\
1774     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1775     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1776     OPNAME ## pixels8_l2(dst, halfH, halfHV, stride, 8, 8, 8);\
1777 }\
1778 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1779     uint8_t halfH[72];\
1780     uint8_t halfHV[64];\
1781     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1782     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1783     OPNAME ## pixels8_l2(dst, halfH+8, halfHV, stride, 8, 8, 8);\
1784 }\
1785 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1786     uint8_t full[16*9];\
1787     uint8_t halfH[72];\
1788     uint8_t halfV[64];\
1789     uint8_t halfHV[64];\
1790     copy_block9(full, src, 16, stride, 9);\
1791     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1792     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
1793     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1794     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1795 }\
1796 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1797     uint8_t full[16*9];\
1798     uint8_t halfH[72];\
1799     copy_block9(full, src, 16, stride, 9);\
1800     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1801     put ## RND ## pixels8_l2(halfH, halfH, full, 8, 8, 16, 9);\
1802     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1803 }\
1804 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1805     uint8_t full[16*9];\
1806     uint8_t halfH[72];\
1807     uint8_t halfV[64];\
1808     uint8_t halfHV[64];\
1809     copy_block9(full, src, 16, stride, 9);\
1810     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1811     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1812     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1813     OPNAME ## pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);\
1814 }\
1815 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1816     uint8_t full[16*9];\
1817     uint8_t halfH[72];\
1818     copy_block9(full, src, 16, stride, 9);\
1819     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1820     put ## RND ## pixels8_l2(halfH, halfH, full+1, 8, 8, 16, 9);\
1821     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1822 }\
1823 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1824     uint8_t halfH[72];\
1825     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1826     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1827 }\
1828 static void OPNAME ## qpel16_mc00_c (uint8_t *dst, uint8_t *src, int stride){\
1829     OPNAME ## pixels16_c(dst, src, stride, 16);\
1830 }\
1831 \
1832 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1833     uint8_t half[256];\
1834     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1835     OPNAME ## pixels16_l2(dst, src, half, stride, stride, 16, 16);\
1836 }\
1837 \
1838 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1839     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1840 }\
1841 \
1842 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1843     uint8_t half[256];\
1844     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1845     OPNAME ## pixels16_l2(dst, src+1, half, stride, stride, 16, 16);\
1846 }\
1847 \
1848 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1849     uint8_t full[24*17];\
1850     uint8_t half[256];\
1851     copy_block17(full, src, 24, stride, 17);\
1852     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1853     OPNAME ## pixels16_l2(dst, full, half, stride, 24, 16, 16);\
1854 }\
1855 \
1856 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1857     uint8_t full[24*17];\
1858     copy_block17(full, src, 24, stride, 17);\
1859     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
1860 }\
1861 \
1862 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1863     uint8_t full[24*17];\
1864     uint8_t half[256];\
1865     copy_block17(full, src, 24, stride, 17);\
1866     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1867     OPNAME ## pixels16_l2(dst, full+24, half, stride, 24, 16, 16);\
1868 }\
1869 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1870     uint8_t full[24*17];\
1871     uint8_t halfH[272];\
1872     uint8_t halfV[256];\
1873     uint8_t halfHV[256];\
1874     copy_block17(full, src, 24, stride, 17);\
1875     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1876     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1877     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1878     OPNAME ## pixels16_l4(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1879 }\
1880 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1881     uint8_t full[24*17];\
1882     uint8_t halfH[272];\
1883     uint8_t halfHV[256];\
1884     copy_block17(full, src, 24, stride, 17);\
1885     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1886     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
1887     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1888     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
1889 }\
1890 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1891     uint8_t full[24*17];\
1892     uint8_t halfH[272];\
1893     uint8_t halfV[256];\
1894     uint8_t halfHV[256];\
1895     copy_block17(full, src, 24, stride, 17);\
1896     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1897     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1898     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1899     OPNAME ## pixels16_l4(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1900 }\
1901 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1902     uint8_t full[24*17];\
1903     uint8_t halfH[272];\
1904     uint8_t halfHV[256];\
1905     copy_block17(full, src, 24, stride, 17);\
1906     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1907     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
1908     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1909     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
1910 }\
1911 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1912     uint8_t full[24*17];\
1913     uint8_t halfH[272];\
1914     uint8_t halfV[256];\
1915     uint8_t halfHV[256];\
1916     copy_block17(full, src, 24, stride, 17);\
1917     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1918     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1919     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1920     OPNAME ## pixels16_l4(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1921 }\
1922 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1923     uint8_t full[24*17];\
1924     uint8_t halfH[272];\
1925     uint8_t halfHV[256];\
1926     copy_block17(full, src, 24, stride, 17);\
1927     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1928     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
1929     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1930     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1931 }\
1932 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1933     uint8_t full[24*17];\
1934     uint8_t halfH[272];\
1935     uint8_t halfV[256];\
1936     uint8_t halfHV[256];\
1937     copy_block17(full, src, 24, stride, 17);\
1938     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
1939     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1940     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1941     OPNAME ## pixels16_l4(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1942 }\
1943 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1944     uint8_t full[24*17];\
1945     uint8_t halfH[272];\
1946     uint8_t halfHV[256];\
1947     copy_block17(full, src, 24, stride, 17);\
1948     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1949     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
1950     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1951     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1952 }\
1953 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1954     uint8_t halfH[272];\
1955     uint8_t halfHV[256];\
1956     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1957     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1958     OPNAME ## pixels16_l2(dst, halfH, halfHV, stride, 16, 16, 16);\
1959 }\
1960 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1961     uint8_t halfH[272];\
1962     uint8_t halfHV[256];\
1963     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1964     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1965     OPNAME ## pixels16_l2(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1966 }\
1967 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1968     uint8_t full[24*17];\
1969     uint8_t halfH[272];\
1970     uint8_t halfV[256];\
1971     uint8_t halfHV[256];\
1972     copy_block17(full, src, 24, stride, 17);\
1973     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1974     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1975     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1976     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
1977 }\
1978 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1979     uint8_t full[24*17];\
1980     uint8_t halfH[272];\
1981     copy_block17(full, src, 24, stride, 17);\
1982     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1983     put ## RND ## pixels16_l2(halfH, halfH, full, 16, 16, 24, 17);\
1984     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1985 }\
1986 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1987     uint8_t full[24*17];\
1988     uint8_t halfH[272];\
1989     uint8_t halfV[256];\
1990     uint8_t halfHV[256];\
1991     copy_block17(full, src, 24, stride, 17);\
1992     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1993     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1994     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1995     OPNAME ## pixels16_l2(dst, halfV, halfHV, stride, 16, 16, 16);\
1996 }\
1997 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1998     uint8_t full[24*17];\
1999     uint8_t halfH[272];\
2000     copy_block17(full, src, 24, stride, 17);\
2001     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
2002     put ## RND ## pixels16_l2(halfH, halfH, full+1, 16, 16, 24, 17);\
2003     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2004 }\
2005 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2006     uint8_t halfH[272];\
2007     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
2008     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
2009 }
2010
2011 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2012 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
2013 #define op_put(a, b) a = cm[((b) + 16)>>5]
2014 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
2015
2016 QPEL_MC(0, put_       , _       , op_put)
2017 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
2018 QPEL_MC(0, avg_       , _       , op_avg)
2019 //QPEL_MC(1, avg_no_rnd , _       , op_avg)
2020 #undef op_avg
2021 #undef op_avg_no_rnd
2022 #undef op_put
2023 #undef op_put_no_rnd
2024
2025 #if 1
2026 #define H264_LOWPASS(OPNAME, OP, OP2) \
2027 static av_unused void OPNAME ## h264_qpel2_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2028     const int h=2;\
2029     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2030     int i;\
2031     for(i=0; i<h; i++)\
2032     {\
2033         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2034         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2035         dst+=dstStride;\
2036         src+=srcStride;\
2037     }\
2038 }\
2039 \
2040 static av_unused void OPNAME ## h264_qpel2_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2041     const int w=2;\
2042     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2043     int i;\
2044     for(i=0; i<w; i++)\
2045     {\
2046         const int srcB= src[-2*srcStride];\
2047         const int srcA= src[-1*srcStride];\
2048         const int src0= src[0 *srcStride];\
2049         const int src1= src[1 *srcStride];\
2050         const int src2= src[2 *srcStride];\
2051         const int src3= src[3 *srcStride];\
2052         const int src4= src[4 *srcStride];\
2053         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2054         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2055         dst++;\
2056         src++;\
2057     }\
2058 }\
2059 \
2060 static av_unused void OPNAME ## h264_qpel2_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2061     const int h=2;\
2062     const int w=2;\
2063     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2064     int i;\
2065     src -= 2*srcStride;\
2066     for(i=0; i<h+5; i++)\
2067     {\
2068         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2069         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2070         tmp+=tmpStride;\
2071         src+=srcStride;\
2072     }\
2073     tmp -= tmpStride*(h+5-2);\
2074     for(i=0; i<w; i++)\
2075     {\
2076         const int tmpB= tmp[-2*tmpStride];\
2077         const int tmpA= tmp[-1*tmpStride];\
2078         const int tmp0= tmp[0 *tmpStride];\
2079         const int tmp1= tmp[1 *tmpStride];\
2080         const int tmp2= tmp[2 *tmpStride];\
2081         const int tmp3= tmp[3 *tmpStride];\
2082         const int tmp4= tmp[4 *tmpStride];\
2083         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2084         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2085         dst++;\
2086         tmp++;\
2087     }\
2088 }\
2089 static void OPNAME ## h264_qpel4_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2090     const int h=4;\
2091     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2092     int i;\
2093     for(i=0; i<h; i++)\
2094     {\
2095         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]));\
2096         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]));\
2097         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]));\
2098         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]));\
2099         dst+=dstStride;\
2100         src+=srcStride;\
2101     }\
2102 }\
2103 \
2104 static void OPNAME ## h264_qpel4_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2105     const int w=4;\
2106     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2107     int i;\
2108     for(i=0; i<w; i++)\
2109     {\
2110         const int srcB= src[-2*srcStride];\
2111         const int srcA= src[-1*srcStride];\
2112         const int src0= src[0 *srcStride];\
2113         const int src1= src[1 *srcStride];\
2114         const int src2= src[2 *srcStride];\
2115         const int src3= src[3 *srcStride];\
2116         const int src4= src[4 *srcStride];\
2117         const int src5= src[5 *srcStride];\
2118         const int src6= src[6 *srcStride];\
2119         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2120         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2121         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2122         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2123         dst++;\
2124         src++;\
2125     }\
2126 }\
2127 \
2128 static void OPNAME ## h264_qpel4_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2129     const int h=4;\
2130     const int w=4;\
2131     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2132     int i;\
2133     src -= 2*srcStride;\
2134     for(i=0; i<h+5; i++)\
2135     {\
2136         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3]);\
2137         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4]);\
2138         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5]);\
2139         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6]);\
2140         tmp+=tmpStride;\
2141         src+=srcStride;\
2142     }\
2143     tmp -= tmpStride*(h+5-2);\
2144     for(i=0; i<w; i++)\
2145     {\
2146         const int tmpB= tmp[-2*tmpStride];\
2147         const int tmpA= tmp[-1*tmpStride];\
2148         const int tmp0= tmp[0 *tmpStride];\
2149         const int tmp1= tmp[1 *tmpStride];\
2150         const int tmp2= tmp[2 *tmpStride];\
2151         const int tmp3= tmp[3 *tmpStride];\
2152         const int tmp4= tmp[4 *tmpStride];\
2153         const int tmp5= tmp[5 *tmpStride];\
2154         const int tmp6= tmp[6 *tmpStride];\
2155         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2156         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2157         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2158         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2159         dst++;\
2160         tmp++;\
2161     }\
2162 }\
2163 \
2164 static void OPNAME ## h264_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2165     const int h=8;\
2166     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2167     int i;\
2168     for(i=0; i<h; i++)\
2169     {\
2170         OP(dst[0], (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]));\
2171         OP(dst[1], (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]));\
2172         OP(dst[2], (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]));\
2173         OP(dst[3], (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]));\
2174         OP(dst[4], (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]));\
2175         OP(dst[5], (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]));\
2176         OP(dst[6], (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]));\
2177         OP(dst[7], (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]));\
2178         dst+=dstStride;\
2179         src+=srcStride;\
2180     }\
2181 }\
2182 \
2183 static void OPNAME ## h264_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2184     const int w=8;\
2185     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2186     int i;\
2187     for(i=0; i<w; i++)\
2188     {\
2189         const int srcB= src[-2*srcStride];\
2190         const int srcA= src[-1*srcStride];\
2191         const int src0= src[0 *srcStride];\
2192         const int src1= src[1 *srcStride];\
2193         const int src2= src[2 *srcStride];\
2194         const int src3= src[3 *srcStride];\
2195         const int src4= src[4 *srcStride];\
2196         const int src5= src[5 *srcStride];\
2197         const int src6= src[6 *srcStride];\
2198         const int src7= src[7 *srcStride];\
2199         const int src8= src[8 *srcStride];\
2200         const int src9= src[9 *srcStride];\
2201         const int src10=src[10*srcStride];\
2202         OP(dst[0*dstStride], (src0+src1)*20 - (srcA+src2)*5 + (srcB+src3));\
2203         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*5 + (srcA+src4));\
2204         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*5 + (src0+src5));\
2205         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*5 + (src1+src6));\
2206         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*5 + (src2+src7));\
2207         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*5 + (src3+src8));\
2208         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*5 + (src4+src9));\
2209         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src9)*5 + (src5+src10));\
2210         dst++;\
2211         src++;\
2212     }\
2213 }\
2214 \
2215 static void OPNAME ## h264_qpel8_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2216     const int h=8;\
2217     const int w=8;\
2218     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
2219     int i;\
2220     src -= 2*srcStride;\
2221     for(i=0; i<h+5; i++)\
2222     {\
2223         tmp[0]= (src[0]+src[1])*20 - (src[-1]+src[2])*5 + (src[-2]+src[3 ]);\
2224         tmp[1]= (src[1]+src[2])*20 - (src[0 ]+src[3])*5 + (src[-1]+src[4 ]);\
2225         tmp[2]= (src[2]+src[3])*20 - (src[1 ]+src[4])*5 + (src[0 ]+src[5 ]);\
2226         tmp[3]= (src[3]+src[4])*20 - (src[2 ]+src[5])*5 + (src[1 ]+src[6 ]);\
2227         tmp[4]= (src[4]+src[5])*20 - (src[3 ]+src[6])*5 + (src[2 ]+src[7 ]);\
2228         tmp[5]= (src[5]+src[6])*20 - (src[4 ]+src[7])*5 + (src[3 ]+src[8 ]);\
2229         tmp[6]= (src[6]+src[7])*20 - (src[5 ]+src[8])*5 + (src[4 ]+src[9 ]);\
2230         tmp[7]= (src[7]+src[8])*20 - (src[6 ]+src[9])*5 + (src[5 ]+src[10]);\
2231         tmp+=tmpStride;\
2232         src+=srcStride;\
2233     }\
2234     tmp -= tmpStride*(h+5-2);\
2235     for(i=0; i<w; i++)\
2236     {\
2237         const int tmpB= tmp[-2*tmpStride];\
2238         const int tmpA= tmp[-1*tmpStride];\
2239         const int tmp0= tmp[0 *tmpStride];\
2240         const int tmp1= tmp[1 *tmpStride];\
2241         const int tmp2= tmp[2 *tmpStride];\
2242         const int tmp3= tmp[3 *tmpStride];\
2243         const int tmp4= tmp[4 *tmpStride];\
2244         const int tmp5= tmp[5 *tmpStride];\
2245         const int tmp6= tmp[6 *tmpStride];\
2246         const int tmp7= tmp[7 *tmpStride];\
2247         const int tmp8= tmp[8 *tmpStride];\
2248         const int tmp9= tmp[9 *tmpStride];\
2249         const int tmp10=tmp[10*tmpStride];\
2250         OP2(dst[0*dstStride], (tmp0+tmp1)*20 - (tmpA+tmp2)*5 + (tmpB+tmp3));\
2251         OP2(dst[1*dstStride], (tmp1+tmp2)*20 - (tmp0+tmp3)*5 + (tmpA+tmp4));\
2252         OP2(dst[2*dstStride], (tmp2+tmp3)*20 - (tmp1+tmp4)*5 + (tmp0+tmp5));\
2253         OP2(dst[3*dstStride], (tmp3+tmp4)*20 - (tmp2+tmp5)*5 + (tmp1+tmp6));\
2254         OP2(dst[4*dstStride], (tmp4+tmp5)*20 - (tmp3+tmp6)*5 + (tmp2+tmp7));\
2255         OP2(dst[5*dstStride], (tmp5+tmp6)*20 - (tmp4+tmp7)*5 + (tmp3+tmp8));\
2256         OP2(dst[6*dstStride], (tmp6+tmp7)*20 - (tmp5+tmp8)*5 + (tmp4+tmp9));\
2257         OP2(dst[7*dstStride], (tmp7+tmp8)*20 - (tmp6+tmp9)*5 + (tmp5+tmp10));\
2258         dst++;\
2259         tmp++;\
2260     }\
2261 }\
2262 \
2263 static void OPNAME ## h264_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2264     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2265     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2266     src += 8*srcStride;\
2267     dst += 8*dstStride;\
2268     OPNAME ## h264_qpel8_v_lowpass(dst  , src  , dstStride, srcStride);\
2269     OPNAME ## h264_qpel8_v_lowpass(dst+8, src+8, dstStride, srcStride);\
2270 }\
2271 \
2272 static void OPNAME ## h264_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
2273     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2274     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2275     src += 8*srcStride;\
2276     dst += 8*dstStride;\
2277     OPNAME ## h264_qpel8_h_lowpass(dst  , src  , dstStride, srcStride);\
2278     OPNAME ## h264_qpel8_h_lowpass(dst+8, src+8, dstStride, srcStride);\
2279 }\
2280 \
2281 static void OPNAME ## h264_qpel16_hv_lowpass(uint8_t *dst, int16_t *tmp, uint8_t *src, int dstStride, int tmpStride, int srcStride){\
2282     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2283     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2284     src += 8*srcStride;\
2285     dst += 8*dstStride;\
2286     OPNAME ## h264_qpel8_hv_lowpass(dst  , tmp  , src  , dstStride, tmpStride, srcStride);\
2287     OPNAME ## h264_qpel8_hv_lowpass(dst+8, tmp+8, src+8, dstStride, tmpStride, srcStride);\
2288 }\
2289
2290 #define H264_MC(OPNAME, SIZE) \
2291 static void OPNAME ## h264_qpel ## SIZE ## _mc00_c (uint8_t *dst, uint8_t *src, int stride){\
2292     OPNAME ## pixels ## SIZE ## _c(dst, src, stride, SIZE);\
2293 }\
2294 \
2295 static void OPNAME ## h264_qpel ## SIZE ## _mc10_c(uint8_t *dst, uint8_t *src, int stride){\
2296     uint8_t half[SIZE*SIZE];\
2297     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2298     OPNAME ## pixels ## SIZE ## _l2(dst, src, half, stride, stride, SIZE, SIZE);\
2299 }\
2300 \
2301 static void OPNAME ## h264_qpel ## SIZE ## _mc20_c(uint8_t *dst, uint8_t *src, int stride){\
2302     OPNAME ## h264_qpel ## SIZE ## _h_lowpass(dst, src, stride, stride);\
2303 }\
2304 \
2305 static void OPNAME ## h264_qpel ## SIZE ## _mc30_c(uint8_t *dst, uint8_t *src, int stride){\
2306     uint8_t half[SIZE*SIZE];\
2307     put_h264_qpel ## SIZE ## _h_lowpass(half, src, SIZE, stride);\
2308     OPNAME ## pixels ## SIZE ## _l2(dst, src+1, half, stride, stride, SIZE, SIZE);\
2309 }\
2310 \
2311 static void OPNAME ## h264_qpel ## SIZE ## _mc01_c(uint8_t *dst, uint8_t *src, int stride){\
2312     uint8_t full[SIZE*(SIZE+5)];\
2313     uint8_t * const full_mid= full + SIZE*2;\
2314     uint8_t half[SIZE*SIZE];\
2315     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2316     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2317     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid, half, stride, SIZE, SIZE, SIZE);\
2318 }\
2319 \
2320 static void OPNAME ## h264_qpel ## SIZE ## _mc02_c(uint8_t *dst, uint8_t *src, int stride){\
2321     uint8_t full[SIZE*(SIZE+5)];\
2322     uint8_t * const full_mid= full + SIZE*2;\
2323     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2324     OPNAME ## h264_qpel ## SIZE ## _v_lowpass(dst, full_mid, stride, SIZE);\
2325 }\
2326 \
2327 static void OPNAME ## h264_qpel ## SIZE ## _mc03_c(uint8_t *dst, uint8_t *src, int stride){\
2328     uint8_t full[SIZE*(SIZE+5)];\
2329     uint8_t * const full_mid= full + SIZE*2;\
2330     uint8_t half[SIZE*SIZE];\
2331     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2332     put_h264_qpel ## SIZE ## _v_lowpass(half, full_mid, SIZE, SIZE);\
2333     OPNAME ## pixels ## SIZE ## _l2(dst, full_mid+SIZE, half, stride, SIZE, SIZE, SIZE);\
2334 }\
2335 \
2336 static void OPNAME ## h264_qpel ## SIZE ## _mc11_c(uint8_t *dst, uint8_t *src, int stride){\
2337     uint8_t full[SIZE*(SIZE+5)];\
2338     uint8_t * const full_mid= full + SIZE*2;\
2339     uint8_t halfH[SIZE*SIZE];\
2340     uint8_t halfV[SIZE*SIZE];\
2341     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2342     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2343     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2344     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2345 }\
2346 \
2347 static void OPNAME ## h264_qpel ## SIZE ## _mc31_c(uint8_t *dst, uint8_t *src, int stride){\
2348     uint8_t full[SIZE*(SIZE+5)];\
2349     uint8_t * const full_mid= full + SIZE*2;\
2350     uint8_t halfH[SIZE*SIZE];\
2351     uint8_t halfV[SIZE*SIZE];\
2352     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2353     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2354     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2355     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2356 }\
2357 \
2358 static void OPNAME ## h264_qpel ## SIZE ## _mc13_c(uint8_t *dst, uint8_t *src, int stride){\
2359     uint8_t full[SIZE*(SIZE+5)];\
2360     uint8_t * const full_mid= full + SIZE*2;\
2361     uint8_t halfH[SIZE*SIZE];\
2362     uint8_t halfV[SIZE*SIZE];\
2363     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2364     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2365     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2366     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2367 }\
2368 \
2369 static void OPNAME ## h264_qpel ## SIZE ## _mc33_c(uint8_t *dst, uint8_t *src, int stride){\
2370     uint8_t full[SIZE*(SIZE+5)];\
2371     uint8_t * const full_mid= full + SIZE*2;\
2372     uint8_t halfH[SIZE*SIZE];\
2373     uint8_t halfV[SIZE*SIZE];\
2374     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2375     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2376     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2377     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfV, stride, SIZE, SIZE, SIZE);\
2378 }\
2379 \
2380 static void OPNAME ## h264_qpel ## SIZE ## _mc22_c(uint8_t *dst, uint8_t *src, int stride){\
2381     int16_t tmp[SIZE*(SIZE+5)];\
2382     OPNAME ## h264_qpel ## SIZE ## _hv_lowpass(dst, tmp, src, stride, SIZE, stride);\
2383 }\
2384 \
2385 static void OPNAME ## h264_qpel ## SIZE ## _mc21_c(uint8_t *dst, uint8_t *src, int stride){\
2386     int16_t tmp[SIZE*(SIZE+5)];\
2387     uint8_t halfH[SIZE*SIZE];\
2388     uint8_t halfHV[SIZE*SIZE];\
2389     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src, SIZE, stride);\
2390     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2391     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2392 }\
2393 \
2394 static void OPNAME ## h264_qpel ## SIZE ## _mc23_c(uint8_t *dst, uint8_t *src, int stride){\
2395     int16_t tmp[SIZE*(SIZE+5)];\
2396     uint8_t halfH[SIZE*SIZE];\
2397     uint8_t halfHV[SIZE*SIZE];\
2398     put_h264_qpel ## SIZE ## _h_lowpass(halfH, src + stride, SIZE, stride);\
2399     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2400     OPNAME ## pixels ## SIZE ## _l2(dst, halfH, halfHV, stride, SIZE, SIZE, SIZE);\
2401 }\
2402 \
2403 static void OPNAME ## h264_qpel ## SIZE ## _mc12_c(uint8_t *dst, uint8_t *src, int stride){\
2404     uint8_t full[SIZE*(SIZE+5)];\
2405     uint8_t * const full_mid= full + SIZE*2;\
2406     int16_t tmp[SIZE*(SIZE+5)];\
2407     uint8_t halfV[SIZE*SIZE];\
2408     uint8_t halfHV[SIZE*SIZE];\
2409     copy_block ## SIZE (full, src - stride*2, SIZE,  stride, SIZE + 5);\
2410     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2411     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2412     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2413 }\
2414 \
2415 static void OPNAME ## h264_qpel ## SIZE ## _mc32_c(uint8_t *dst, uint8_t *src, int stride){\
2416     uint8_t full[SIZE*(SIZE+5)];\
2417     uint8_t * const full_mid= full + SIZE*2;\
2418     int16_t tmp[SIZE*(SIZE+5)];\
2419     uint8_t halfV[SIZE*SIZE];\
2420     uint8_t halfHV[SIZE*SIZE];\
2421     copy_block ## SIZE (full, src - stride*2 + 1, SIZE,  stride, SIZE + 5);\
2422     put_h264_qpel ## SIZE ## _v_lowpass(halfV, full_mid, SIZE, SIZE);\
2423     put_h264_qpel ## SIZE ## _hv_lowpass(halfHV, tmp, src, SIZE, SIZE, stride);\
2424     OPNAME ## pixels ## SIZE ## _l2(dst, halfV, halfHV, stride, SIZE, SIZE, SIZE);\
2425 }\
2426
2427 #define op_avg(a, b)  a = (((a)+cm[((b) + 16)>>5]+1)>>1)
2428 //#define op_avg2(a, b) a = (((a)*w1+cm[((b) + 16)>>5]*w2 + o + 64)>>7)
2429 #define op_put(a, b)  a = cm[((b) + 16)>>5]
2430 #define op2_avg(a, b)  a = (((a)+cm[((b) + 512)>>10]+1)>>1)
2431 #define op2_put(a, b)  a = cm[((b) + 512)>>10]
2432
2433 H264_LOWPASS(put_       , op_put, op2_put)
2434 H264_LOWPASS(avg_       , op_avg, op2_avg)
2435 H264_MC(put_, 2)
2436 H264_MC(put_, 4)
2437 H264_MC(put_, 8)
2438 H264_MC(put_, 16)
2439 H264_MC(avg_, 4)
2440 H264_MC(avg_, 8)
2441 H264_MC(avg_, 16)
2442
2443 #undef op_avg
2444 #undef op_put
2445 #undef op2_avg
2446 #undef op2_put
2447 #endif
2448
2449 #define op_scale1(x)  block[x] = av_clip_uint8( (block[x]*weight + offset) >> log2_denom )
2450 #define op_scale2(x)  dst[x] = av_clip_uint8( (src[x]*weights + dst[x]*weightd + offset) >> (log2_denom+1))
2451 #define H264_WEIGHT(W,H) \
2452 static void weight_h264_pixels ## W ## x ## H ## _c(uint8_t *block, int stride, int log2_denom, int weight, int offset){ \
2453     int y; \
2454     offset <<= log2_denom; \
2455     if(log2_denom) offset += 1<<(log2_denom-1); \
2456     for(y=0; y<H; y++, block += stride){ \
2457         op_scale1(0); \
2458         op_scale1(1); \
2459         if(W==2) continue; \
2460         op_scale1(2); \
2461         op_scale1(3); \
2462         if(W==4) continue; \
2463         op_scale1(4); \
2464         op_scale1(5); \
2465         op_scale1(6); \
2466         op_scale1(7); \
2467         if(W==8) continue; \
2468         op_scale1(8); \
2469         op_scale1(9); \
2470         op_scale1(10); \
2471         op_scale1(11); \
2472         op_scale1(12); \
2473         op_scale1(13); \
2474         op_scale1(14); \
2475         op_scale1(15); \
2476     } \
2477 } \
2478 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){ \
2479     int y; \
2480     offset = ((offset + 1) | 1) << log2_denom; \
2481     for(y=0; y<H; y++, dst += stride, src += stride){ \
2482         op_scale2(0); \
2483         op_scale2(1); \
2484         if(W==2) continue; \
2485         op_scale2(2); \
2486         op_scale2(3); \
2487         if(W==4) continue; \
2488         op_scale2(4); \
2489         op_scale2(5); \
2490         op_scale2(6); \
2491         op_scale2(7); \
2492         if(W==8) continue; \
2493         op_scale2(8); \
2494         op_scale2(9); \
2495         op_scale2(10); \
2496         op_scale2(11); \
2497         op_scale2(12); \
2498         op_scale2(13); \
2499         op_scale2(14); \
2500         op_scale2(15); \
2501     } \
2502 }
2503
2504 H264_WEIGHT(16,16)
2505 H264_WEIGHT(16,8)
2506 H264_WEIGHT(8,16)
2507 H264_WEIGHT(8,8)
2508 H264_WEIGHT(8,4)
2509 H264_WEIGHT(4,8)
2510 H264_WEIGHT(4,4)
2511 H264_WEIGHT(4,2)
2512 H264_WEIGHT(2,4)
2513 H264_WEIGHT(2,2)
2514
2515 #undef op_scale1
2516 #undef op_scale2
2517 #undef H264_WEIGHT
2518
2519 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
2520     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2521     int i;
2522
2523     for(i=0; i<h; i++){
2524         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
2525         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
2526         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
2527         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
2528         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
2529         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
2530         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
2531         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
2532         dst+=dstStride;
2533         src+=srcStride;
2534     }
2535 }
2536
2537 #ifdef CONFIG_CAVS_DECODER
2538 /* AVS specific */
2539 void ff_cavsdsp_init(DSPContext* c, AVCodecContext *avctx);
2540
2541 void ff_put_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2542     put_pixels8_c(dst, src, stride, 8);
2543 }
2544 void ff_avg_cavs_qpel8_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2545     avg_pixels8_c(dst, src, stride, 8);
2546 }
2547 void ff_put_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2548     put_pixels16_c(dst, src, stride, 16);
2549 }
2550 void ff_avg_cavs_qpel16_mc00_c(uint8_t *dst, uint8_t *src, int stride) {
2551     avg_pixels16_c(dst, src, stride, 16);
2552 }
2553 #endif /* CONFIG_CAVS_DECODER */
2554
2555 #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
2556 /* VC-1 specific */
2557 void ff_vc1dsp_init(DSPContext* c, AVCodecContext *avctx);
2558
2559 void ff_put_vc1_mspel_mc00_c(uint8_t *dst, uint8_t *src, int stride, int rnd) {
2560     put_pixels8_c(dst, src, stride, 8);
2561 }
2562 #endif /* CONFIG_VC1_DECODER||CONFIG_WMV3_DECODER */
2563
2564 #if defined(CONFIG_H264_ENCODER)
2565 /* H264 specific */
2566 void ff_h264dspenc_init(DSPContext* c, AVCodecContext *avctx);
2567 #endif /* CONFIG_H264_ENCODER */
2568
2569 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
2570     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
2571     int i;
2572
2573     for(i=0; i<w; i++){
2574         const int src_1= src[ -srcStride];
2575         const int src0 = src[0          ];
2576         const int src1 = src[  srcStride];
2577         const int src2 = src[2*srcStride];
2578         const int src3 = src[3*srcStride];
2579         const int src4 = src[4*srcStride];
2580         const int src5 = src[5*srcStride];
2581         const int src6 = src[6*srcStride];
2582         const int src7 = src[7*srcStride];
2583         const int src8 = src[8*srcStride];
2584         const int src9 = src[9*srcStride];
2585         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
2586         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
2587         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
2588         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
2589         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
2590         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
2591         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
2592         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
2593         src++;
2594         dst++;
2595     }
2596 }
2597
2598 static void put_mspel8_mc00_c (uint8_t *dst, uint8_t *src, int stride){
2599     put_pixels8_c(dst, src, stride, 8);
2600 }
2601
2602 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
2603     uint8_t half[64];
2604     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
2605     put_pixels8_l2(dst, src, half, stride, stride, 8, 8);
2606 }
2607
2608 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
2609     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
2610 }
2611
2612 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
2613     uint8_t half[64];
2614     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
2615     put_pixels8_l2(dst, src+1, half, stride, stride, 8, 8);
2616 }
2617
2618 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
2619     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
2620 }
2621
2622 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
2623     uint8_t halfH[88];
2624     uint8_t halfV[64];
2625     uint8_t halfHV[64];
2626     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2627     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
2628     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
2629     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
2630 }
2631 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
2632     uint8_t halfH[88];
2633     uint8_t halfV[64];
2634     uint8_t halfHV[64];
2635     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2636     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
2637     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
2638     put_pixels8_l2(dst, halfV, halfHV, stride, 8, 8, 8);
2639 }
2640 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
2641     uint8_t halfH[88];
2642     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
2643     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
2644 }
2645
2646 static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
2647     if(ENABLE_ANY_H263) {
2648     int x;
2649     const int strength= ff_h263_loop_filter_strength[qscale];
2650
2651     for(x=0; x<8; x++){
2652         int d1, d2, ad1;
2653         int p0= src[x-2*stride];
2654         int p1= src[x-1*stride];
2655         int p2= src[x+0*stride];
2656         int p3= src[x+1*stride];
2657         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
2658
2659         if     (d<-2*strength) d1= 0;
2660         else if(d<-  strength) d1=-2*strength - d;
2661         else if(d<   strength) d1= d;
2662         else if(d< 2*strength) d1= 2*strength - d;
2663         else                   d1= 0;
2664
2665         p1 += d1;
2666         p2 -= d1;
2667         if(p1&256) p1= ~(p1>>31);
2668         if(p2&256) p2= ~(p2>>31);
2669
2670         src[x-1*stride] = p1;
2671         src[x+0*stride] = p2;
2672
2673         ad1= FFABS(d1)>>1;
2674
2675         d2= av_clip((p0-p3)/4, -ad1, ad1);
2676
2677         src[x-2*stride] = p0 - d2;
2678         src[x+  stride] = p3 + d2;
2679     }
2680     }
2681 }
2682
2683 static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
2684     if(ENABLE_ANY_H263) {
2685     int y;
2686     const int strength= ff_h263_loop_filter_strength[qscale];
2687
2688     for(y=0; y<8; y++){
2689         int d1, d2, ad1;
2690         int p0= src[y*stride-2];
2691         int p1= src[y*stride-1];
2692         int p2= src[y*stride+0];
2693         int p3= src[y*stride+1];
2694         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
2695
2696         if     (d<-2*strength) d1= 0;
2697         else if(d<-  strength) d1=-2*strength - d;
2698         else if(d<   strength) d1= d;
2699         else if(d< 2*strength) d1= 2*strength - d;
2700         else                   d1= 0;
2701
2702         p1 += d1;
2703         p2 -= d1;
2704         if(p1&256) p1= ~(p1>>31);
2705         if(p2&256) p2= ~(p2>>31);
2706
2707         src[y*stride-1] = p1;
2708         src[y*stride+0] = p2;
2709
2710         ad1= FFABS(d1)>>1;
2711
2712         d2= av_clip((p0-p3)/4, -ad1, ad1);
2713
2714         src[y*stride-2] = p0 - d2;
2715         src[y*stride+1] = p3 + d2;
2716     }
2717     }
2718 }
2719
2720 static void h261_loop_filter_c(uint8_t *src, int stride){
2721     int x,y,xy,yz;
2722     int temp[64];
2723
2724     for(x=0; x<8; x++){
2725         temp[x      ] = 4*src[x           ];
2726         temp[x + 7*8] = 4*src[x + 7*stride];
2727     }
2728     for(y=1; y<7; y++){
2729         for(x=0; x<8; x++){
2730             xy = y * stride + x;
2731             yz = y * 8 + x;
2732             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
2733         }
2734     }
2735
2736     for(y=0; y<8; y++){
2737         src[  y*stride] = (temp[  y*8] + 2)>>2;
2738         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
2739         for(x=1; x<7; x++){
2740             xy = y * stride + x;
2741             yz = y * 8 + x;
2742             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
2743         }
2744     }
2745 }
2746
2747 static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
2748 {
2749     int i, d;
2750     for( i = 0; i < 4; i++ ) {
2751         if( tc0[i] < 0 ) {
2752             pix += 4*ystride;
2753             continue;
2754         }
2755         for( d = 0; d < 4; d++ ) {
2756             const int p0 = pix[-1*xstride];
2757             const int p1 = pix[-2*xstride];
2758             const int p2 = pix[-3*xstride];
2759             const int q0 = pix[0];
2760             const int q1 = pix[1*xstride];
2761             const int q2 = pix[2*xstride];
2762
2763             if( FFABS( p0 - q0 ) < alpha &&
2764                 FFABS( p1 - p0 ) < beta &&
2765                 FFABS( q1 - q0 ) < beta ) {
2766
2767                 int tc = tc0[i];
2768                 int i_delta;
2769
2770                 if( FFABS( p2 - p0 ) < beta ) {
2771                     pix[-2*xstride] = p1 + av_clip( (( p2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - p1, -tc0[i], tc0[i] );
2772                     tc++;
2773                 }
2774                 if( FFABS( q2 - q0 ) < beta ) {
2775                     pix[   xstride] = q1 + av_clip( (( q2 + ( ( p0 + q0 + 1 ) >> 1 ) ) >> 1) - q1, -tc0[i], tc0[i] );
2776                     tc++;
2777                 }
2778
2779                 i_delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
2780                 pix[-xstride] = av_clip_uint8( p0 + i_delta );    /* p0' */
2781                 pix[0]        = av_clip_uint8( q0 - i_delta );    /* q0' */
2782             }
2783             pix += ystride;
2784         }
2785     }
2786 }
2787 static void h264_v_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2788 {
2789     h264_loop_filter_luma_c(pix, stride, 1, alpha, beta, tc0);
2790 }
2791 static void h264_h_loop_filter_luma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2792 {
2793     h264_loop_filter_luma_c(pix, 1, stride, alpha, beta, tc0);
2794 }
2795
2796 static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
2797 {
2798     int i, d;
2799     for( i = 0; i < 4; i++ ) {
2800         const int tc = tc0[i];
2801         if( tc <= 0 ) {
2802             pix += 2*ystride;
2803             continue;
2804         }
2805         for( d = 0; d < 2; d++ ) {
2806             const int p0 = pix[-1*xstride];
2807             const int p1 = pix[-2*xstride];
2808             const int q0 = pix[0];
2809             const int q1 = pix[1*xstride];
2810
2811             if( FFABS( p0 - q0 ) < alpha &&
2812                 FFABS( p1 - p0 ) < beta &&
2813                 FFABS( q1 - q0 ) < beta ) {
2814
2815                 int delta = av_clip( (((q0 - p0 ) << 2) + (p1 - q1) + 4) >> 3, -tc, tc );
2816
2817                 pix[-xstride] = av_clip_uint8( p0 + delta );    /* p0' */
2818                 pix[0]        = av_clip_uint8( q0 - delta );    /* q0' */
2819             }
2820             pix += ystride;
2821         }
2822     }
2823 }
2824 static void h264_v_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2825 {
2826     h264_loop_filter_chroma_c(pix, stride, 1, alpha, beta, tc0);
2827 }
2828 static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
2829 {
2830     h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
2831 }
2832
2833 static inline void h264_loop_filter_chroma_intra_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta)
2834 {
2835     int d;
2836     for( d = 0; d < 8; d++ ) {
2837         const int p0 = pix[-1*xstride];
2838         const int p1 = pix[-2*xstride];
2839         const int q0 = pix[0];
2840         const int q1 = pix[1*xstride];
2841
2842         if( FFABS( p0 - q0 ) < alpha &&
2843             FFABS( p1 - p0 ) < beta &&
2844             FFABS( q1 - q0 ) < beta ) {
2845
2846             pix[-xstride] = ( 2*p1 + p0 + q1 + 2 ) >> 2;   /* p0' */
2847             pix[0]        = ( 2*q1 + q0 + p1 + 2 ) >> 2;   /* q0' */
2848         }
2849         pix += ystride;
2850     }
2851 }
2852 static void h264_v_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
2853 {
2854     h264_loop_filter_chroma_intra_c(pix, stride, 1, alpha, beta);
2855 }
2856 static void h264_h_loop_filter_chroma_intra_c(uint8_t *pix, int stride, int alpha, int beta)
2857 {
2858     h264_loop_filter_chroma_intra_c(pix, 1, stride, alpha, beta);
2859 }
2860
2861 static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2862 {
2863     int s, i;
2864
2865     s = 0;
2866     for(i=0;i<h;i++) {
2867         s += abs(pix1[0] - pix2[0]);
2868         s += abs(pix1[1] - pix2[1]);
2869         s += abs(pix1[2] - pix2[2]);
2870         s += abs(pix1[3] - pix2[3]);
2871         s += abs(pix1[4] - pix2[4]);
2872         s += abs(pix1[5] - pix2[5]);
2873         s += abs(pix1[6] - pix2[6]);
2874         s += abs(pix1[7] - pix2[7]);
2875         s += abs(pix1[8] - pix2[8]);
2876         s += abs(pix1[9] - pix2[9]);
2877         s += abs(pix1[10] - pix2[10]);
2878         s += abs(pix1[11] - pix2[11]);
2879         s += abs(pix1[12] - pix2[12]);
2880         s += abs(pix1[13] - pix2[13]);
2881         s += abs(pix1[14] - pix2[14]);
2882         s += abs(pix1[15] - pix2[15]);
2883         pix1 += line_size;
2884         pix2 += line_size;
2885     }
2886     return s;
2887 }
2888
2889 static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2890 {
2891     int s, i;
2892
2893     s = 0;
2894     for(i=0;i<h;i++) {
2895         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
2896         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
2897         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
2898         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
2899         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
2900         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
2901         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
2902         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
2903         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
2904         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
2905         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
2906         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
2907         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
2908         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
2909         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
2910         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
2911         pix1 += line_size;
2912         pix2 += line_size;
2913     }
2914     return s;
2915 }
2916
2917 static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2918 {
2919     int s, i;
2920     uint8_t *pix3 = pix2 + line_size;
2921
2922     s = 0;
2923     for(i=0;i<h;i++) {
2924         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
2925         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
2926         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
2927         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
2928         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
2929         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
2930         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
2931         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
2932         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
2933         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
2934         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
2935         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
2936         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
2937         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
2938         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
2939         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
2940         pix1 += line_size;
2941         pix2 += line_size;
2942         pix3 += line_size;
2943     }
2944     return s;
2945 }
2946
2947 static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2948 {
2949     int s, i;
2950     uint8_t *pix3 = pix2 + line_size;
2951
2952     s = 0;
2953     for(i=0;i<h;i++) {
2954         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
2955         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
2956         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
2957         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
2958         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
2959         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
2960         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
2961         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
2962         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
2963         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
2964         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
2965         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
2966         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
2967         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
2968         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
2969         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
2970         pix1 += line_size;
2971         pix2 += line_size;
2972         pix3 += line_size;
2973     }
2974     return s;
2975 }
2976
2977 static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2978 {
2979     int s, i;
2980
2981     s = 0;
2982     for(i=0;i<h;i++) {
2983         s += abs(pix1[0] - pix2[0]);
2984         s += abs(pix1[1] - pix2[1]);
2985         s += abs(pix1[2] - pix2[2]);
2986         s += abs(pix1[3] - pix2[3]);
2987         s += abs(pix1[4] - pix2[4]);
2988         s += abs(pix1[5] - pix2[5]);
2989         s += abs(pix1[6] - pix2[6]);
2990         s += abs(pix1[7] - pix2[7]);
2991         pix1 += line_size;
2992         pix2 += line_size;
2993     }
2994     return s;
2995 }
2996
2997 static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
2998 {
2999     int s, i;
3000
3001     s = 0;
3002     for(i=0;i<h;i++) {
3003         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
3004         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
3005         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
3006         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
3007         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
3008         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
3009         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
3010         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
3011         pix1 += line_size;
3012         pix2 += line_size;
3013     }
3014     return s;
3015 }
3016
3017 static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3018 {
3019     int s, i;
3020     uint8_t *pix3 = pix2 + line_size;
3021
3022     s = 0;
3023     for(i=0;i<h;i++) {
3024         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
3025         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
3026         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
3027         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
3028         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
3029         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
3030         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
3031         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
3032         pix1 += line_size;
3033         pix2 += line_size;
3034         pix3 += line_size;
3035     }
3036     return s;
3037 }
3038
3039 static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
3040 {
3041     int s, i;
3042     uint8_t *pix3 = pix2 + line_size;
3043
3044     s = 0;
3045     for(i=0;i<h;i++) {
3046         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
3047         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
3048         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
3049         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
3050         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
3051         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
3052         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
3053         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
3054         pix1 += line_size;
3055         pix2 += line_size;
3056         pix3 += line_size;
3057     }
3058     return s;
3059 }
3060
3061 static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
3062     MpegEncContext *c = v;
3063     int score1=0;
3064     int score2=0;
3065     int x,y;
3066
3067     for(y=0; y<h; y++){
3068         for(x=0; x<16; x++){
3069             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
3070         }
3071         if(y+1<h){
3072             for(x=0; x<15; x++){
3073                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
3074                              - s1[x+1] + s1[x+1+stride])
3075                         -FFABS(  s2[x  ] - s2[x  +stride]
3076                              - s2[x+1] + s2[x+1+stride]);
3077             }
3078         }
3079         s1+= stride;
3080         s2+= stride;
3081     }
3082
3083     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
3084     else  return score1 + FFABS(score2)*8;
3085 }
3086
3087 static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
3088     MpegEncContext *c = v;
3089     int score1=0;
3090     int score2=0;
3091     int x,y;
3092
3093     for(y=0; y<h; y++){
3094         for(x=0; x<8; x++){
3095             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
3096         }
3097         if(y+1<h){
3098             for(x=0; x<7; x++){
3099                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
3100                              - s1[x+1] + s1[x+1+stride])
3101                         -FFABS(  s2[x  ] - s2[x  +stride]
3102                              - s2[x+1] + s2[x+1+stride]);
3103             }
3104         }
3105         s1+= stride;
3106         s2+= stride;
3107     }
3108
3109     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
3110     else  return score1 + FFABS(score2)*8;
3111 }
3112
3113 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
3114     int i;
3115     unsigned int sum=0;
3116
3117     for(i=0; i<8*8; i++){
3118         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
3119         int w= weight[i];
3120         b>>= RECON_SHIFT;
3121         assert(-512<b && b<512);
3122
3123         sum += (w*b)*(w*b)>>4;
3124     }
3125     return sum>>2;
3126 }
3127
3128 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
3129     int i;
3130
3131     for(i=0; i<8*8; i++){
3132         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
3133     }
3134 }
3135
3136 /**
3137  * permutes an 8x8 block.
3138  * @param block the block which will be permuted according to the given permutation vector
3139  * @param permutation the permutation vector
3140  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3141  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3142  *                  (inverse) permutated to scantable order!
3143  */
3144 void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
3145 {
3146     int i;
3147     DCTELEM temp[64];
3148
3149     if(last<=0) return;
3150     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3151
3152     for(i=0; i<=last; i++){
3153         const int j= scantable[i];
3154         temp[j]= block[j];
3155         block[j]=0;
3156     }
3157
3158     for(i=0; i<=last; i++){
3159         const int j= scantable[i];
3160         const int perm_j= permutation[j];
3161         block[perm_j]= temp[j];
3162     }
3163 }
3164
3165 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
3166     return 0;
3167 }
3168
3169 void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
3170     int i;
3171
3172     memset(cmp, 0, sizeof(void*)*5);
3173
3174     for(i=0; i<5; i++){
3175         switch(type&0xFF){
3176         case FF_CMP_SAD:
3177             cmp[i]= c->sad[i];
3178             break;
3179         case FF_CMP_SATD:
3180             cmp[i]= c->hadamard8_diff[i];
3181             break;
3182         case FF_CMP_SSE:
3183             cmp[i]= c->sse[i];
3184             break;
3185         case FF_CMP_DCT:
3186             cmp[i]= c->dct_sad[i];
3187             break;
3188         case FF_CMP_DCT264:
3189             cmp[i]= c->dct264_sad[i];
3190             break;
3191         case FF_CMP_DCTMAX:
3192             cmp[i]= c->dct_max[i];
3193             break;
3194         case FF_CMP_PSNR:
3195             cmp[i]= c->quant_psnr[i];
3196             break;
3197         case FF_CMP_BIT:
3198             cmp[i]= c->bit[i];
3199             break;
3200         case FF_CMP_RD:
3201             cmp[i]= c->rd[i];
3202             break;
3203         case FF_CMP_VSAD:
3204             cmp[i]= c->vsad[i];
3205             break;
3206         case FF_CMP_VSSE:
3207             cmp[i]= c->vsse[i];
3208             break;
3209         case FF_CMP_ZERO:
3210             cmp[i]= zero_cmp;
3211             break;
3212         case FF_CMP_NSSE:
3213             cmp[i]= c->nsse[i];
3214             break;
3215 #ifdef CONFIG_SNOW_ENCODER
3216         case FF_CMP_W53:
3217             cmp[i]= c->w53[i];
3218             break;
3219         case FF_CMP_W97:
3220             cmp[i]= c->w97[i];
3221             break;
3222 #endif
3223         default:
3224             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selection\n");
3225         }
3226     }
3227 }
3228
3229 /**
3230  * memset(blocks, 0, sizeof(DCTELEM)*6*64)
3231  */
3232 static void clear_blocks_c(DCTELEM *blocks)
3233 {
3234     memset(blocks, 0, sizeof(DCTELEM)*6*64);
3235 }
3236
3237 static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
3238     int i;
3239     for(i=0; i+7<w; i+=8){
3240         dst[i+0] += src[i+0];
3241         dst[i+1] += src[i+1];
3242         dst[i+2] += src[i+2];
3243         dst[i+3] += src[i+3];
3244         dst[i+4] += src[i+4];
3245         dst[i+5] += src[i+5];
3246         dst[i+6] += src[i+6];
3247         dst[i+7] += src[i+7];
3248     }
3249     for(; i<w; i++)
3250         dst[i+0] += src[i+0];
3251 }
3252
3253 static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
3254     int i;
3255     for(i=0; i+7<w; i+=8){
3256         dst[i+0] = src1[i+0]-src2[i+0];
3257         dst[i+1] = src1[i+1]-src2[i+1];
3258         dst[i+2] = src1[i+2]-src2[i+2];
3259         dst[i+3] = src1[i+3]-src2[i+3];
3260         dst[i+4] = src1[i+4]-src2[i+4];
3261         dst[i+5] = src1[i+5]-src2[i+5];
3262         dst[i+6] = src1[i+6]-src2[i+6];
3263         dst[i+7] = src1[i+7]-src2[i+7];
3264     }
3265     for(; i<w; i++)
3266         dst[i+0] = src1[i+0]-src2[i+0];
3267 }
3268
3269 static void sub_hfyu_median_prediction_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w, int *left, int *left_top){
3270     int i;
3271     uint8_t l, lt;
3272
3273     l= *left;
3274     lt= *left_top;
3275
3276     for(i=0; i<w; i++){
3277         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
3278         lt= src1[i];
3279         l= src2[i];
3280         dst[i]= l - pred;
3281     }
3282
3283     *left= l;
3284     *left_top= lt;
3285 }
3286
3287 #define BUTTERFLY2(o1,o2,i1,i2) \
3288 o1= (i1)+(i2);\
3289 o2= (i1)-(i2);
3290
3291 #define BUTTERFLY1(x,y) \
3292 {\
3293     int a,b;\
3294     a= x;\
3295     b= y;\
3296     x= a+b;\
3297     y= a-b;\
3298 }
3299
3300 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
3301
3302 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
3303     int i;
3304     int temp[64];
3305     int sum=0;
3306
3307     assert(h==8);
3308
3309     for(i=0; i<8; i++){
3310         //FIXME try pointer walks
3311         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]);
3312         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]);
3313         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]);
3314         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]);
3315
3316         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
3317         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
3318         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
3319         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
3320
3321         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
3322         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
3323         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
3324         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
3325     }
3326
3327     for(i=0; i<8; i++){
3328         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
3329         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
3330         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
3331         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
3332
3333         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
3334         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
3335         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
3336         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
3337
3338         sum +=
3339              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
3340             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
3341             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
3342             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
3343     }
3344 #if 0
3345 static int maxi=0;
3346 if(sum>maxi){
3347     maxi=sum;
3348     printf("MAX:%d\n", maxi);
3349 }
3350 #endif
3351     return sum;
3352 }
3353
3354 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
3355     int i;
3356     int temp[64];
3357     int sum=0;
3358
3359     assert(h==8);
3360
3361     for(i=0; i<8; i++){
3362         //FIXME try pointer walks
3363         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
3364         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
3365         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
3366         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
3367
3368         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
3369         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
3370         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
3371         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
3372
3373         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
3374         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
3375         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
3376         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
3377     }
3378
3379     for(i=0; i<8; i++){
3380         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
3381         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
3382         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
3383         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
3384
3385         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
3386         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
3387         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
3388         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
3389
3390         sum +=
3391              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
3392             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
3393             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
3394             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
3395     }
3396
3397     sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
3398
3399     return sum;
3400 }
3401
3402 static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3403     MpegEncContext * const s= (MpegEncContext *)c;
3404     DECLARE_ALIGNED_16(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3405     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3406
3407     assert(h==8);
3408
3409     s->dsp.diff_pixels(temp, src1, src2, stride);
3410     s->dsp.fdct(temp);
3411     return s->dsp.sum_abs_dctelem(temp);
3412 }
3413
3414 #ifdef CONFIG_GPL
3415 #define DCT8_1D {\
3416     const int s07 = SRC(0) + SRC(7);\
3417     const int s16 = SRC(1) + SRC(6);\
3418     const int s25 = SRC(2) + SRC(5);\
3419     const int s34 = SRC(3) + SRC(4);\
3420     const int a0 = s07 + s34;\
3421     const int a1 = s16 + s25;\
3422     const int a2 = s07 - s34;\
3423     const int a3 = s16 - s25;\
3424     const int d07 = SRC(0) - SRC(7);\
3425     const int d16 = SRC(1) - SRC(6);\
3426     const int d25 = SRC(2) - SRC(5);\
3427     const int d34 = SRC(3) - SRC(4);\
3428     const int a4 = d16 + d25 + (d07 + (d07>>1));\
3429     const int a5 = d07 - d34 - (d25 + (d25>>1));\
3430     const int a6 = d07 + d34 - (d16 + (d16>>1));\
3431     const int a7 = d16 - d25 + (d34 + (d34>>1));\
3432     DST(0,  a0 + a1     ) ;\
3433     DST(1,  a4 + (a7>>2)) ;\
3434     DST(2,  a2 + (a3>>1)) ;\
3435     DST(3,  a5 + (a6>>2)) ;\
3436     DST(4,  a0 - a1     ) ;\
3437     DST(5,  a6 - (a5>>2)) ;\
3438     DST(6, (a2>>1) - a3 ) ;\
3439     DST(7, (a4>>2) - a7 ) ;\
3440 }
3441
3442 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3443     MpegEncContext * const s= (MpegEncContext *)c;
3444     DCTELEM dct[8][8];
3445     int i;
3446     int sum=0;
3447
3448     s->dsp.diff_pixels(dct[0], src1, src2, stride);
3449
3450 #define SRC(x) dct[i][x]
3451 #define DST(x,v) dct[i][x]= v
3452     for( i = 0; i < 8; i++ )
3453         DCT8_1D
3454 #undef SRC
3455 #undef DST
3456
3457 #define SRC(x) dct[x][i]
3458 #define DST(x,v) sum += FFABS(v)
3459     for( i = 0; i < 8; i++ )
3460         DCT8_1D
3461 #undef SRC
3462 #undef DST
3463     return sum;
3464 }
3465 #endif
3466
3467 static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3468     MpegEncContext * const s= (MpegEncContext *)c;
3469     DECLARE_ALIGNED_8(uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3470     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3471     int sum=0, i;
3472
3473     assert(h==8);
3474
3475     s->dsp.diff_pixels(temp, src1, src2, stride);
3476     s->dsp.fdct(temp);
3477
3478     for(i=0; i<64; i++)
3479         sum= FFMAX(sum, FFABS(temp[i]));
3480
3481     return sum;
3482 }
3483
3484 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3485     MpegEncContext * const s= (MpegEncContext *)c;
3486     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64*2/8]);
3487     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3488     DCTELEM * const bak = ((DCTELEM*)aligned_temp)+64;
3489     int sum=0, i;
3490
3491     assert(h==8);
3492     s->mb_intra=0;
3493
3494     s->dsp.diff_pixels(temp, src1, src2, stride);
3495
3496     memcpy(bak, temp, 64*sizeof(DCTELEM));
3497
3498     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3499     s->dct_unquantize_inter(s, temp, 0, s->qscale);
3500     simple_idct(temp); //FIXME
3501
3502     for(i=0; i<64; i++)
3503         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
3504
3505     return sum;
3506 }
3507
3508 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3509     MpegEncContext * const s= (MpegEncContext *)c;
3510     const uint8_t *scantable= s->intra_scantable.permutated;
3511     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3512     DECLARE_ALIGNED_8 (uint64_t, aligned_bak[stride]);
3513     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3514     uint8_t * const bak= (uint8_t*)aligned_bak;
3515     int i, last, run, bits, level, distoration, start_i;
3516     const int esc_length= s->ac_esc_length;
3517     uint8_t * length;
3518     uint8_t * last_length;
3519
3520     assert(h==8);
3521
3522     for(i=0; i<8; i++){
3523         ((uint32_t*)(bak + i*stride))[0]= ((uint32_t*)(src2 + i*stride))[0];
3524         ((uint32_t*)(bak + i*stride))[1]= ((uint32_t*)(src2 + i*stride))[1];
3525     }
3526
3527     s->dsp.diff_pixels(temp, src1, src2, stride);
3528
3529     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3530
3531     bits=0;
3532
3533     if (s->mb_intra) {
3534         start_i = 1;
3535         length     = s->intra_ac_vlc_length;
3536         last_length= s->intra_ac_vlc_last_length;
3537         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
3538     } else {
3539         start_i = 0;
3540         length     = s->inter_ac_vlc_length;
3541         last_length= s->inter_ac_vlc_last_length;
3542     }
3543
3544     if(last>=start_i){
3545         run=0;
3546         for(i=start_i; i<last; i++){
3547             int j= scantable[i];
3548             level= temp[j];
3549
3550             if(level){
3551                 level+=64;
3552                 if((level&(~127)) == 0){
3553                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
3554                 }else
3555                     bits+= esc_length;
3556                 run=0;
3557             }else
3558                 run++;
3559         }
3560         i= scantable[last];
3561
3562         level= temp[i] + 64;
3563
3564         assert(level - 64);
3565
3566         if((level&(~127)) == 0){
3567             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
3568         }else
3569             bits+= esc_length;
3570
3571     }
3572
3573     if(last>=0){
3574         if(s->mb_intra)
3575             s->dct_unquantize_intra(s, temp, 0, s->qscale);
3576         else
3577             s->dct_unquantize_inter(s, temp, 0, s->qscale);
3578     }
3579
3580     s->dsp.idct_add(bak, stride, temp);
3581
3582     distoration= s->dsp.sse[1](NULL, bak, src1, stride, 8);
3583
3584     return distoration + ((bits*s->qscale*s->qscale*109 + 64)>>7);
3585 }
3586
3587 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
3588     MpegEncContext * const s= (MpegEncContext *)c;
3589     const uint8_t *scantable= s->intra_scantable.permutated;
3590     DECLARE_ALIGNED_8 (uint64_t, aligned_temp[sizeof(DCTELEM)*64/8]);
3591     DCTELEM * const temp= (DCTELEM*)aligned_temp;
3592     int i, last, run, bits, level, start_i;
3593     const int esc_length= s->ac_esc_length;
3594     uint8_t * length;
3595     uint8_t * last_length;
3596
3597     assert(h==8);
3598
3599     s->dsp.diff_pixels(temp, src1, src2, stride);
3600
3601     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
3602
3603     bits=0;
3604
3605     if (s->mb_intra) {
3606         start_i = 1;
3607         length     = s->intra_ac_vlc_length;
3608         last_length= s->intra_ac_vlc_last_length;
3609         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
3610     } else {
3611         start_i = 0;
3612         length     = s->inter_ac_vlc_length;
3613         last_length= s->inter_ac_vlc_last_length;
3614     }
3615
3616     if(last>=start_i){
3617         run=0;
3618         for(i=start_i; i<last; i++){
3619             int j= scantable[i];
3620             level= temp[j];
3621
3622             if(level){
3623                 level+=64;
3624                 if((level&(~127)) == 0){
3625                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
3626                 }else
3627                     bits+= esc_length;
3628                 run=0;
3629             }else
3630                 run++;
3631         }
3632         i= scantable[last];
3633
3634         level= temp[i] + 64;
3635
3636         assert(level - 64);
3637
3638         if((level&(~127)) == 0){
3639             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
3640         }else
3641             bits+= esc_length;
3642     }
3643
3644     return bits;
3645 }
3646
3647 static int vsad_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
3648     int score=0;
3649     int x,y;
3650
3651     for(y=1; y<h; y++){
3652         for(x=0; x<16; x+=4){
3653             score+= FFABS(s[x  ] - s[x  +stride]) + FFABS(s[x+1] - s[x+1+stride])
3654                    +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]);
3655         }
3656         s+= stride;
3657     }
3658
3659     return score;
3660 }
3661
3662 static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
3663     int score=0;
3664     int x,y;
3665
3666     for(y=1; y<h; y++){
3667         for(x=0; x<16; x++){
3668             score+= FFABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3669         }
3670         s1+= stride;
3671         s2+= stride;
3672     }
3673
3674     return score;
3675 }
3676
3677 #define SQ(a) ((a)*(a))
3678 static int vsse_intra16_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){
3679     int score=0;
3680     int x,y;
3681
3682     for(y=1; y<h; y++){
3683         for(x=0; x<16; x+=4){
3684             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])
3685                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);
3686         }
3687         s+= stride;
3688     }
3689
3690     return score;
3691 }
3692
3693 static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
3694     int score=0;
3695     int x,y;
3696
3697     for(y=1; y<h; y++){
3698         for(x=0; x<16; x++){
3699             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
3700         }
3701         s1+= stride;
3702         s2+= stride;
3703     }
3704
3705     return score;
3706 }
3707
3708 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
3709                                int size){
3710     int score=0;
3711     int i;
3712     for(i=0; i<size; i++)
3713         score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
3714     return score;
3715 }
3716
3717 WARPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
3718 WARPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
3719 WARPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
3720 #ifdef CONFIG_GPL
3721 WARPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
3722 #endif
3723 WARPER8_16_SQ(dct_max8x8_c, dct_max16_c)
3724 WARPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
3725 WARPER8_16_SQ(rd8x8_c, rd16_c)
3726 WARPER8_16_SQ(bit8x8_c, bit16_c)
3727
3728 static void vector_fmul_c(float *dst, const float *src, int len){
3729     int i;
3730     for(i=0; i<len; i++)
3731         dst[i] *= src[i];
3732 }
3733
3734 static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
3735     int i;
3736     src1 += len-1;
3737     for(i=0; i<len; i++)
3738         dst[i] = src0[i] * src1[-i];
3739 }
3740
3741 void ff_vector_fmul_add_add_c(float *dst, const float *src0, const float *src1, const float *src2, int src3, int len, int step){
3742     int i;
3743     for(i=0; i<len; i++)
3744         dst[i*step] = src0[i] * src1[i] + src2[i] + src3;
3745 }
3746
3747 void ff_float_to_int16_c(int16_t *dst, const float *src, int len){
3748     int i;
3749     for(i=0; i<len; i++) {
3750         int_fast32_t tmp = ((int32_t*)src)[i];
3751         if(tmp & 0xf0000){
3752             tmp = (0x43c0ffff - tmp)>>31;
3753             // is this faster on some gcc/cpu combinations?
3754 //          if(tmp > 0x43c0ffff) tmp = 0xFFFF;
3755 //          else                 tmp = 0;
3756         }
3757         dst[i] = tmp - 0x8000;
3758     }
3759 }
3760
3761 /* XXX: those functions should be suppressed ASAP when all IDCTs are
3762  converted */
3763 static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
3764 {
3765     j_rev_dct (block);
3766     put_pixels_clamped_c(block, dest, line_size);
3767 }
3768 static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
3769 {
3770     j_rev_dct (block);
3771     add_pixels_clamped_c(block, dest, line_size);
3772 }
3773
3774 static void ff_jref_idct4_put(uint8_t *dest, int line_size, DCTELEM *block)
3775 {
3776     j_rev_dct4 (block);
3777     put_pixels_clamped4_c(block, dest, line_size);
3778 }
3779 static void ff_jref_idct4_add(uint8_t *dest, int line_size, DCTELEM *block)
3780 {
3781     j_rev_dct4 (block);
3782     add_pixels_clamped4_c(block, dest, line_size);
3783 }
3784
3785 static void ff_jref_idct2_put(uint8_t *dest, int line_size, DCTELEM *block)
3786 {
3787     j_rev_dct2 (block);
3788     put_pixels_clamped2_c(block, dest, line_size);
3789 }
3790 static void ff_jref_idct2_add(uint8_t *dest, int line_size, DCTELEM *block)
3791 {
3792     j_rev_dct2 (block);
3793     add_pixels_clamped2_c(block, dest, line_size);
3794 }
3795
3796 static void ff_jref_idct1_put(uint8_t *dest, int line_size, DCTELEM *block)
3797 {
3798     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
3799
3800     dest[0] = cm[(block[0] + 4)>>3];
3801 }
3802 static void ff_jref_idct1_add(uint8_t *dest, int line_size, DCTELEM *block)
3803 {
3804     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
3805
3806     dest[0] = cm[dest[0] + ((block[0] + 4)>>3)];
3807 }
3808
3809 static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
3810
3811 /* init static data */
3812 void dsputil_static_init(void)
3813 {
3814     int i;
3815
3816     for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
3817     for(i=0;i<MAX_NEG_CROP;i++) {
3818         ff_cropTbl[i] = 0;
3819         ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
3820     }
3821
3822     for(i=0;i<512;i++) {
3823         ff_squareTbl[i] = (i - 256) * (i - 256);
3824     }
3825
3826     for(i=0; i<64; i++) inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
3827 }
3828
3829 int ff_check_alignment(void){
3830     static int did_fail=0;
3831     DECLARE_ALIGNED_16(int, aligned);
3832
3833     if((long)&aligned & 15){
3834         if(!did_fail){
3835 #if defined(HAVE_MMX) || defined(HAVE_ALTIVEC)
3836             av_log(NULL, AV_LOG_ERROR,
3837                 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
3838                 "and may be very slow or crash. This is not a bug in libavcodec,\n"
3839                 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
3840                 "Do not report crashes to FFmpeg developers.\n");
3841 #endif
3842             did_fail=1;
3843         }
3844         return -1;
3845     }
3846     return 0;
3847 }
3848
3849 void dsputil_init(DSPContext* c, AVCodecContext *avctx)
3850 {
3851     int i;
3852
3853     ff_check_alignment();
3854
3855 #ifdef CONFIG_ENCODERS
3856     if(avctx->dct_algo==FF_DCT_FASTINT) {
3857         c->fdct = fdct_ifast;
3858         c->fdct248 = fdct_ifast248;
3859     }
3860     else if(avctx->dct_algo==FF_DCT_FAAN) {
3861         c->fdct = ff_faandct;
3862         c->fdct248 = ff_faandct248;
3863     }
3864     else {
3865         c->fdct = ff_jpeg_fdct_islow; //slow/accurate/default
3866         c->fdct248 = ff_fdct248_islow;
3867     }
3868 #endif //CONFIG_ENCODERS
3869
3870     if(avctx->lowres==1){
3871         if(avctx->idct_algo==FF_IDCT_INT || avctx->idct_algo==FF_IDCT_AUTO || !ENABLE_H264_DECODER){
3872             c->idct_put= ff_jref_idct4_put;
3873             c->idct_add= ff_jref_idct4_add;
3874         }else{
3875             c->idct_put= ff_h264_lowres_idct_put_c;
3876             c->idct_add= ff_h264_lowres_idct_add_c;
3877         }
3878         c->idct    = j_rev_dct4;
3879         c->idct_permutation_type= FF_NO_IDCT_PERM;
3880     }else if(avctx->lowres==2){
3881         c->idct_put= ff_jref_idct2_put;
3882         c->idct_add= ff_jref_idct2_add;
3883         c->idct    = j_rev_dct2;
3884         c->idct_permutation_type= FF_NO_IDCT_PERM;
3885     }else if(avctx->lowres==3){
3886         c->idct_put= ff_jref_idct1_put;
3887         c->idct_add= ff_jref_idct1_add;
3888         c->idct    = j_rev_dct1;
3889         c->idct_permutation_type= FF_NO_IDCT_PERM;
3890     }else{
3891         if(avctx->idct_algo==FF_IDCT_INT){
3892             c->idct_put= ff_jref_idct_put;
3893             c->idct_add= ff_jref_idct_add;
3894             c->idct    = j_rev_dct;
3895             c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
3896         }else if((ENABLE_VP3_DECODER || ENABLE_VP5_DECODER || ENABLE_VP6_DECODER || ENABLE_THEORA_DECODER ) &&
3897                 avctx->idct_algo==FF_IDCT_VP3){
3898             c->idct_put= ff_vp3_idct_put_c;
3899             c->idct_add= ff_vp3_idct_add_c;
3900             c->idct    = ff_vp3_idct_c;
3901             c->idct_permutation_type= FF_NO_IDCT_PERM;
3902         }else{ //accurate/default
3903             c->idct_put= simple_idct_put;
3904             c->idct_add= simple_idct_add;
3905             c->idct    = simple_idct;
3906             c->idct_permutation_type= FF_NO_IDCT_PERM;
3907         }
3908     }
3909
3910     if (ENABLE_H264_DECODER) {
3911         c->h264_idct_add= ff_h264_idct_add_c;
3912         c->h264_idct8_add= ff_h264_idct8_add_c;
3913         c->h264_idct_dc_add= ff_h264_idct_dc_add_c;
3914         c->h264_idct8_dc_add= ff_h264_idct8_dc_add_c;
3915     }
3916
3917     c->get_pixels = get_pixels_c;
3918     c->diff_pixels = diff_pixels_c;
3919     c->put_pixels_clamped = put_pixels_clamped_c;
3920     c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
3921     c->add_pixels_clamped = add_pixels_clamped_c;
3922     c->add_pixels8 = add_pixels8_c;
3923     c->add_pixels4 = add_pixels4_c;
3924     c->sum_abs_dctelem = sum_abs_dctelem_c;
3925     c->gmc1 = gmc1_c;
3926     c->gmc = ff_gmc_c;
3927     c->clear_blocks = clear_blocks_c;
3928     c->pix_sum = pix_sum_c;
3929     c->pix_norm1 = pix_norm1_c;
3930
3931     /* TODO [0] 16  [1] 8 */
3932     c->pix_abs[0][0] = pix_abs16_c;
3933     c->pix_abs[0][1] = pix_abs16_x2_c;
3934     c->pix_abs[0][2] = pix_abs16_y2_c;
3935     c->pix_abs[0][3] = pix_abs16_xy2_c;
3936     c->pix_abs[1][0] = pix_abs8_c;
3937     c->pix_abs[1][1] = pix_abs8_x2_c;
3938     c->pix_abs[1][2] = pix_abs8_y2_c;
3939     c->pix_abs[1][3] = pix_abs8_xy2_c;
3940
3941 #define dspfunc(PFX, IDX, NUM) \
3942     c->PFX ## _pixels_tab[IDX][0] = PFX ## _pixels ## NUM ## _c;     \
3943     c->PFX ## _pixels_tab[IDX][1] = PFX ## _pixels ## NUM ## _x2_c;  \
3944     c->PFX ## _pixels_tab[IDX][2] = PFX ## _pixels ## NUM ## _y2_c;  \
3945     c->PFX ## _pixels_tab[IDX][3] = PFX ## _pixels ## NUM ## _xy2_c
3946
3947     dspfunc(put, 0, 16);
3948     dspfunc(put_no_rnd, 0, 16);
3949     dspfunc(put, 1, 8);
3950     dspfunc(put_no_rnd, 1, 8);
3951     dspfunc(put, 2, 4);
3952     dspfunc(put, 3, 2);
3953
3954     dspfunc(avg, 0, 16);
3955     dspfunc(avg_no_rnd, 0, 16);
3956     dspfunc(avg, 1, 8);
3957     dspfunc(avg_no_rnd, 1, 8);
3958     dspfunc(avg, 2, 4);
3959     dspfunc(avg, 3, 2);
3960 #undef dspfunc
3961
3962     c->put_no_rnd_pixels_l2[0]= put_no_rnd_pixels16_l2_c;
3963     c->put_no_rnd_pixels_l2[1]= put_no_rnd_pixels8_l2_c;
3964
3965     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
3966     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
3967     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
3968     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
3969     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
3970     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
3971     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
3972     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
3973     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
3974
3975     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
3976     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
3977     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
3978     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
3979     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
3980     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
3981     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
3982     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
3983     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
3984
3985 #define dspfunc(PFX, IDX, NUM) \
3986     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
3987     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
3988     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
3989     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
3990     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
3991     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
3992     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
3993     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
3994     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
3995     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
3996     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
3997     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
3998     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
3999     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
4000     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
4001     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
4002
4003     dspfunc(put_qpel, 0, 16);
4004     dspfunc(put_no_rnd_qpel, 0, 16);
4005
4006     dspfunc(avg_qpel, 0, 16);
4007     /* dspfunc(avg_no_rnd_qpel, 0, 16); */
4008
4009     dspfunc(put_qpel, 1, 8);
4010     dspfunc(put_no_rnd_qpel, 1, 8);
4011
4012     dspfunc(avg_qpel, 1, 8);
4013     /* dspfunc(avg_no_rnd_qpel, 1, 8); */
4014
4015     dspfunc(put_h264_qpel, 0, 16);
4016     dspfunc(put_h264_qpel, 1, 8);
4017     dspfunc(put_h264_qpel, 2, 4);
4018     dspfunc(put_h264_qpel, 3, 2);
4019     dspfunc(avg_h264_qpel, 0, 16);
4020     dspfunc(avg_h264_qpel, 1, 8);
4021     dspfunc(avg_h264_qpel, 2, 4);
4022
4023 #undef dspfunc
4024     c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_c;
4025     c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_c;
4026     c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_c;
4027     c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_c;
4028     c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_c;
4029     c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_c;
4030     c->put_no_rnd_h264_chroma_pixels_tab[0]= put_no_rnd_h264_chroma_mc8_c;
4031
4032     c->weight_h264_pixels_tab[0]= weight_h264_pixels16x16_c;
4033     c->weight_h264_pixels_tab[1]= weight_h264_pixels16x8_c;
4034     c->weight_h264_pixels_tab[2]= weight_h264_pixels8x16_c;
4035     c->weight_h264_pixels_tab[3]= weight_h264_pixels8x8_c;
4036     c->weight_h264_pixels_tab[4]= weight_h264_pixels8x4_c;
4037     c->weight_h264_pixels_tab[5]= weight_h264_pixels4x8_c;
4038     c->weight_h264_pixels_tab[6]= weight_h264_pixels4x4_c;
4039     c->weight_h264_pixels_tab[7]= weight_h264_pixels4x2_c;
4040     c->weight_h264_pixels_tab[8]= weight_h264_pixels2x4_c;
4041     c->weight_h264_pixels_tab[9]= weight_h264_pixels2x2_c;
4042     c->biweight_h264_pixels_tab[0]= biweight_h264_pixels16x16_c;
4043     c->biweight_h264_pixels_tab[1]= biweight_h264_pixels16x8_c;
4044     c->biweight_h264_pixels_tab[2]= biweight_h264_pixels8x16_c;
4045     c->biweight_h264_pixels_tab[3]= biweight_h264_pixels8x8_c;
4046     c->biweight_h264_pixels_tab[4]= biweight_h264_pixels8x4_c;
4047     c->biweight_h264_pixels_tab[5]= biweight_h264_pixels4x8_c;
4048     c->biweight_h264_pixels_tab[6]= biweight_h264_pixels4x4_c;
4049     c->biweight_h264_pixels_tab[7]= biweight_h264_pixels4x2_c;
4050     c->biweight_h264_pixels_tab[8]= biweight_h264_pixels2x4_c;
4051     c->biweight_h264_pixels_tab[9]= biweight_h264_pixels2x2_c;
4052
4053 #ifdef CONFIG_CAVS_DECODER
4054     ff_cavsdsp_init(c,avctx);
4055 #endif
4056 #if defined(CONFIG_VC1_DECODER) || defined(CONFIG_WMV3_DECODER)
4057     ff_vc1dsp_init(c,avctx);
4058 #endif
4059 #if defined(CONFIG_H264_ENCODER)
4060     ff_h264dspenc_init(c,avctx);
4061 #endif
4062
4063     c->put_mspel_pixels_tab[0]= put_mspel8_mc00_c;
4064     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
4065     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
4066     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
4067     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
4068     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
4069     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
4070     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
4071
4072 #define SET_CMP_FUNC(name) \
4073     c->name[0]= name ## 16_c;\
4074     c->name[1]= name ## 8x8_c;
4075
4076     SET_CMP_FUNC(hadamard8_diff)
4077     c->hadamard8_diff[4]= hadamard8_intra16_c;
4078     SET_CMP_FUNC(dct_sad)
4079     SET_CMP_FUNC(dct_max)
4080 #ifdef CONFIG_GPL
4081     SET_CMP_FUNC(dct264_sad)
4082 #endif
4083     c->sad[0]= pix_abs16_c;
4084     c->sad[1]= pix_abs8_c;
4085     c->sse[0]= sse16_c;
4086     c->sse[1]= sse8_c;
4087     c->sse[2]= sse4_c;
4088     SET_CMP_FUNC(quant_psnr)
4089     SET_CMP_FUNC(rd)
4090     SET_CMP_FUNC(bit)
4091     c->vsad[0]= vsad16_c;
4092     c->vsad[4]= vsad_intra16_c;
4093     c->vsse[0]= vsse16_c;
4094     c->vsse[4]= vsse_intra16_c;
4095     c->nsse[0]= nsse16_c;
4096     c->nsse[1]= nsse8_c;
4097 #ifdef CONFIG_SNOW_ENCODER
4098     c->w53[0]= w53_16_c;
4099     c->w53[1]= w53_8_c;
4100     c->w97[0]= w97_16_c;
4101     c->w97[1]= w97_8_c;
4102 #endif
4103
4104     c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
4105
4106     c->add_bytes= add_bytes_c;
4107     c->diff_bytes= diff_bytes_c;
4108     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
4109     c->bswap_buf= bswap_buf;
4110
4111     c->h264_v_loop_filter_luma= h264_v_loop_filter_luma_c;
4112     c->h264_h_loop_filter_luma= h264_h_loop_filter_luma_c;
4113     c->h264_v_loop_filter_chroma= h264_v_loop_filter_chroma_c;
4114     c->h264_h_loop_filter_chroma= h264_h_loop_filter_chroma_c;
4115     c->h264_v_loop_filter_chroma_intra= h264_v_loop_filter_chroma_intra_c;
4116     c->h264_h_loop_filter_chroma_intra= h264_h_loop_filter_chroma_intra_c;
4117     c->h264_loop_filter_strength= NULL;
4118
4119     if (ENABLE_ANY_H263) {
4120         c->h263_h_loop_filter= h263_h_loop_filter_c;
4121         c->h263_v_loop_filter= h263_v_loop_filter_c;
4122     }
4123
4124     c->h261_loop_filter= h261_loop_filter_c;
4125
4126     c->try_8x8basis= try_8x8basis_c;
4127     c->add_8x8basis= add_8x8basis_c;
4128
4129 #ifdef CONFIG_SNOW_DECODER
4130     c->vertical_compose97i = ff_snow_vertical_compose97i;
4131     c->horizontal_compose97i = ff_snow_horizontal_compose97i;
4132     c->inner_add_yblock = ff_snow_inner_add_yblock;
4133 #endif
4134
4135 #ifdef CONFIG_VORBIS_DECODER
4136     c->vorbis_inverse_coupling = vorbis_inverse_coupling;
4137 #endif
4138 #ifdef CONFIG_FLAC_ENCODER
4139     c->flac_compute_autocorr = ff_flac_compute_autocorr;
4140 #endif
4141     c->vector_fmul = vector_fmul_c;
4142     c->vector_fmul_reverse = vector_fmul_reverse_c;
4143     c->vector_fmul_add_add = ff_vector_fmul_add_add_c;
4144     c->float_to_int16 = ff_float_to_int16_c;
4145
4146     c->shrink[0]= ff_img_copy_plane;
4147     c->shrink[1]= ff_shrink22;
4148     c->shrink[2]= ff_shrink44;
4149     c->shrink[3]= ff_shrink88;
4150
4151     c->prefetch= just_return;
4152
4153     memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));
4154     memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));
4155
4156     if (ENABLE_MMX)      dsputil_init_mmx   (c, avctx);
4157     if (ENABLE_ARMV4L)   dsputil_init_armv4l(c, avctx);
4158     if (ENABLE_MLIB)     dsputil_init_mlib  (c, avctx);
4159     if (ENABLE_VIS)      dsputil_init_vis   (c, avctx);
4160     if (ENABLE_ALPHA)    dsputil_init_alpha (c, avctx);
4161     if (ENABLE_POWERPC)  dsputil_init_ppc   (c, avctx);
4162     if (ENABLE_MMI)      dsputil_init_mmi   (c, avctx);
4163     if (ENABLE_SH4)      dsputil_init_sh4   (c, avctx);
4164     if (ENABLE_BFIN)     dsputil_init_bfin  (c, avctx);
4165
4166     for(i=0; i<64; i++){
4167         if(!c->put_2tap_qpel_pixels_tab[0][i])
4168             c->put_2tap_qpel_pixels_tab[0][i]= c->put_h264_qpel_pixels_tab[0][i];
4169         if(!c->avg_2tap_qpel_pixels_tab[0][i])
4170             c->avg_2tap_qpel_pixels_tab[0][i]= c->avg_h264_qpel_pixels_tab[0][i];
4171     }
4172
4173     switch(c->idct_permutation_type){
4174     case FF_NO_IDCT_PERM:
4175         for(i=0; i<64; i++)
4176             c->idct_permutation[i]= i;
4177         break;
4178     case FF_LIBMPEG2_IDCT_PERM:
4179         for(i=0; i<64; i++)
4180             c->idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
4181         break;
4182     case FF_SIMPLE_IDCT_PERM:
4183         for(i=0; i<64; i++)
4184             c->idct_permutation[i]= simple_mmx_permutation[i];
4185         break;
4186     case FF_TRANSPOSE_IDCT_PERM:
4187         for(i=0; i<64; i++)
4188             c->idct_permutation[i]= ((i&7)<<3) | (i>>3);
4189         break;
4190     case FF_PARTTRANS_IDCT_PERM:
4191         for(i=0; i<64; i++)
4192             c->idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
4193         break;
4194     default:
4195         av_log(avctx, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");
4196     }
4197 }
4198