synfig-core/tags/synfig_0_61_05/synfig-core/src/modules/mod_libavcodec/libavcodec/dsputil.c

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