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