git.sesse.net Git - ffmpeg/blob - libavcodec/dsputil.c

   1 /*
   2  * DSP utils
   3  * Copyright (c) 2000, 2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * gmc & q-pel & 32/64 bit based MC by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of Libav.
   9  *
  10  * Libav is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * Libav is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with Libav; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * DSP utils
  28  */
  29
  30 #include "libavutil/imgutils.h"
  31 #include "avcodec.h"
  32 #include "dsputil.h"
  33 #include "simple_idct.h"
  34 #include "faandct.h"
  35 #include "faanidct.h"
  36 #include "mathops.h"
  37 #include "mpegvideo.h"
  38 #include "config.h"
  39 #include "ac3dec.h"
  40 #include "vorbis.h"
  41
  42 uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
  43 uint32_t ff_squareTbl[512] = {0, };
  44
  45 #define BIT_DEPTH 9
  46 #include "dsputil_template.c"
  47 #undef BIT_DEPTH
  48
  49 #define BIT_DEPTH 10
  50 #include "dsputil_template.c"
  51 #undef BIT_DEPTH
  52
  53 #define BIT_DEPTH 8
  54 #include "dsputil_template.c"
  55
  56 // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
  57 #define pb_7f (~0UL/255 * 0x7f)
  58 #define pb_80 (~0UL/255 * 0x80)
  59
  60 const uint8_t ff_zigzag_direct[64] = {
  61     0,   1,  8, 16,  9,  2,  3, 10,
  62     17, 24, 32, 25, 18, 11,  4,  5,
  63     12, 19, 26, 33, 40, 48, 41, 34,
  64     27, 20, 13,  6,  7, 14, 21, 28,
  65     35, 42, 49, 56, 57, 50, 43, 36,
  66     29, 22, 15, 23, 30, 37, 44, 51,
  67     58, 59, 52, 45, 38, 31, 39, 46,
  68     53, 60, 61, 54, 47, 55, 62, 63
  69 };
  70
  71 /* Specific zigzag scan for 248 idct. NOTE that unlike the
  72    specification, we interleave the fields */
  73 const uint8_t ff_zigzag248_direct[64] = {
  74      0,  8,  1,  9, 16, 24,  2, 10,
  75     17, 25, 32, 40, 48, 56, 33, 41,
  76     18, 26,  3, 11,  4, 12, 19, 27,
  77     34, 42, 49, 57, 50, 58, 35, 43,
  78     20, 28,  5, 13,  6, 14, 21, 29,
  79     36, 44, 51, 59, 52, 60, 37, 45,
  80     22, 30,  7, 15, 23, 31, 38, 46,
  81     53, 61, 54, 62, 39, 47, 55, 63,
  82 };
  83
  84 /* not permutated inverse zigzag_direct + 1 for MMX quantizer */
  85 DECLARE_ALIGNED(16, uint16_t, ff_inv_zigzag_direct16)[64];
  86
  87 const uint8_t ff_alternate_horizontal_scan[64] = {
  88     0,  1,   2,  3,  8,  9, 16, 17,
  89     10, 11,  4,  5,  6,  7, 15, 14,
  90     13, 12, 19, 18, 24, 25, 32, 33,
  91     26, 27, 20, 21, 22, 23, 28, 29,
  92     30, 31, 34, 35, 40, 41, 48, 49,
  93     42, 43, 36, 37, 38, 39, 44, 45,
  94     46, 47, 50, 51, 56, 57, 58, 59,
  95     52, 53, 54, 55, 60, 61, 62, 63,
  96 };
  97
  98 const uint8_t ff_alternate_vertical_scan[64] = {
  99     0,  8,  16, 24,  1,  9,  2, 10,
 100     17, 25, 32, 40, 48, 56, 57, 49,
 101     41, 33, 26, 18,  3, 11,  4, 12,
 102     19, 27, 34, 42, 50, 58, 35, 43,
 103     51, 59, 20, 28,  5, 13,  6, 14,
 104     21, 29, 36, 44, 52, 60, 37, 45,
 105     53, 61, 22, 30,  7, 15, 23, 31,
 106     38, 46, 54, 62, 39, 47, 55, 63,
 107 };
 108
 109 /* Input permutation for the simple_idct_mmx */
 110 static const uint8_t simple_mmx_permutation[64]={
 111         0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
 112         0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
 113         0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
 114         0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
 115         0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
 116         0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
 117         0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
 118         0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
 119 };
 120
 121 static const uint8_t idct_sse2_row_perm[8] = {0, 4, 1, 5, 2, 6, 3, 7};
 122
 123 void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable){
 124     int i;
 125     int end;
 126
 127     st->scantable= src_scantable;
 128
 129     for(i=0; i<64; i++){
 130         int j;
 131         j = src_scantable[i];
 132         st->permutated[i] = permutation[j];
 133     }
 134
 135     end=-1;
 136     for(i=0; i<64; i++){
 137         int j;
 138         j = st->permutated[i];
 139         if(j>end) end=j;
 140         st->raster_end[i]= end;
 141     }
 142 }
 143
 144 void ff_init_scantable_permutation(uint8_t *idct_permutation,
 145                                    int idct_permutation_type)
 146 {
 147     int i;
 148
 149     switch(idct_permutation_type){
 150     case FF_NO_IDCT_PERM:
 151         for(i=0; i<64; i++)
 152             idct_permutation[i]= i;
 153         break;
 154     case FF_LIBMPEG2_IDCT_PERM:
 155         for(i=0; i<64; i++)
 156             idct_permutation[i]= (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
 157         break;
 158     case FF_SIMPLE_IDCT_PERM:
 159         for(i=0; i<64; i++)
 160             idct_permutation[i]= simple_mmx_permutation[i];
 161         break;
 162     case FF_TRANSPOSE_IDCT_PERM:
 163         for(i=0; i<64; i++)
 164             idct_permutation[i]= ((i&7)<<3) | (i>>3);
 165         break;
 166     case FF_PARTTRANS_IDCT_PERM:
 167         for(i=0; i<64; i++)
 168             idct_permutation[i]= (i&0x24) | ((i&3)<<3) | ((i>>3)&3);
 169         break;
 170     case FF_SSE2_IDCT_PERM:
 171         for(i=0; i<64; i++)
 172             idct_permutation[i]= (i&0x38) | idct_sse2_row_perm[i&7];
 173         break;
 174     default:
 175         av_log(NULL, AV_LOG_ERROR, "Internal error, IDCT permutation not set\n");
 176     }
 177 }
 178
 179 static int pix_sum_c(uint8_t * pix, int line_size)
 180 {
 181     int s, i, j;
 182
 183     s = 0;
 184     for (i = 0; i < 16; i++) {
 185         for (j = 0; j < 16; j += 8) {
 186             s += pix[0];
 187             s += pix[1];
 188             s += pix[2];
 189             s += pix[3];
 190             s += pix[4];
 191             s += pix[5];
 192             s += pix[6];
 193             s += pix[7];
 194             pix += 8;
 195         }
 196         pix += line_size - 16;
 197     }
 198     return s;
 199 }
 200
 201 static int pix_norm1_c(uint8_t * pix, int line_size)
 202 {
 203     int s, i, j;
 204     uint32_t *sq = ff_squareTbl + 256;
 205
 206     s = 0;
 207     for (i = 0; i < 16; i++) {
 208         for (j = 0; j < 16; j += 8) {
 209 #if 0
 210             s += sq[pix[0]];
 211             s += sq[pix[1]];
 212             s += sq[pix[2]];
 213             s += sq[pix[3]];
 214             s += sq[pix[4]];
 215             s += sq[pix[5]];
 216             s += sq[pix[6]];
 217             s += sq[pix[7]];
 218 #else
 219 #if HAVE_FAST_64BIT
 220             register uint64_t x=*(uint64_t*)pix;
 221             s += sq[x&0xff];
 222             s += sq[(x>>8)&0xff];
 223             s += sq[(x>>16)&0xff];
 224             s += sq[(x>>24)&0xff];
 225             s += sq[(x>>32)&0xff];
 226             s += sq[(x>>40)&0xff];
 227             s += sq[(x>>48)&0xff];
 228             s += sq[(x>>56)&0xff];
 229 #else
 230             register uint32_t x=*(uint32_t*)pix;
 231             s += sq[x&0xff];
 232             s += sq[(x>>8)&0xff];
 233             s += sq[(x>>16)&0xff];
 234             s += sq[(x>>24)&0xff];
 235             x=*(uint32_t*)(pix+4);
 236             s += sq[x&0xff];
 237             s += sq[(x>>8)&0xff];
 238             s += sq[(x>>16)&0xff];
 239             s += sq[(x>>24)&0xff];
 240 #endif
 241 #endif
 242             pix += 8;
 243         }
 244         pix += line_size - 16;
 245     }
 246     return s;
 247 }
 248
 249 static void bswap_buf(uint32_t *dst, const uint32_t *src, int w){
 250     int i;
 251
 252     for(i=0; i+8<=w; i+=8){
 253         dst[i+0]= av_bswap32(src[i+0]);
 254         dst[i+1]= av_bswap32(src[i+1]);
 255         dst[i+2]= av_bswap32(src[i+2]);
 256         dst[i+3]= av_bswap32(src[i+3]);
 257         dst[i+4]= av_bswap32(src[i+4]);
 258         dst[i+5]= av_bswap32(src[i+5]);
 259         dst[i+6]= av_bswap32(src[i+6]);
 260         dst[i+7]= av_bswap32(src[i+7]);
 261     }
 262     for(;i<w; i++){
 263         dst[i+0]= av_bswap32(src[i+0]);
 264     }
 265 }
 266
 267 static void bswap16_buf(uint16_t *dst, const uint16_t *src, int len)
 268 {
 269     while (len--)
 270         *dst++ = av_bswap16(*src++);
 271 }
 272
 273 static int sse4_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
 274 {
 275     int s, i;
 276     uint32_t *sq = ff_squareTbl + 256;
 277
 278     s = 0;
 279     for (i = 0; i < h; i++) {
 280         s += sq[pix1[0] - pix2[0]];
 281         s += sq[pix1[1] - pix2[1]];
 282         s += sq[pix1[2] - pix2[2]];
 283         s += sq[pix1[3] - pix2[3]];
 284         pix1 += line_size;
 285         pix2 += line_size;
 286     }
 287     return s;
 288 }
 289
 290 static int sse8_c(void *v, uint8_t * pix1, uint8_t * pix2, int line_size, int h)
 291 {
 292     int s, i;
 293     uint32_t *sq = ff_squareTbl + 256;
 294
 295     s = 0;
 296     for (i = 0; i < h; i++) {
 297         s += sq[pix1[0] - pix2[0]];
 298         s += sq[pix1[1] - pix2[1]];
 299         s += sq[pix1[2] - pix2[2]];
 300         s += sq[pix1[3] - pix2[3]];
 301         s += sq[pix1[4] - pix2[4]];
 302         s += sq[pix1[5] - pix2[5]];
 303         s += sq[pix1[6] - pix2[6]];
 304         s += sq[pix1[7] - pix2[7]];
 305         pix1 += line_size;
 306         pix2 += line_size;
 307     }
 308     return s;
 309 }
 310
 311 static int sse16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
 312 {
 313     int s, i;
 314     uint32_t *sq = ff_squareTbl + 256;
 315
 316     s = 0;
 317     for (i = 0; i < h; i++) {
 318         s += sq[pix1[ 0] - pix2[ 0]];
 319         s += sq[pix1[ 1] - pix2[ 1]];
 320         s += sq[pix1[ 2] - pix2[ 2]];
 321         s += sq[pix1[ 3] - pix2[ 3]];
 322         s += sq[pix1[ 4] - pix2[ 4]];
 323         s += sq[pix1[ 5] - pix2[ 5]];
 324         s += sq[pix1[ 6] - pix2[ 6]];
 325         s += sq[pix1[ 7] - pix2[ 7]];
 326         s += sq[pix1[ 8] - pix2[ 8]];
 327         s += sq[pix1[ 9] - pix2[ 9]];
 328         s += sq[pix1[10] - pix2[10]];
 329         s += sq[pix1[11] - pix2[11]];
 330         s += sq[pix1[12] - pix2[12]];
 331         s += sq[pix1[13] - pix2[13]];
 332         s += sq[pix1[14] - pix2[14]];
 333         s += sq[pix1[15] - pix2[15]];
 334
 335         pix1 += line_size;
 336         pix2 += line_size;
 337     }
 338     return s;
 339 }
 340
 341 static void diff_pixels_c(DCTELEM *restrict block, const uint8_t *s1,
 342                           const uint8_t *s2, int stride){
 343     int i;
 344
 345     /* read the pixels */
 346     for(i=0;i<8;i++) {
 347         block[0] = s1[0] - s2[0];
 348         block[1] = s1[1] - s2[1];
 349         block[2] = s1[2] - s2[2];
 350         block[3] = s1[3] - s2[3];
 351         block[4] = s1[4] - s2[4];
 352         block[5] = s1[5] - s2[5];
 353         block[6] = s1[6] - s2[6];
 354         block[7] = s1[7] - s2[7];
 355         s1 += stride;
 356         s2 += stride;
 357         block += 8;
 358     }
 359 }
 360
 361
 362 void ff_put_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
 363                              int line_size)
 364 {
 365     int i;
 366
 367     /* read the pixels */
 368     for(i=0;i<8;i++) {
 369         pixels[0] = av_clip_uint8(block[0]);
 370         pixels[1] = av_clip_uint8(block[1]);
 371         pixels[2] = av_clip_uint8(block[2]);
 372         pixels[3] = av_clip_uint8(block[3]);
 373         pixels[4] = av_clip_uint8(block[4]);
 374         pixels[5] = av_clip_uint8(block[5]);
 375         pixels[6] = av_clip_uint8(block[6]);
 376         pixels[7] = av_clip_uint8(block[7]);
 377
 378         pixels += line_size;
 379         block += 8;
 380     }
 381 }
 382
 383 void ff_put_signed_pixels_clamped_c(const DCTELEM *block,
 384                                     uint8_t *restrict pixels,
 385                                     int line_size)
 386 {
 387     int i, j;
 388
 389     for (i = 0; i < 8; i++) {
 390         for (j = 0; j < 8; j++) {
 391             if (*block < -128)
 392                 *pixels = 0;
 393             else if (*block > 127)
 394                 *pixels = 255;
 395             else
 396                 *pixels = (uint8_t)(*block + 128);
 397             block++;
 398             pixels++;
 399         }
 400         pixels += (line_size - 8);
 401     }
 402 }
 403
 404 void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels,
 405                              int line_size)
 406 {
 407     int i;
 408
 409     /* read the pixels */
 410     for(i=0;i<8;i++) {
 411         pixels[0] = av_clip_uint8(pixels[0] + block[0]);
 412         pixels[1] = av_clip_uint8(pixels[1] + block[1]);
 413         pixels[2] = av_clip_uint8(pixels[2] + block[2]);
 414         pixels[3] = av_clip_uint8(pixels[3] + block[3]);
 415         pixels[4] = av_clip_uint8(pixels[4] + block[4]);
 416         pixels[5] = av_clip_uint8(pixels[5] + block[5]);
 417         pixels[6] = av_clip_uint8(pixels[6] + block[6]);
 418         pixels[7] = av_clip_uint8(pixels[7] + block[7]);
 419         pixels += line_size;
 420         block += 8;
 421     }
 422 }
 423
 424 static int sum_abs_dctelem_c(DCTELEM *block)
 425 {
 426     int sum=0, i;
 427     for(i=0; i<64; i++)
 428         sum+= FFABS(block[i]);
 429     return sum;
 430 }
 431
 432 static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
 433 {
 434     int i;
 435
 436     for (i = 0; i < h; i++) {
 437         memset(block, value, 16);
 438         block += line_size;
 439     }
 440 }
 441
 442 static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
 443 {
 444     int i;
 445
 446     for (i = 0; i < h; i++) {
 447         memset(block, value, 8);
 448         block += line_size;
 449     }
 450 }
 451
 452 #define avg2(a,b) ((a+b+1)>>1)
 453 #define avg4(a,b,c,d) ((a+b+c+d+2)>>2)
 454
 455 static void gmc1_c(uint8_t *dst, uint8_t *src, int stride, int h, int x16, int y16, int rounder)
 456 {
 457     const int A=(16-x16)*(16-y16);
 458     const int B=(   x16)*(16-y16);
 459     const int C=(16-x16)*(   y16);
 460     const int D=(   x16)*(   y16);
 461     int i;
 462
 463     for(i=0; i<h; i++)
 464     {
 465         dst[0]= (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1] + rounder)>>8;
 466         dst[1]= (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2] + rounder)>>8;
 467         dst[2]= (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3] + rounder)>>8;
 468         dst[3]= (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4] + rounder)>>8;
 469         dst[4]= (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5] + rounder)>>8;
 470         dst[5]= (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6] + rounder)>>8;
 471         dst[6]= (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7] + rounder)>>8;
 472         dst[7]= (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8] + rounder)>>8;
 473         dst+= stride;
 474         src+= stride;
 475     }
 476 }
 477
 478 void ff_gmc_c(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy,
 479                   int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height)
 480 {
 481     int y, vx, vy;
 482     const int s= 1<<shift;
 483
 484     width--;
 485     height--;
 486
 487     for(y=0; y<h; y++){
 488         int x;
 489
 490         vx= ox;
 491         vy= oy;
 492         for(x=0; x<8; x++){ //XXX FIXME optimize
 493             int src_x, src_y, frac_x, frac_y, index;
 494
 495             src_x= vx>>16;
 496             src_y= vy>>16;
 497             frac_x= src_x&(s-1);
 498             frac_y= src_y&(s-1);
 499             src_x>>=shift;
 500             src_y>>=shift;
 501
 502             if((unsigned)src_x < width){
 503                 if((unsigned)src_y < height){
 504                     index= src_x + src_y*stride;
 505                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_x)
 506                                            + src[index       +1]*   frac_x )*(s-frac_y)
 507                                         + (  src[index+stride  ]*(s-frac_x)
 508                                            + src[index+stride+1]*   frac_x )*   frac_y
 509                                         + r)>>(shift*2);
 510                 }else{
 511                     index= src_x + av_clip(src_y, 0, height)*stride;
 512                     dst[y*stride + x]= ( (  src[index         ]*(s-frac_x)
 513                                           + src[index       +1]*   frac_x )*s
 514                                         + r)>>(shift*2);
 515                 }
 516             }else{
 517                 if((unsigned)src_y < height){
 518                     index= av_clip(src_x, 0, width) + src_y*stride;
 519                     dst[y*stride + x]= (  (  src[index         ]*(s-frac_y)
 520                                            + src[index+stride  ]*   frac_y )*s
 521                                         + r)>>(shift*2);
 522                 }else{
 523                     index= av_clip(src_x, 0, width) + av_clip(src_y, 0, height)*stride;
 524                     dst[y*stride + x]=    src[index         ];
 525                 }
 526             }
 527
 528             vx+= dxx;
 529             vy+= dyx;
 530         }
 531         ox += dxy;
 532         oy += dyy;
 533     }
 534 }
 535
 536 static inline void put_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 537     switch(width){
 538     case 2: put_pixels2_8_c (dst, src, stride, height); break;
 539     case 4: put_pixels4_8_c (dst, src, stride, height); break;
 540     case 8: put_pixels8_8_c (dst, src, stride, height); break;
 541     case 16:put_pixels16_8_c(dst, src, stride, height); break;
 542     }
 543 }
 544
 545 static inline void put_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 546     int i,j;
 547     for (i=0; i < height; i++) {
 548       for (j=0; j < width; j++) {
 549         dst[j] = (683*(2*src[j] + src[j+1] + 1)) >> 11;
 550       }
 551       src += stride;
 552       dst += stride;
 553     }
 554 }
 555
 556 static inline void put_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 557     int i,j;
 558     for (i=0; i < height; i++) {
 559       for (j=0; j < width; j++) {
 560         dst[j] = (683*(src[j] + 2*src[j+1] + 1)) >> 11;
 561       }
 562       src += stride;
 563       dst += stride;
 564     }
 565 }
 566
 567 static inline void put_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 568     int i,j;
 569     for (i=0; i < height; i++) {
 570       for (j=0; j < width; j++) {
 571         dst[j] = (683*(2*src[j] + src[j+stride] + 1)) >> 11;
 572       }
 573       src += stride;
 574       dst += stride;
 575     }
 576 }
 577
 578 static inline void put_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 579     int i,j;
 580     for (i=0; i < height; i++) {
 581       for (j=0; j < width; j++) {
 582         dst[j] = (2731*(4*src[j] + 3*src[j+1] + 3*src[j+stride] + 2*src[j+stride+1] + 6)) >> 15;
 583       }
 584       src += stride;
 585       dst += stride;
 586     }
 587 }
 588
 589 static inline void put_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 590     int i,j;
 591     for (i=0; i < height; i++) {
 592       for (j=0; j < width; j++) {
 593         dst[j] = (2731*(3*src[j] + 2*src[j+1] + 4*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
 594       }
 595       src += stride;
 596       dst += stride;
 597     }
 598 }
 599
 600 static inline void put_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 601     int i,j;
 602     for (i=0; i < height; i++) {
 603       for (j=0; j < width; j++) {
 604         dst[j] = (683*(src[j] + 2*src[j+stride] + 1)) >> 11;
 605       }
 606       src += stride;
 607       dst += stride;
 608     }
 609 }
 610
 611 static inline void put_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 612     int i,j;
 613     for (i=0; i < height; i++) {
 614       for (j=0; j < width; j++) {
 615         dst[j] = (2731*(3*src[j] + 4*src[j+1] + 2*src[j+stride] + 3*src[j+stride+1] + 6)) >> 15;
 616       }
 617       src += stride;
 618       dst += stride;
 619     }
 620 }
 621
 622 static inline void put_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 623     int i,j;
 624     for (i=0; i < height; i++) {
 625       for (j=0; j < width; j++) {
 626         dst[j] = (2731*(2*src[j] + 3*src[j+1] + 3*src[j+stride] + 4*src[j+stride+1] + 6)) >> 15;
 627       }
 628       src += stride;
 629       dst += stride;
 630     }
 631 }
 632
 633 static inline void avg_tpel_pixels_mc00_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 634     switch(width){
 635     case 2: avg_pixels2_8_c (dst, src, stride, height); break;
 636     case 4: avg_pixels4_8_c (dst, src, stride, height); break;
 637     case 8: avg_pixels8_8_c (dst, src, stride, height); break;
 638     case 16:avg_pixels16_8_c(dst, src, stride, height); break;
 639     }
 640 }
 641
 642 static inline void avg_tpel_pixels_mc10_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 643     int i,j;
 644     for (i=0; i < height; i++) {
 645       for (j=0; j < width; j++) {
 646         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+1] + 1)) >> 11) + 1) >> 1;
 647       }
 648       src += stride;
 649       dst += stride;
 650     }
 651 }
 652
 653 static inline void avg_tpel_pixels_mc20_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 654     int i,j;
 655     for (i=0; i < height; i++) {
 656       for (j=0; j < width; j++) {
 657         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+1] + 1)) >> 11) + 1) >> 1;
 658       }
 659       src += stride;
 660       dst += stride;
 661     }
 662 }
 663
 664 static inline void avg_tpel_pixels_mc01_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 665     int i,j;
 666     for (i=0; i < height; i++) {
 667       for (j=0; j < width; j++) {
 668         dst[j] = (dst[j] + ((683*(2*src[j] + src[j+stride] + 1)) >> 11) + 1) >> 1;
 669       }
 670       src += stride;
 671       dst += stride;
 672     }
 673 }
 674
 675 static inline void avg_tpel_pixels_mc11_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 676     int i,j;
 677     for (i=0; i < height; i++) {
 678       for (j=0; j < width; j++) {
 679         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;
 680       }
 681       src += stride;
 682       dst += stride;
 683     }
 684 }
 685
 686 static inline void avg_tpel_pixels_mc12_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 687     int i,j;
 688     for (i=0; i < height; i++) {
 689       for (j=0; j < width; j++) {
 690         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;
 691       }
 692       src += stride;
 693       dst += stride;
 694     }
 695 }
 696
 697 static inline void avg_tpel_pixels_mc02_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 698     int i,j;
 699     for (i=0; i < height; i++) {
 700       for (j=0; j < width; j++) {
 701         dst[j] = (dst[j] + ((683*(src[j] + 2*src[j+stride] + 1)) >> 11) + 1) >> 1;
 702       }
 703       src += stride;
 704       dst += stride;
 705     }
 706 }
 707
 708 static inline void avg_tpel_pixels_mc21_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 709     int i,j;
 710     for (i=0; i < height; i++) {
 711       for (j=0; j < width; j++) {
 712         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;
 713       }
 714       src += stride;
 715       dst += stride;
 716     }
 717 }
 718
 719 static inline void avg_tpel_pixels_mc22_c(uint8_t *dst, const uint8_t *src, int stride, int width, int height){
 720     int i,j;
 721     for (i=0; i < height; i++) {
 722       for (j=0; j < width; j++) {
 723         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;
 724       }
 725       src += stride;
 726       dst += stride;
 727     }
 728 }
 729
 730 #define QPEL_MC(r, OPNAME, RND, OP) \
 731 static void OPNAME ## mpeg4_qpel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
 732     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
 733     int i;\
 734     for(i=0; i<h; i++)\
 735     {\
 736         OP(dst[0], (src[0]+src[1])*20 - (src[0]+src[2])*6 + (src[1]+src[3])*3 - (src[2]+src[4]));\
 737         OP(dst[1], (src[1]+src[2])*20 - (src[0]+src[3])*6 + (src[0]+src[4])*3 - (src[1]+src[5]));\
 738         OP(dst[2], (src[2]+src[3])*20 - (src[1]+src[4])*6 + (src[0]+src[5])*3 - (src[0]+src[6]));\
 739         OP(dst[3], (src[3]+src[4])*20 - (src[2]+src[5])*6 + (src[1]+src[6])*3 - (src[0]+src[7]));\
 740         OP(dst[4], (src[4]+src[5])*20 - (src[3]+src[6])*6 + (src[2]+src[7])*3 - (src[1]+src[8]));\
 741         OP(dst[5], (src[5]+src[6])*20 - (src[4]+src[7])*6 + (src[3]+src[8])*3 - (src[2]+src[8]));\
 742         OP(dst[6], (src[6]+src[7])*20 - (src[5]+src[8])*6 + (src[4]+src[8])*3 - (src[3]+src[7]));\
 743         OP(dst[7], (src[7]+src[8])*20 - (src[6]+src[8])*6 + (src[5]+src[7])*3 - (src[4]+src[6]));\
 744         dst+=dstStride;\
 745         src+=srcStride;\
 746     }\
 747 }\
 748 \
 749 static void OPNAME ## mpeg4_qpel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
 750     const int w=8;\
 751     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
 752     int i;\
 753     for(i=0; i<w; i++)\
 754     {\
 755         const int src0= src[0*srcStride];\
 756         const int src1= src[1*srcStride];\
 757         const int src2= src[2*srcStride];\
 758         const int src3= src[3*srcStride];\
 759         const int src4= src[4*srcStride];\
 760         const int src5= src[5*srcStride];\
 761         const int src6= src[6*srcStride];\
 762         const int src7= src[7*srcStride];\
 763         const int src8= src[8*srcStride];\
 764         OP(dst[0*dstStride], (src0+src1)*20 - (src0+src2)*6 + (src1+src3)*3 - (src2+src4));\
 765         OP(dst[1*dstStride], (src1+src2)*20 - (src0+src3)*6 + (src0+src4)*3 - (src1+src5));\
 766         OP(dst[2*dstStride], (src2+src3)*20 - (src1+src4)*6 + (src0+src5)*3 - (src0+src6));\
 767         OP(dst[3*dstStride], (src3+src4)*20 - (src2+src5)*6 + (src1+src6)*3 - (src0+src7));\
 768         OP(dst[4*dstStride], (src4+src5)*20 - (src3+src6)*6 + (src2+src7)*3 - (src1+src8));\
 769         OP(dst[5*dstStride], (src5+src6)*20 - (src4+src7)*6 + (src3+src8)*3 - (src2+src8));\
 770         OP(dst[6*dstStride], (src6+src7)*20 - (src5+src8)*6 + (src4+src8)*3 - (src3+src7));\
 771         OP(dst[7*dstStride], (src7+src8)*20 - (src6+src8)*6 + (src5+src7)*3 - (src4+src6));\
 772         dst++;\
 773         src++;\
 774     }\
 775 }\
 776 \
 777 static void OPNAME ## mpeg4_qpel16_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){\
 778     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
 779     int i;\
 780     \
 781     for(i=0; i<h; i++)\
 782     {\
 783         OP(dst[ 0], (src[ 0]+src[ 1])*20 - (src[ 0]+src[ 2])*6 + (src[ 1]+src[ 3])*3 - (src[ 2]+src[ 4]));\
 784         OP(dst[ 1], (src[ 1]+src[ 2])*20 - (src[ 0]+src[ 3])*6 + (src[ 0]+src[ 4])*3 - (src[ 1]+src[ 5]));\
 785         OP(dst[ 2], (src[ 2]+src[ 3])*20 - (src[ 1]+src[ 4])*6 + (src[ 0]+src[ 5])*3 - (src[ 0]+src[ 6]));\
 786         OP(dst[ 3], (src[ 3]+src[ 4])*20 - (src[ 2]+src[ 5])*6 + (src[ 1]+src[ 6])*3 - (src[ 0]+src[ 7]));\
 787         OP(dst[ 4], (src[ 4]+src[ 5])*20 - (src[ 3]+src[ 6])*6 + (src[ 2]+src[ 7])*3 - (src[ 1]+src[ 8]));\
 788         OP(dst[ 5], (src[ 5]+src[ 6])*20 - (src[ 4]+src[ 7])*6 + (src[ 3]+src[ 8])*3 - (src[ 2]+src[ 9]));\
 789         OP(dst[ 6], (src[ 6]+src[ 7])*20 - (src[ 5]+src[ 8])*6 + (src[ 4]+src[ 9])*3 - (src[ 3]+src[10]));\
 790         OP(dst[ 7], (src[ 7]+src[ 8])*20 - (src[ 6]+src[ 9])*6 + (src[ 5]+src[10])*3 - (src[ 4]+src[11]));\
 791         OP(dst[ 8], (src[ 8]+src[ 9])*20 - (src[ 7]+src[10])*6 + (src[ 6]+src[11])*3 - (src[ 5]+src[12]));\
 792         OP(dst[ 9], (src[ 9]+src[10])*20 - (src[ 8]+src[11])*6 + (src[ 7]+src[12])*3 - (src[ 6]+src[13]));\
 793         OP(dst[10], (src[10]+src[11])*20 - (src[ 9]+src[12])*6 + (src[ 8]+src[13])*3 - (src[ 7]+src[14]));\
 794         OP(dst[11], (src[11]+src[12])*20 - (src[10]+src[13])*6 + (src[ 9]+src[14])*3 - (src[ 8]+src[15]));\
 795         OP(dst[12], (src[12]+src[13])*20 - (src[11]+src[14])*6 + (src[10]+src[15])*3 - (src[ 9]+src[16]));\
 796         OP(dst[13], (src[13]+src[14])*20 - (src[12]+src[15])*6 + (src[11]+src[16])*3 - (src[10]+src[16]));\
 797         OP(dst[14], (src[14]+src[15])*20 - (src[13]+src[16])*6 + (src[12]+src[16])*3 - (src[11]+src[15]));\
 798         OP(dst[15], (src[15]+src[16])*20 - (src[14]+src[16])*6 + (src[13]+src[15])*3 - (src[12]+src[14]));\
 799         dst+=dstStride;\
 800         src+=srcStride;\
 801     }\
 802 }\
 803 \
 804 static void OPNAME ## mpeg4_qpel16_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride){\
 805     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;\
 806     int i;\
 807     const int w=16;\
 808     for(i=0; i<w; i++)\
 809     {\
 810         const int src0= src[0*srcStride];\
 811         const int src1= src[1*srcStride];\
 812         const int src2= src[2*srcStride];\
 813         const int src3= src[3*srcStride];\
 814         const int src4= src[4*srcStride];\
 815         const int src5= src[5*srcStride];\
 816         const int src6= src[6*srcStride];\
 817         const int src7= src[7*srcStride];\
 818         const int src8= src[8*srcStride];\
 819         const int src9= src[9*srcStride];\
 820         const int src10= src[10*srcStride];\
 821         const int src11= src[11*srcStride];\
 822         const int src12= src[12*srcStride];\
 823         const int src13= src[13*srcStride];\
 824         const int src14= src[14*srcStride];\
 825         const int src15= src[15*srcStride];\
 826         const int src16= src[16*srcStride];\
 827         OP(dst[ 0*dstStride], (src0 +src1 )*20 - (src0 +src2 )*6 + (src1 +src3 )*3 - (src2 +src4 ));\
 828         OP(dst[ 1*dstStride], (src1 +src2 )*20 - (src0 +src3 )*6 + (src0 +src4 )*3 - (src1 +src5 ));\
 829         OP(dst[ 2*dstStride], (src2 +src3 )*20 - (src1 +src4 )*6 + (src0 +src5 )*3 - (src0 +src6 ));\
 830         OP(dst[ 3*dstStride], (src3 +src4 )*20 - (src2 +src5 )*6 + (src1 +src6 )*3 - (src0 +src7 ));\
 831         OP(dst[ 4*dstStride], (src4 +src5 )*20 - (src3 +src6 )*6 + (src2 +src7 )*3 - (src1 +src8 ));\
 832         OP(dst[ 5*dstStride], (src5 +src6 )*20 - (src4 +src7 )*6 + (src3 +src8 )*3 - (src2 +src9 ));\
 833         OP(dst[ 6*dstStride], (src6 +src7 )*20 - (src5 +src8 )*6 + (src4 +src9 )*3 - (src3 +src10));\
 834         OP(dst[ 7*dstStride], (src7 +src8 )*20 - (src6 +src9 )*6 + (src5 +src10)*3 - (src4 +src11));\
 835         OP(dst[ 8*dstStride], (src8 +src9 )*20 - (src7 +src10)*6 + (src6 +src11)*3 - (src5 +src12));\
 836         OP(dst[ 9*dstStride], (src9 +src10)*20 - (src8 +src11)*6 + (src7 +src12)*3 - (src6 +src13));\
 837         OP(dst[10*dstStride], (src10+src11)*20 - (src9 +src12)*6 + (src8 +src13)*3 - (src7 +src14));\
 838         OP(dst[11*dstStride], (src11+src12)*20 - (src10+src13)*6 + (src9 +src14)*3 - (src8 +src15));\
 839         OP(dst[12*dstStride], (src12+src13)*20 - (src11+src14)*6 + (src10+src15)*3 - (src9 +src16));\
 840         OP(dst[13*dstStride], (src13+src14)*20 - (src12+src15)*6 + (src11+src16)*3 - (src10+src16));\
 841         OP(dst[14*dstStride], (src14+src15)*20 - (src13+src16)*6 + (src12+src16)*3 - (src11+src15));\
 842         OP(dst[15*dstStride], (src15+src16)*20 - (src14+src16)*6 + (src13+src15)*3 - (src12+src14));\
 843         dst++;\
 844         src++;\
 845     }\
 846 }\
 847 \
 848 static void OPNAME ## qpel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
 849     uint8_t half[64];\
 850     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
 851     OPNAME ## pixels8_l2_8(dst, src, half, stride, stride, 8, 8);\
 852 }\
 853 \
 854 static void OPNAME ## qpel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
 855     OPNAME ## mpeg4_qpel8_h_lowpass(dst, src, stride, stride, 8);\
 856 }\
 857 \
 858 static void OPNAME ## qpel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
 859     uint8_t half[64];\
 860     put ## RND ## mpeg4_qpel8_h_lowpass(half, src, 8, stride, 8);\
 861     OPNAME ## pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);\
 862 }\
 863 \
 864 static void OPNAME ## qpel8_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
 865     uint8_t full[16*9];\
 866     uint8_t half[64];\
 867     copy_block9(full, src, 16, stride, 9);\
 868     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
 869     OPNAME ## pixels8_l2_8(dst, full, half, stride, 16, 8, 8);\
 870 }\
 871 \
 872 static void OPNAME ## qpel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
 873     uint8_t full[16*9];\
 874     copy_block9(full, src, 16, stride, 9);\
 875     OPNAME ## mpeg4_qpel8_v_lowpass(dst, full, stride, 16);\
 876 }\
 877 \
 878 static void OPNAME ## qpel8_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
 879     uint8_t full[16*9];\
 880     uint8_t half[64];\
 881     copy_block9(full, src, 16, stride, 9);\
 882     put ## RND ## mpeg4_qpel8_v_lowpass(half, full, 8, 16);\
 883     OPNAME ## pixels8_l2_8(dst, full+16, half, stride, 16, 8, 8);\
 884 }\
 885 void ff_ ## OPNAME ## qpel8_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
 886     uint8_t full[16*9];\
 887     uint8_t halfH[72];\
 888     uint8_t halfV[64];\
 889     uint8_t halfHV[64];\
 890     copy_block9(full, src, 16, stride, 9);\
 891     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 892     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
 893     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 894     OPNAME ## pixels8_l4_8(dst, full, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 895 }\
 896 static void OPNAME ## qpel8_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
 897     uint8_t full[16*9];\
 898     uint8_t halfH[72];\
 899     uint8_t halfHV[64];\
 900     copy_block9(full, src, 16, stride, 9);\
 901     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 902     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
 903     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 904     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
 905 }\
 906 void ff_ ## OPNAME ## qpel8_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
 907     uint8_t full[16*9];\
 908     uint8_t halfH[72];\
 909     uint8_t halfV[64];\
 910     uint8_t halfHV[64];\
 911     copy_block9(full, src, 16, stride, 9);\
 912     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 913     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
 914     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 915     OPNAME ## pixels8_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 916 }\
 917 static void OPNAME ## qpel8_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
 918     uint8_t full[16*9];\
 919     uint8_t halfH[72];\
 920     uint8_t halfHV[64];\
 921     copy_block9(full, src, 16, stride, 9);\
 922     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 923     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
 924     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 925     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
 926 }\
 927 void ff_ ## OPNAME ## qpel8_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
 928     uint8_t full[16*9];\
 929     uint8_t halfH[72];\
 930     uint8_t halfV[64];\
 931     uint8_t halfHV[64];\
 932     copy_block9(full, src, 16, stride, 9);\
 933     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 934     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
 935     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 936     OPNAME ## pixels8_l4_8(dst, full+16, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 937 }\
 938 static void OPNAME ## qpel8_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
 939     uint8_t full[16*9];\
 940     uint8_t halfH[72];\
 941     uint8_t halfHV[64];\
 942     copy_block9(full, src, 16, stride, 9);\
 943     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 944     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
 945     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 946     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 947 }\
 948 void ff_ ## OPNAME ## qpel8_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
 949     uint8_t full[16*9];\
 950     uint8_t halfH[72];\
 951     uint8_t halfV[64];\
 952     uint8_t halfHV[64];\
 953     copy_block9(full, src, 16, stride, 9);\
 954     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full  , 8, 16, 9);\
 955     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
 956     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 957     OPNAME ## pixels8_l4_8(dst, full+17, halfH+8, halfV, halfHV, stride, 16, 8, 8, 8, 8);\
 958 }\
 959 static void OPNAME ## qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
 960     uint8_t full[16*9];\
 961     uint8_t halfH[72];\
 962     uint8_t halfHV[64];\
 963     copy_block9(full, src, 16, stride, 9);\
 964     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 965     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
 966     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 967     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 968 }\
 969 static void OPNAME ## qpel8_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
 970     uint8_t halfH[72];\
 971     uint8_t halfHV[64];\
 972     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
 973     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 974     OPNAME ## pixels8_l2_8(dst, halfH, halfHV, stride, 8, 8, 8);\
 975 }\
 976 static void OPNAME ## qpel8_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
 977     uint8_t halfH[72];\
 978     uint8_t halfHV[64];\
 979     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
 980     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 981     OPNAME ## pixels8_l2_8(dst, halfH+8, halfHV, stride, 8, 8, 8);\
 982 }\
 983 void ff_ ## OPNAME ## qpel8_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
 984     uint8_t full[16*9];\
 985     uint8_t halfH[72];\
 986     uint8_t halfV[64];\
 987     uint8_t halfHV[64];\
 988     copy_block9(full, src, 16, stride, 9);\
 989     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 990     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full, 8, 16);\
 991     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
 992     OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
 993 }\
 994 static void OPNAME ## qpel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
 995     uint8_t full[16*9];\
 996     uint8_t halfH[72];\
 997     copy_block9(full, src, 16, stride, 9);\
 998     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
 999     put ## RND ## pixels8_l2_8(halfH, halfH, full, 8, 8, 16, 9);\
1000     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1001 }\
1002 void ff_ ## OPNAME ## qpel8_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1003     uint8_t full[16*9];\
1004     uint8_t halfH[72];\
1005     uint8_t halfV[64];\
1006     uint8_t halfHV[64];\
1007     copy_block9(full, src, 16, stride, 9);\
1008     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1009     put ## RND ## mpeg4_qpel8_v_lowpass(halfV, full+1, 8, 16);\
1010     put ## RND ## mpeg4_qpel8_v_lowpass(halfHV, halfH, 8, 8);\
1011     OPNAME ## pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);\
1012 }\
1013 static void OPNAME ## qpel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1014     uint8_t full[16*9];\
1015     uint8_t halfH[72];\
1016     copy_block9(full, src, 16, stride, 9);\
1017     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, full, 8, 16, 9);\
1018     put ## RND ## pixels8_l2_8(halfH, halfH, full+1, 8, 8, 16, 9);\
1019     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1020 }\
1021 static void OPNAME ## qpel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1022     uint8_t halfH[72];\
1023     put ## RND ## mpeg4_qpel8_h_lowpass(halfH, src, 8, stride, 9);\
1024     OPNAME ## mpeg4_qpel8_v_lowpass(dst, halfH, stride, 8);\
1025 }\
1026 \
1027 static void OPNAME ## qpel16_mc10_c(uint8_t *dst, uint8_t *src, int stride){\
1028     uint8_t half[256];\
1029     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1030     OPNAME ## pixels16_l2_8(dst, src, half, stride, stride, 16, 16);\
1031 }\
1032 \
1033 static void OPNAME ## qpel16_mc20_c(uint8_t *dst, uint8_t *src, int stride){\
1034     OPNAME ## mpeg4_qpel16_h_lowpass(dst, src, stride, stride, 16);\
1035 }\
1036 \
1037 static void OPNAME ## qpel16_mc30_c(uint8_t *dst, uint8_t *src, int stride){\
1038     uint8_t half[256];\
1039     put ## RND ## mpeg4_qpel16_h_lowpass(half, src, 16, stride, 16);\
1040     OPNAME ## pixels16_l2_8(dst, src+1, half, stride, stride, 16, 16);\
1041 }\
1042 \
1043 static void OPNAME ## qpel16_mc01_c(uint8_t *dst, uint8_t *src, int stride){\
1044     uint8_t full[24*17];\
1045     uint8_t half[256];\
1046     copy_block17(full, src, 24, stride, 17);\
1047     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1048     OPNAME ## pixels16_l2_8(dst, full, half, stride, 24, 16, 16);\
1049 }\
1050 \
1051 static void OPNAME ## qpel16_mc02_c(uint8_t *dst, uint8_t *src, int stride){\
1052     uint8_t full[24*17];\
1053     copy_block17(full, src, 24, stride, 17);\
1054     OPNAME ## mpeg4_qpel16_v_lowpass(dst, full, stride, 24);\
1055 }\
1056 \
1057 static void OPNAME ## qpel16_mc03_c(uint8_t *dst, uint8_t *src, int stride){\
1058     uint8_t full[24*17];\
1059     uint8_t half[256];\
1060     copy_block17(full, src, 24, stride, 17);\
1061     put ## RND ## mpeg4_qpel16_v_lowpass(half, full, 16, 24);\
1062     OPNAME ## pixels16_l2_8(dst, full+24, half, stride, 24, 16, 16);\
1063 }\
1064 void ff_ ## OPNAME ## qpel16_mc11_old_c(uint8_t *dst, uint8_t *src, int stride){\
1065     uint8_t full[24*17];\
1066     uint8_t halfH[272];\
1067     uint8_t halfV[256];\
1068     uint8_t halfHV[256];\
1069     copy_block17(full, src, 24, stride, 17);\
1070     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1071     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1072     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1073     OPNAME ## pixels16_l4_8(dst, full, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1074 }\
1075 static void OPNAME ## qpel16_mc11_c(uint8_t *dst, uint8_t *src, int stride){\
1076     uint8_t full[24*17];\
1077     uint8_t halfH[272];\
1078     uint8_t halfHV[256];\
1079     copy_block17(full, src, 24, stride, 17);\
1080     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1081     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1082     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1083     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1084 }\
1085 void ff_ ## OPNAME ## qpel16_mc31_old_c(uint8_t *dst, uint8_t *src, int stride){\
1086     uint8_t full[24*17];\
1087     uint8_t halfH[272];\
1088     uint8_t halfV[256];\
1089     uint8_t halfHV[256];\
1090     copy_block17(full, src, 24, stride, 17);\
1091     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1092     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1093     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1094     OPNAME ## pixels16_l4_8(dst, full+1, halfH, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1095 }\
1096 static void OPNAME ## qpel16_mc31_c(uint8_t *dst, uint8_t *src, int stride){\
1097     uint8_t full[24*17];\
1098     uint8_t halfH[272];\
1099     uint8_t halfHV[256];\
1100     copy_block17(full, src, 24, stride, 17);\
1101     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1102     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1103     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1104     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1105 }\
1106 void ff_ ## OPNAME ## qpel16_mc13_old_c(uint8_t *dst, uint8_t *src, int stride){\
1107     uint8_t full[24*17];\
1108     uint8_t halfH[272];\
1109     uint8_t halfV[256];\
1110     uint8_t halfHV[256];\
1111     copy_block17(full, src, 24, stride, 17);\
1112     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1113     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1114     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1115     OPNAME ## pixels16_l4_8(dst, full+24, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1116 }\
1117 static void OPNAME ## qpel16_mc13_c(uint8_t *dst, uint8_t *src, int stride){\
1118     uint8_t full[24*17];\
1119     uint8_t halfH[272];\
1120     uint8_t halfHV[256];\
1121     copy_block17(full, src, 24, stride, 17);\
1122     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1123     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1124     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1125     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1126 }\
1127 void ff_ ## OPNAME ## qpel16_mc33_old_c(uint8_t *dst, uint8_t *src, int stride){\
1128     uint8_t full[24*17];\
1129     uint8_t halfH[272];\
1130     uint8_t halfV[256];\
1131     uint8_t halfHV[256];\
1132     copy_block17(full, src, 24, stride, 17);\
1133     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full  , 16, 24, 17);\
1134     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1135     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1136     OPNAME ## pixels16_l4_8(dst, full+25, halfH+16, halfV, halfHV, stride, 24, 16, 16, 16, 16);\
1137 }\
1138 static void OPNAME ## qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){\
1139     uint8_t full[24*17];\
1140     uint8_t halfH[272];\
1141     uint8_t halfHV[256];\
1142     copy_block17(full, src, 24, stride, 17);\
1143     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1144     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1145     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1146     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1147 }\
1148 static void OPNAME ## qpel16_mc21_c(uint8_t *dst, uint8_t *src, int stride){\
1149     uint8_t halfH[272];\
1150     uint8_t halfHV[256];\
1151     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1152     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1153     OPNAME ## pixels16_l2_8(dst, halfH, halfHV, stride, 16, 16, 16);\
1154 }\
1155 static void OPNAME ## qpel16_mc23_c(uint8_t *dst, uint8_t *src, int stride){\
1156     uint8_t halfH[272];\
1157     uint8_t halfHV[256];\
1158     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1159     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1160     OPNAME ## pixels16_l2_8(dst, halfH+16, halfHV, stride, 16, 16, 16);\
1161 }\
1162 void ff_ ## OPNAME ## qpel16_mc12_old_c(uint8_t *dst, uint8_t *src, int stride){\
1163     uint8_t full[24*17];\
1164     uint8_t halfH[272];\
1165     uint8_t halfV[256];\
1166     uint8_t halfHV[256];\
1167     copy_block17(full, src, 24, stride, 17);\
1168     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1169     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full, 16, 24);\
1170     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1171     OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1172 }\
1173 static void OPNAME ## qpel16_mc12_c(uint8_t *dst, uint8_t *src, int stride){\
1174     uint8_t full[24*17];\
1175     uint8_t halfH[272];\
1176     copy_block17(full, src, 24, stride, 17);\
1177     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1178     put ## RND ## pixels16_l2_8(halfH, halfH, full, 16, 16, 24, 17);\
1179     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1180 }\
1181 void ff_ ## OPNAME ## qpel16_mc32_old_c(uint8_t *dst, uint8_t *src, int stride){\
1182     uint8_t full[24*17];\
1183     uint8_t halfH[272];\
1184     uint8_t halfV[256];\
1185     uint8_t halfHV[256];\
1186     copy_block17(full, src, 24, stride, 17);\
1187     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1188     put ## RND ## mpeg4_qpel16_v_lowpass(halfV, full+1, 16, 24);\
1189     put ## RND ## mpeg4_qpel16_v_lowpass(halfHV, halfH, 16, 16);\
1190     OPNAME ## pixels16_l2_8(dst, halfV, halfHV, stride, 16, 16, 16);\
1191 }\
1192 static void OPNAME ## qpel16_mc32_c(uint8_t *dst, uint8_t *src, int stride){\
1193     uint8_t full[24*17];\
1194     uint8_t halfH[272];\
1195     copy_block17(full, src, 24, stride, 17);\
1196     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, full, 16, 24, 17);\
1197     put ## RND ## pixels16_l2_8(halfH, halfH, full+1, 16, 16, 24, 17);\
1198     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1199 }\
1200 static void OPNAME ## qpel16_mc22_c(uint8_t *dst, uint8_t *src, int stride){\
1201     uint8_t halfH[272];\
1202     put ## RND ## mpeg4_qpel16_h_lowpass(halfH, src, 16, stride, 17);\
1203     OPNAME ## mpeg4_qpel16_v_lowpass(dst, halfH, stride, 16);\
1204 }
1205
1206 #define op_avg(a, b) a = (((a)+cm[((b) + 16)>>5]+1)>>1)
1207 #define op_avg_no_rnd(a, b) a = (((a)+cm[((b) + 15)>>5])>>1)
1208 #define op_put(a, b) a = cm[((b) + 16)>>5]
1209 #define op_put_no_rnd(a, b) a = cm[((b) + 15)>>5]
1210
1211 QPEL_MC(0, put_       , _       , op_put)
1212 QPEL_MC(1, put_no_rnd_, _no_rnd_, op_put_no_rnd)
1213 QPEL_MC(0, avg_       , _       , op_avg)
1214 //QPEL_MC(1, avg_no_rnd , _       , op_avg)
1215 #undef op_avg
1216 #undef op_avg_no_rnd
1217 #undef op_put
1218 #undef op_put_no_rnd
1219
1220 #define put_qpel8_mc00_c  ff_put_pixels8x8_c
1221 #define avg_qpel8_mc00_c  ff_avg_pixels8x8_c
1222 #define put_qpel16_mc00_c ff_put_pixels16x16_c
1223 #define avg_qpel16_mc00_c ff_avg_pixels16x16_c
1224 #define put_no_rnd_qpel8_mc00_c  ff_put_pixels8x8_c
1225 #define put_no_rnd_qpel16_mc00_c ff_put_pixels16x16_8_c
1226
1227 static void wmv2_mspel8_h_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int h){
1228     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1229     int i;
1230
1231     for(i=0; i<h; i++){
1232         dst[0]= cm[(9*(src[0] + src[1]) - (src[-1] + src[2]) + 8)>>4];
1233         dst[1]= cm[(9*(src[1] + src[2]) - (src[ 0] + src[3]) + 8)>>4];
1234         dst[2]= cm[(9*(src[2] + src[3]) - (src[ 1] + src[4]) + 8)>>4];
1235         dst[3]= cm[(9*(src[3] + src[4]) - (src[ 2] + src[5]) + 8)>>4];
1236         dst[4]= cm[(9*(src[4] + src[5]) - (src[ 3] + src[6]) + 8)>>4];
1237         dst[5]= cm[(9*(src[5] + src[6]) - (src[ 4] + src[7]) + 8)>>4];
1238         dst[6]= cm[(9*(src[6] + src[7]) - (src[ 5] + src[8]) + 8)>>4];
1239         dst[7]= cm[(9*(src[7] + src[8]) - (src[ 6] + src[9]) + 8)>>4];
1240         dst+=dstStride;
1241         src+=srcStride;
1242     }
1243 }
1244
1245 #if CONFIG_RV40_DECODER
1246 void ff_put_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1247     put_pixels16_xy2_8_c(dst, src, stride, 16);
1248 }
1249 void ff_avg_rv40_qpel16_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1250     avg_pixels16_xy2_8_c(dst, src, stride, 16);
1251 }
1252 void ff_put_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1253     put_pixels8_xy2_8_c(dst, src, stride, 8);
1254 }
1255 void ff_avg_rv40_qpel8_mc33_c(uint8_t *dst, uint8_t *src, int stride){
1256     avg_pixels8_xy2_8_c(dst, src, stride, 8);
1257 }
1258 #endif /* CONFIG_RV40_DECODER */
1259
1260 static void wmv2_mspel8_v_lowpass(uint8_t *dst, uint8_t *src, int dstStride, int srcStride, int w){
1261     uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
1262     int i;
1263
1264     for(i=0; i<w; i++){
1265         const int src_1= src[ -srcStride];
1266         const int src0 = src[0          ];
1267         const int src1 = src[  srcStride];
1268         const int src2 = src[2*srcStride];
1269         const int src3 = src[3*srcStride];
1270         const int src4 = src[4*srcStride];
1271         const int src5 = src[5*srcStride];
1272         const int src6 = src[6*srcStride];
1273         const int src7 = src[7*srcStride];
1274         const int src8 = src[8*srcStride];
1275         const int src9 = src[9*srcStride];
1276         dst[0*dstStride]= cm[(9*(src0 + src1) - (src_1 + src2) + 8)>>4];
1277         dst[1*dstStride]= cm[(9*(src1 + src2) - (src0  + src3) + 8)>>4];
1278         dst[2*dstStride]= cm[(9*(src2 + src3) - (src1  + src4) + 8)>>4];
1279         dst[3*dstStride]= cm[(9*(src3 + src4) - (src2  + src5) + 8)>>4];
1280         dst[4*dstStride]= cm[(9*(src4 + src5) - (src3  + src6) + 8)>>4];
1281         dst[5*dstStride]= cm[(9*(src5 + src6) - (src4  + src7) + 8)>>4];
1282         dst[6*dstStride]= cm[(9*(src6 + src7) - (src5  + src8) + 8)>>4];
1283         dst[7*dstStride]= cm[(9*(src7 + src8) - (src6  + src9) + 8)>>4];
1284         src++;
1285         dst++;
1286     }
1287 }
1288
1289 static void put_mspel8_mc10_c(uint8_t *dst, uint8_t *src, int stride){
1290     uint8_t half[64];
1291     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1292     put_pixels8_l2_8(dst, src, half, stride, stride, 8, 8);
1293 }
1294
1295 static void put_mspel8_mc20_c(uint8_t *dst, uint8_t *src, int stride){
1296     wmv2_mspel8_h_lowpass(dst, src, stride, stride, 8);
1297 }
1298
1299 static void put_mspel8_mc30_c(uint8_t *dst, uint8_t *src, int stride){
1300     uint8_t half[64];
1301     wmv2_mspel8_h_lowpass(half, src, 8, stride, 8);
1302     put_pixels8_l2_8(dst, src+1, half, stride, stride, 8, 8);
1303 }
1304
1305 static void put_mspel8_mc02_c(uint8_t *dst, uint8_t *src, int stride){
1306     wmv2_mspel8_v_lowpass(dst, src, stride, stride, 8);
1307 }
1308
1309 static void put_mspel8_mc12_c(uint8_t *dst, uint8_t *src, int stride){
1310     uint8_t halfH[88];
1311     uint8_t halfV[64];
1312     uint8_t halfHV[64];
1313     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1314     wmv2_mspel8_v_lowpass(halfV, src, 8, stride, 8);
1315     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1316     put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1317 }
1318 static void put_mspel8_mc32_c(uint8_t *dst, uint8_t *src, int stride){
1319     uint8_t halfH[88];
1320     uint8_t halfV[64];
1321     uint8_t halfHV[64];
1322     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1323     wmv2_mspel8_v_lowpass(halfV, src+1, 8, stride, 8);
1324     wmv2_mspel8_v_lowpass(halfHV, halfH+8, 8, 8, 8);
1325     put_pixels8_l2_8(dst, halfV, halfHV, stride, 8, 8, 8);
1326 }
1327 static void put_mspel8_mc22_c(uint8_t *dst, uint8_t *src, int stride){
1328     uint8_t halfH[88];
1329     wmv2_mspel8_h_lowpass(halfH, src-stride, 8, stride, 11);
1330     wmv2_mspel8_v_lowpass(dst, halfH+8, stride, 8, 8);
1331 }
1332
1333 static void h263_v_loop_filter_c(uint8_t *src, int stride, int qscale){
1334     if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1335     int x;
1336     const int strength= ff_h263_loop_filter_strength[qscale];
1337
1338     for(x=0; x<8; x++){
1339         int d1, d2, ad1;
1340         int p0= src[x-2*stride];
1341         int p1= src[x-1*stride];
1342         int p2= src[x+0*stride];
1343         int p3= src[x+1*stride];
1344         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1345
1346         if     (d<-2*strength) d1= 0;
1347         else if(d<-  strength) d1=-2*strength - d;
1348         else if(d<   strength) d1= d;
1349         else if(d< 2*strength) d1= 2*strength - d;
1350         else                   d1= 0;
1351
1352         p1 += d1;
1353         p2 -= d1;
1354         if(p1&256) p1= ~(p1>>31);
1355         if(p2&256) p2= ~(p2>>31);
1356
1357         src[x-1*stride] = p1;
1358         src[x+0*stride] = p2;
1359
1360         ad1= FFABS(d1)>>1;
1361
1362         d2= av_clip((p0-p3)/4, -ad1, ad1);
1363
1364         src[x-2*stride] = p0 - d2;
1365         src[x+  stride] = p3 + d2;
1366     }
1367     }
1368 }
1369
1370 static void h263_h_loop_filter_c(uint8_t *src, int stride, int qscale){
1371     if(CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
1372     int y;
1373     const int strength= ff_h263_loop_filter_strength[qscale];
1374
1375     for(y=0; y<8; y++){
1376         int d1, d2, ad1;
1377         int p0= src[y*stride-2];
1378         int p1= src[y*stride-1];
1379         int p2= src[y*stride+0];
1380         int p3= src[y*stride+1];
1381         int d = (p0 - p3 + 4*(p2 - p1)) / 8;
1382
1383         if     (d<-2*strength) d1= 0;
1384         else if(d<-  strength) d1=-2*strength - d;
1385         else if(d<   strength) d1= d;
1386         else if(d< 2*strength) d1= 2*strength - d;
1387         else                   d1= 0;
1388
1389         p1 += d1;
1390         p2 -= d1;
1391         if(p1&256) p1= ~(p1>>31);
1392         if(p2&256) p2= ~(p2>>31);
1393
1394         src[y*stride-1] = p1;
1395         src[y*stride+0] = p2;
1396
1397         ad1= FFABS(d1)>>1;
1398
1399         d2= av_clip((p0-p3)/4, -ad1, ad1);
1400
1401         src[y*stride-2] = p0 - d2;
1402         src[y*stride+1] = p3 + d2;
1403     }
1404     }
1405 }
1406
1407 static void h261_loop_filter_c(uint8_t *src, int stride){
1408     int x,y,xy,yz;
1409     int temp[64];
1410
1411     for(x=0; x<8; x++){
1412         temp[x      ] = 4*src[x           ];
1413         temp[x + 7*8] = 4*src[x + 7*stride];
1414     }
1415     for(y=1; y<7; y++){
1416         for(x=0; x<8; x++){
1417             xy = y * stride + x;
1418             yz = y * 8 + x;
1419             temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
1420         }
1421     }
1422
1423     for(y=0; y<8; y++){
1424         src[  y*stride] = (temp[  y*8] + 2)>>2;
1425         src[7+y*stride] = (temp[7+y*8] + 2)>>2;
1426         for(x=1; x<7; x++){
1427             xy = y * stride + x;
1428             yz = y * 8 + x;
1429             src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
1430         }
1431     }
1432 }
1433
1434 static inline int pix_abs16_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1435 {
1436     int s, i;
1437
1438     s = 0;
1439     for(i=0;i<h;i++) {
1440         s += abs(pix1[0] - pix2[0]);
1441         s += abs(pix1[1] - pix2[1]);
1442         s += abs(pix1[2] - pix2[2]);
1443         s += abs(pix1[3] - pix2[3]);
1444         s += abs(pix1[4] - pix2[4]);
1445         s += abs(pix1[5] - pix2[5]);
1446         s += abs(pix1[6] - pix2[6]);
1447         s += abs(pix1[7] - pix2[7]);
1448         s += abs(pix1[8] - pix2[8]);
1449         s += abs(pix1[9] - pix2[9]);
1450         s += abs(pix1[10] - pix2[10]);
1451         s += abs(pix1[11] - pix2[11]);
1452         s += abs(pix1[12] - pix2[12]);
1453         s += abs(pix1[13] - pix2[13]);
1454         s += abs(pix1[14] - pix2[14]);
1455         s += abs(pix1[15] - pix2[15]);
1456         pix1 += line_size;
1457         pix2 += line_size;
1458     }
1459     return s;
1460 }
1461
1462 static int pix_abs16_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1463 {
1464     int s, i;
1465
1466     s = 0;
1467     for(i=0;i<h;i++) {
1468         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1469         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1470         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1471         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1472         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1473         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1474         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1475         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1476         s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
1477         s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
1478         s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
1479         s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
1480         s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
1481         s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
1482         s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
1483         s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
1484         pix1 += line_size;
1485         pix2 += line_size;
1486     }
1487     return s;
1488 }
1489
1490 static int pix_abs16_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1491 {
1492     int s, i;
1493     uint8_t *pix3 = pix2 + line_size;
1494
1495     s = 0;
1496     for(i=0;i<h;i++) {
1497         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1498         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1499         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1500         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1501         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1502         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1503         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1504         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1505         s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
1506         s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
1507         s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
1508         s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
1509         s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
1510         s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
1511         s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
1512         s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
1513         pix1 += line_size;
1514         pix2 += line_size;
1515         pix3 += line_size;
1516     }
1517     return s;
1518 }
1519
1520 static int pix_abs16_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1521 {
1522     int s, i;
1523     uint8_t *pix3 = pix2 + line_size;
1524
1525     s = 0;
1526     for(i=0;i<h;i++) {
1527         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1528         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1529         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1530         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1531         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1532         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1533         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1534         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1535         s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
1536         s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
1537         s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
1538         s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
1539         s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
1540         s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
1541         s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
1542         s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
1543         pix1 += line_size;
1544         pix2 += line_size;
1545         pix3 += line_size;
1546     }
1547     return s;
1548 }
1549
1550 static inline int pix_abs8_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1551 {
1552     int s, i;
1553
1554     s = 0;
1555     for(i=0;i<h;i++) {
1556         s += abs(pix1[0] - pix2[0]);
1557         s += abs(pix1[1] - pix2[1]);
1558         s += abs(pix1[2] - pix2[2]);
1559         s += abs(pix1[3] - pix2[3]);
1560         s += abs(pix1[4] - pix2[4]);
1561         s += abs(pix1[5] - pix2[5]);
1562         s += abs(pix1[6] - pix2[6]);
1563         s += abs(pix1[7] - pix2[7]);
1564         pix1 += line_size;
1565         pix2 += line_size;
1566     }
1567     return s;
1568 }
1569
1570 static int pix_abs8_x2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1571 {
1572     int s, i;
1573
1574     s = 0;
1575     for(i=0;i<h;i++) {
1576         s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
1577         s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
1578         s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
1579         s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
1580         s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
1581         s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
1582         s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
1583         s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
1584         pix1 += line_size;
1585         pix2 += line_size;
1586     }
1587     return s;
1588 }
1589
1590 static int pix_abs8_y2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1591 {
1592     int s, i;
1593     uint8_t *pix3 = pix2 + line_size;
1594
1595     s = 0;
1596     for(i=0;i<h;i++) {
1597         s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
1598         s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
1599         s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
1600         s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
1601         s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
1602         s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
1603         s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
1604         s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
1605         pix1 += line_size;
1606         pix2 += line_size;
1607         pix3 += line_size;
1608     }
1609     return s;
1610 }
1611
1612 static int pix_abs8_xy2_c(void *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
1613 {
1614     int s, i;
1615     uint8_t *pix3 = pix2 + line_size;
1616
1617     s = 0;
1618     for(i=0;i<h;i++) {
1619         s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
1620         s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
1621         s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
1622         s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
1623         s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
1624         s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
1625         s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
1626         s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
1627         pix1 += line_size;
1628         pix2 += line_size;
1629         pix3 += line_size;
1630     }
1631     return s;
1632 }
1633
1634 static int nsse16_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1635     MpegEncContext *c = v;
1636     int score1=0;
1637     int score2=0;
1638     int x,y;
1639
1640     for(y=0; y<h; y++){
1641         for(x=0; x<16; x++){
1642             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
1643         }
1644         if(y+1<h){
1645             for(x=0; x<15; x++){
1646                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
1647                              - s1[x+1] + s1[x+1+stride])
1648                         -FFABS(  s2[x  ] - s2[x  +stride]
1649                              - s2[x+1] + s2[x+1+stride]);
1650             }
1651         }
1652         s1+= stride;
1653         s2+= stride;
1654     }
1655
1656     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1657     else  return score1 + FFABS(score2)*8;
1658 }
1659
1660 static int nsse8_c(void *v, uint8_t *s1, uint8_t *s2, int stride, int h){
1661     MpegEncContext *c = v;
1662     int score1=0;
1663     int score2=0;
1664     int x,y;
1665
1666     for(y=0; y<h; y++){
1667         for(x=0; x<8; x++){
1668             score1+= (s1[x  ] - s2[x ])*(s1[x  ] - s2[x ]);
1669         }
1670         if(y+1<h){
1671             for(x=0; x<7; x++){
1672                 score2+= FFABS(  s1[x  ] - s1[x  +stride]
1673                              - s1[x+1] + s1[x+1+stride])
1674                         -FFABS(  s2[x  ] - s2[x  +stride]
1675                              - s2[x+1] + s2[x+1+stride]);
1676             }
1677         }
1678         s1+= stride;
1679         s2+= stride;
1680     }
1681
1682     if(c) return score1 + FFABS(score2)*c->avctx->nsse_weight;
1683     else  return score1 + FFABS(score2)*8;
1684 }
1685
1686 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64], int16_t basis[64], int scale){
1687     int i;
1688     unsigned int sum=0;
1689
1690     for(i=0; i<8*8; i++){
1691         int b= rem[i] + ((basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT));
1692         int w= weight[i];
1693         b>>= RECON_SHIFT;
1694         assert(-512<b && b<512);
1695
1696         sum += (w*b)*(w*b)>>4;
1697     }
1698     return sum>>2;
1699 }
1700
1701 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale){
1702     int i;
1703
1704     for(i=0; i<8*8; i++){
1705         rem[i] += (basis[i]*scale + (1<<(BASIS_SHIFT - RECON_SHIFT-1)))>>(BASIS_SHIFT - RECON_SHIFT);
1706     }
1707 }
1708
1709 /**
1710  * Permute an 8x8 block.
1711  * @param block the block which will be permuted according to the given permutation vector
1712  * @param permutation the permutation vector
1713  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
1714  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
1715  *                  (inverse) permutated to scantable order!
1716  */
1717 void ff_block_permute(DCTELEM *block, uint8_t *permutation, const uint8_t *scantable, int last)
1718 {
1719     int i;
1720     DCTELEM temp[64];
1721
1722     if(last<=0) return;
1723     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
1724
1725     for(i=0; i<=last; i++){
1726         const int j= scantable[i];
1727         temp[j]= block[j];
1728         block[j]=0;
1729     }
1730
1731     for(i=0; i<=last; i++){
1732         const int j= scantable[i];
1733         const int perm_j= permutation[j];
1734         block[perm_j]= temp[j];
1735     }
1736 }
1737
1738 static int zero_cmp(void *s, uint8_t *a, uint8_t *b, int stride, int h){
1739     return 0;
1740 }
1741
1742 void ff_set_cmp(DSPContext* c, me_cmp_func *cmp, int type){
1743     int i;
1744
1745     memset(cmp, 0, sizeof(void*)*6);
1746
1747     for(i=0; i<6; i++){
1748         switch(type&0xFF){
1749         case FF_CMP_SAD:
1750             cmp[i]= c->sad[i];
1751             break;
1752         case FF_CMP_SATD:
1753             cmp[i]= c->hadamard8_diff[i];
1754             break;
1755         case FF_CMP_SSE:
1756             cmp[i]= c->sse[i];
1757             break;
1758         case FF_CMP_DCT:
1759             cmp[i]= c->dct_sad[i];
1760             break;
1761         case FF_CMP_DCT264:
1762             cmp[i]= c->dct264_sad[i];
1763             break;
1764         case FF_CMP_DCTMAX:
1765             cmp[i]= c->dct_max[i];
1766             break;
1767         case FF_CMP_PSNR:
1768             cmp[i]= c->quant_psnr[i];
1769             break;
1770         case FF_CMP_BIT:
1771             cmp[i]= c->bit[i];
1772             break;
1773         case FF_CMP_RD:
1774             cmp[i]= c->rd[i];
1775             break;
1776         case FF_CMP_VSAD:
1777             cmp[i]= c->vsad[i];
1778             break;
1779         case FF_CMP_VSSE:
1780             cmp[i]= c->vsse[i];
1781             break;
1782         case FF_CMP_ZERO:
1783             cmp[i]= zero_cmp;
1784             break;
1785         case FF_CMP_NSSE:
1786             cmp[i]= c->nsse[i];
1787             break;
1788 #if CONFIG_DWT
1789         case FF_CMP_W53:
1790             cmp[i]= c->w53[i];
1791             break;
1792         case FF_CMP_W97:
1793             cmp[i]= c->w97[i];
1794             break;
1795 #endif
1796         default:
1797             av_log(NULL, AV_LOG_ERROR,"internal error in cmp function selection\n");
1798         }
1799     }
1800 }
1801
1802 static void add_bytes_c(uint8_t *dst, uint8_t *src, int w){
1803     long i;
1804     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1805         long a = *(long*)(src+i);
1806         long b = *(long*)(dst+i);
1807         *(long*)(dst+i) = ((a&pb_7f) + (b&pb_7f)) ^ ((a^b)&pb_80);
1808     }
1809     for(; i<w; i++)
1810         dst[i+0] += src[i+0];
1811 }
1812
1813 static void diff_bytes_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w){
1814     long i;
1815 #if !HAVE_FAST_UNALIGNED
1816     if((long)src2 & (sizeof(long)-1)){
1817         for(i=0; i+7<w; i+=8){
1818             dst[i+0] = src1[i+0]-src2[i+0];
1819             dst[i+1] = src1[i+1]-src2[i+1];
1820             dst[i+2] = src1[i+2]-src2[i+2];
1821             dst[i+3] = src1[i+3]-src2[i+3];
1822             dst[i+4] = src1[i+4]-src2[i+4];
1823             dst[i+5] = src1[i+5]-src2[i+5];
1824             dst[i+6] = src1[i+6]-src2[i+6];
1825             dst[i+7] = src1[i+7]-src2[i+7];
1826         }
1827     }else
1828 #endif
1829     for(i=0; i<=w-sizeof(long); i+=sizeof(long)){
1830         long a = *(long*)(src1+i);
1831         long b = *(long*)(src2+i);
1832         *(long*)(dst+i) = ((a|pb_80) - (b&pb_7f)) ^ ((a^b^pb_80)&pb_80);
1833     }
1834     for(; i<w; i++)
1835         dst[i+0] = src1[i+0]-src2[i+0];
1836 }
1837
1838 static void add_hfyu_median_prediction_c(uint8_t *dst, const uint8_t *src1, const uint8_t *diff, int w, int *left, int *left_top){
1839     int i;
1840     uint8_t l, lt;
1841
1842     l= *left;
1843     lt= *left_top;
1844
1845     for(i=0; i<w; i++){
1846         l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
1847         lt= src1[i];
1848         dst[i]= l;
1849     }
1850
1851     *left= l;
1852     *left_top= lt;
1853 }
1854
1855 static void sub_hfyu_median_prediction_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top){
1856     int i;
1857     uint8_t l, lt;
1858
1859     l= *left;
1860     lt= *left_top;
1861
1862     for(i=0; i<w; i++){
1863         const int pred= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF);
1864         lt= src1[i];
1865         l= src2[i];
1866         dst[i]= l - pred;
1867     }
1868
1869     *left= l;
1870     *left_top= lt;
1871 }
1872
1873 static int add_hfyu_left_prediction_c(uint8_t *dst, const uint8_t *src, int w, int acc){
1874     int i;
1875
1876     for(i=0; i<w-1; i++){
1877         acc+= src[i];
1878         dst[i]= acc;
1879         i++;
1880         acc+= src[i];
1881         dst[i]= acc;
1882     }
1883
1884     for(; i<w; i++){
1885         acc+= src[i];
1886         dst[i]= acc;
1887     }
1888
1889     return acc;
1890 }
1891
1892 #if HAVE_BIGENDIAN
1893 #define B 3
1894 #define G 2
1895 #define R 1
1896 #define A 0
1897 #else
1898 #define B 0
1899 #define G 1
1900 #define R 2
1901 #define A 3
1902 #endif
1903 static void add_hfyu_left_prediction_bgr32_c(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha){
1904     int i;
1905     int r,g,b,a;
1906     r= *red;
1907     g= *green;
1908     b= *blue;
1909     a= *alpha;
1910
1911     for(i=0; i<w; i++){
1912         b+= src[4*i+B];
1913         g+= src[4*i+G];
1914         r+= src[4*i+R];
1915         a+= src[4*i+A];
1916
1917         dst[4*i+B]= b;
1918         dst[4*i+G]= g;
1919         dst[4*i+R]= r;
1920         dst[4*i+A]= a;
1921     }
1922
1923     *red= r;
1924     *green= g;
1925     *blue= b;
1926     *alpha= a;
1927 }
1928 #undef B
1929 #undef G
1930 #undef R
1931 #undef A
1932
1933 #define BUTTERFLY2(o1,o2,i1,i2) \
1934 o1= (i1)+(i2);\
1935 o2= (i1)-(i2);
1936
1937 #define BUTTERFLY1(x,y) \
1938 {\
1939     int a,b;\
1940     a= x;\
1941     b= y;\
1942     x= a+b;\
1943     y= a-b;\
1944 }
1945
1946 #define BUTTERFLYA(x,y) (FFABS((x)+(y)) + FFABS((x)-(y)))
1947
1948 static int hadamard8_diff8x8_c(/*MpegEncContext*/ void *s, uint8_t *dst, uint8_t *src, int stride, int h){
1949     int i;
1950     int temp[64];
1951     int sum=0;
1952
1953     assert(h==8);
1954
1955     for(i=0; i<8; i++){
1956         //FIXME try pointer walks
1957         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]);
1958         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]);
1959         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]);
1960         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]);
1961
1962         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
1963         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
1964         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
1965         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
1966
1967         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
1968         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
1969         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
1970         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
1971     }
1972
1973     for(i=0; i<8; i++){
1974         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
1975         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
1976         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
1977         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
1978
1979         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
1980         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
1981         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
1982         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
1983
1984         sum +=
1985              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
1986             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
1987             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
1988             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
1989     }
1990     return sum;
1991 }
1992
1993 static int hadamard8_intra8x8_c(/*MpegEncContext*/ void *s, uint8_t *src, uint8_t *dummy, int stride, int h){
1994     int i;
1995     int temp[64];
1996     int sum=0;
1997
1998     assert(h==8);
1999
2000     for(i=0; i<8; i++){
2001         //FIXME try pointer walks
2002         BUTTERFLY2(temp[8*i+0], temp[8*i+1], src[stride*i+0],src[stride*i+1]);
2003         BUTTERFLY2(temp[8*i+2], temp[8*i+3], src[stride*i+2],src[stride*i+3]);
2004         BUTTERFLY2(temp[8*i+4], temp[8*i+5], src[stride*i+4],src[stride*i+5]);
2005         BUTTERFLY2(temp[8*i+6], temp[8*i+7], src[stride*i+6],src[stride*i+7]);
2006
2007         BUTTERFLY1(temp[8*i+0], temp[8*i+2]);
2008         BUTTERFLY1(temp[8*i+1], temp[8*i+3]);
2009         BUTTERFLY1(temp[8*i+4], temp[8*i+6]);
2010         BUTTERFLY1(temp[8*i+5], temp[8*i+7]);
2011
2012         BUTTERFLY1(temp[8*i+0], temp[8*i+4]);
2013         BUTTERFLY1(temp[8*i+1], temp[8*i+5]);
2014         BUTTERFLY1(temp[8*i+2], temp[8*i+6]);
2015         BUTTERFLY1(temp[8*i+3], temp[8*i+7]);
2016     }
2017
2018     for(i=0; i<8; i++){
2019         BUTTERFLY1(temp[8*0+i], temp[8*1+i]);
2020         BUTTERFLY1(temp[8*2+i], temp[8*3+i]);
2021         BUTTERFLY1(temp[8*4+i], temp[8*5+i]);
2022         BUTTERFLY1(temp[8*6+i], temp[8*7+i]);
2023
2024         BUTTERFLY1(temp[8*0+i], temp[8*2+i]);
2025         BUTTERFLY1(temp[8*1+i], temp[8*3+i]);
2026         BUTTERFLY1(temp[8*4+i], temp[8*6+i]);
2027         BUTTERFLY1(temp[8*5+i], temp[8*7+i]);
2028
2029         sum +=
2030              BUTTERFLYA(temp[8*0+i], temp[8*4+i])
2031             +BUTTERFLYA(temp[8*1+i], temp[8*5+i])
2032             +BUTTERFLYA(temp[8*2+i], temp[8*6+i])
2033             +BUTTERFLYA(temp[8*3+i], temp[8*7+i]);
2034     }
2035
2036     sum -= FFABS(temp[8*0] + temp[8*4]); // -mean
2037
2038     return sum;
2039 }
2040
2041 static int dct_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2042     MpegEncContext * const s= (MpegEncContext *)c;
2043     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2044
2045     assert(h==8);
2046
2047     s->dsp.diff_pixels(temp, src1, src2, stride);
2048     s->dsp.fdct(temp);
2049     return s->dsp.sum_abs_dctelem(temp);
2050 }
2051
2052 #if CONFIG_GPL
2053 #define DCT8_1D {\
2054     const int s07 = SRC(0) + SRC(7);\
2055     const int s16 = SRC(1) + SRC(6);\
2056     const int s25 = SRC(2) + SRC(5);\
2057     const int s34 = SRC(3) + SRC(4);\
2058     const int a0 = s07 + s34;\
2059     const int a1 = s16 + s25;\
2060     const int a2 = s07 - s34;\
2061     const int a3 = s16 - s25;\
2062     const int d07 = SRC(0) - SRC(7);\
2063     const int d16 = SRC(1) - SRC(6);\
2064     const int d25 = SRC(2) - SRC(5);\
2065     const int d34 = SRC(3) - SRC(4);\
2066     const int a4 = d16 + d25 + (d07 + (d07>>1));\
2067     const int a5 = d07 - d34 - (d25 + (d25>>1));\
2068     const int a6 = d07 + d34 - (d16 + (d16>>1));\
2069     const int a7 = d16 - d25 + (d34 + (d34>>1));\
2070     DST(0,  a0 + a1     ) ;\
2071     DST(1,  a4 + (a7>>2)) ;\
2072     DST(2,  a2 + (a3>>1)) ;\
2073     DST(3,  a5 + (a6>>2)) ;\
2074     DST(4,  a0 - a1     ) ;\
2075     DST(5,  a6 - (a5>>2)) ;\
2076     DST(6, (a2>>1) - a3 ) ;\
2077     DST(7, (a4>>2) - a7 ) ;\
2078 }
2079
2080 static int dct264_sad8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2081     MpegEncContext * const s= (MpegEncContext *)c;
2082     DCTELEM dct[8][8];
2083     int i;
2084     int sum=0;
2085
2086     s->dsp.diff_pixels(dct[0], src1, src2, stride);
2087
2088 #define SRC(x) dct[i][x]
2089 #define DST(x,v) dct[i][x]= v
2090     for( i = 0; i < 8; i++ )
2091         DCT8_1D
2092 #undef SRC
2093 #undef DST
2094
2095 #define SRC(x) dct[x][i]
2096 #define DST(x,v) sum += FFABS(v)
2097     for( i = 0; i < 8; i++ )
2098         DCT8_1D
2099 #undef SRC
2100 #undef DST
2101     return sum;
2102 }
2103 #endif
2104
2105 static int dct_max8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2106     MpegEncContext * const s= (MpegEncContext *)c;
2107     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2108     int sum=0, i;
2109
2110     assert(h==8);
2111
2112     s->dsp.diff_pixels(temp, src1, src2, stride);
2113     s->dsp.fdct(temp);
2114
2115     for(i=0; i<64; i++)
2116         sum= FFMAX(sum, FFABS(temp[i]));
2117
2118     return sum;
2119 }
2120
2121 static int quant_psnr8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2122     MpegEncContext * const s= (MpegEncContext *)c;
2123     LOCAL_ALIGNED_16(DCTELEM, temp, [64*2]);
2124     DCTELEM * const bak = temp+64;
2125     int sum=0, i;
2126
2127     assert(h==8);
2128     s->mb_intra=0;
2129
2130     s->dsp.diff_pixels(temp, src1, src2, stride);
2131
2132     memcpy(bak, temp, 64*sizeof(DCTELEM));
2133
2134     s->block_last_index[0/*FIXME*/]= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2135     s->dct_unquantize_inter(s, temp, 0, s->qscale);
2136     ff_simple_idct_8(temp); //FIXME
2137
2138     for(i=0; i<64; i++)
2139         sum+= (temp[i]-bak[i])*(temp[i]-bak[i]);
2140
2141     return sum;
2142 }
2143
2144 static int rd8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2145     MpegEncContext * const s= (MpegEncContext *)c;
2146     const uint8_t *scantable= s->intra_scantable.permutated;
2147     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2148     LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
2149     LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
2150     int i, last, run, bits, level, distortion, start_i;
2151     const int esc_length= s->ac_esc_length;
2152     uint8_t * length;
2153     uint8_t * last_length;
2154
2155     assert(h==8);
2156
2157     copy_block8(lsrc1, src1, 8, stride, 8);
2158     copy_block8(lsrc2, src2, 8, stride, 8);
2159
2160     s->dsp.diff_pixels(temp, lsrc1, lsrc2, 8);
2161
2162     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2163
2164     bits=0;
2165
2166     if (s->mb_intra) {
2167         start_i = 1;
2168         length     = s->intra_ac_vlc_length;
2169         last_length= s->intra_ac_vlc_last_length;
2170         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2171     } else {
2172         start_i = 0;
2173         length     = s->inter_ac_vlc_length;
2174         last_length= s->inter_ac_vlc_last_length;
2175     }
2176
2177     if(last>=start_i){
2178         run=0;
2179         for(i=start_i; i<last; i++){
2180             int j= scantable[i];
2181             level= temp[j];
2182
2183             if(level){
2184                 level+=64;
2185                 if((level&(~127)) == 0){
2186                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
2187                 }else
2188                     bits+= esc_length;
2189                 run=0;
2190             }else
2191                 run++;
2192         }
2193         i= scantable[last];
2194
2195         level= temp[i] + 64;
2196
2197         assert(level - 64);
2198
2199         if((level&(~127)) == 0){
2200             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2201         }else
2202             bits+= esc_length;
2203
2204     }
2205
2206     if(last>=0){
2207         if(s->mb_intra)
2208             s->dct_unquantize_intra(s, temp, 0, s->qscale);
2209         else
2210             s->dct_unquantize_inter(s, temp, 0, s->qscale);
2211     }
2212
2213     s->dsp.idct_add(lsrc2, 8, temp);
2214
2215     distortion= s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);
2216
2217     return distortion + ((bits*s->qscale*s->qscale*109 + 64)>>7);
2218 }
2219
2220 static int bit8x8_c(/*MpegEncContext*/ void *c, uint8_t *src1, uint8_t *src2, int stride, int h){
2221     MpegEncContext * const s= (MpegEncContext *)c;
2222     const uint8_t *scantable= s->intra_scantable.permutated;
2223     LOCAL_ALIGNED_16(DCTELEM, temp, [64]);
2224     int i, last, run, bits, level, start_i;
2225     const int esc_length= s->ac_esc_length;
2226     uint8_t * length;
2227     uint8_t * last_length;
2228
2229     assert(h==8);
2230
2231     s->dsp.diff_pixels(temp, src1, src2, stride);
2232
2233     s->block_last_index[0/*FIXME*/]= last= s->fast_dct_quantize(s, temp, 0/*FIXME*/, s->qscale, &i);
2234
2235     bits=0;
2236
2237     if (s->mb_intra) {
2238         start_i = 1;
2239         length     = s->intra_ac_vlc_length;
2240         last_length= s->intra_ac_vlc_last_length;
2241         bits+= s->luma_dc_vlc_length[temp[0] + 256]; //FIXME chroma
2242     } else {
2243         start_i = 0;
2244         length     = s->inter_ac_vlc_length;
2245         last_length= s->inter_ac_vlc_last_length;
2246     }
2247
2248     if(last>=start_i){
2249         run=0;
2250         for(i=start_i; i<last; i++){
2251             int j= scantable[i];
2252             level= temp[j];
2253
2254             if(level){
2255                 level+=64;
2256                 if((level&(~127)) == 0){
2257                     bits+= length[UNI_AC_ENC_INDEX(run, level)];
2258                 }else
2259                     bits+= esc_length;
2260                 run=0;
2261             }else
2262                 run++;
2263         }
2264         i= scantable[last];
2265
2266         level= temp[i] + 64;
2267
2268         assert(level - 64);
2269
2270         if((level&(~127)) == 0){
2271             bits+= last_length[UNI_AC_ENC_INDEX(run, level)];
2272         }else
2273             bits+= esc_length;
2274     }
2275
2276     return bits;
2277 }
2278
2279 #define VSAD_INTRA(size) \
2280 static int vsad_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2281     int score=0;                                                                                            \
2282     int x,y;                                                                                                \
2283                                                                                                             \
2284     for(y=1; y<h; y++){                                                                                     \
2285         for(x=0; x<size; x+=4){                                                                             \
2286             score+= FFABS(s[x  ] - s[x  +stride]) + FFABS(s[x+1] - s[x+1+stride])                           \
2287                    +FFABS(s[x+2] - s[x+2+stride]) + FFABS(s[x+3] - s[x+3+stride]);                          \
2288         }                                                                                                   \
2289         s+= stride;                                                                                         \
2290     }                                                                                                       \
2291                                                                                                             \
2292     return score;                                                                                           \
2293 }
2294 VSAD_INTRA(8)
2295 VSAD_INTRA(16)
2296
2297 static int vsad16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2298     int score=0;
2299     int x,y;
2300
2301     for(y=1; y<h; y++){
2302         for(x=0; x<16; x++){
2303             score+= FFABS(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2304         }
2305         s1+= stride;
2306         s2+= stride;
2307     }
2308
2309     return score;
2310 }
2311
2312 #define SQ(a) ((a)*(a))
2313 #define VSSE_INTRA(size) \
2314 static int vsse_intra##size##_c(/*MpegEncContext*/ void *c, uint8_t *s, uint8_t *dummy, int stride, int h){ \
2315     int score=0;                                                                                            \
2316     int x,y;                                                                                                \
2317                                                                                                             \
2318     for(y=1; y<h; y++){                                                                                     \
2319         for(x=0; x<size; x+=4){                                                                               \
2320             score+= SQ(s[x  ] - s[x  +stride]) + SQ(s[x+1] - s[x+1+stride])                                 \
2321                    +SQ(s[x+2] - s[x+2+stride]) + SQ(s[x+3] - s[x+3+stride]);                                \
2322         }                                                                                                   \
2323         s+= stride;                                                                                         \
2324     }                                                                                                       \
2325                                                                                                             \
2326     return score;                                                                                           \
2327 }
2328 VSSE_INTRA(8)
2329 VSSE_INTRA(16)
2330
2331 static int vsse16_c(/*MpegEncContext*/ void *c, uint8_t *s1, uint8_t *s2, int stride, int h){
2332     int score=0;
2333     int x,y;
2334
2335     for(y=1; y<h; y++){
2336         for(x=0; x<16; x++){
2337             score+= SQ(s1[x  ] - s2[x ] - s1[x  +stride] + s2[x +stride]);
2338         }
2339         s1+= stride;
2340         s2+= stride;
2341     }
2342
2343     return score;
2344 }
2345
2346 static int ssd_int8_vs_int16_c(const int8_t *pix1, const int16_t *pix2,
2347                                int size){
2348     int score=0;
2349     int i;
2350     for(i=0; i<size; i++)
2351         score += (pix1[i]-pix2[i])*(pix1[i]-pix2[i]);
2352     return score;
2353 }
2354
2355 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
2356 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
2357 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
2358 #if CONFIG_GPL
2359 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
2360 #endif
2361 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
2362 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
2363 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
2364 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
2365
2366 static void vector_fmul_c(float *dst, const float *src0, const float *src1, int len){
2367     int i;
2368     for(i=0; i<len; i++)
2369         dst[i] = src0[i] * src1[i];
2370 }
2371
2372 static void vector_fmul_reverse_c(float *dst, const float *src0, const float *src1, int len){
2373     int i;
2374     src1 += len-1;
2375     for(i=0; i<len; i++)
2376         dst[i] = src0[i] * src1[-i];
2377 }
2378
2379 static void vector_fmul_add_c(float *dst, const float *src0, const float *src1, const float *src2, int len){
2380     int i;
2381     for(i=0; i<len; i++)
2382         dst[i] = src0[i] * src1[i] + src2[i];
2383 }
2384
2385 static void vector_fmul_window_c(float *dst, const float *src0,
2386                                  const float *src1, const float *win, int len)
2387 {
2388     int i,j;
2389     dst += len;
2390     win += len;
2391     src0+= len;
2392     for(i=-len, j=len-1; i<0; i++, j--) {
2393         float s0 = src0[i];
2394         float s1 = src1[j];
2395         float wi = win[i];
2396         float wj = win[j];
2397         dst[i] = s0*wj - s1*wi;
2398         dst[j] = s0*wi + s1*wj;
2399     }
2400 }
2401
2402 static void vector_fmul_scalar_c(float *dst, const float *src, float mul,
2403                                  int len)
2404 {
2405     int i;
2406     for (i = 0; i < len; i++)
2407         dst[i] = src[i] * mul;
2408 }
2409
2410 static void vector_fmac_scalar_c(float *dst, const float *src, float mul,
2411                                  int len)
2412 {
2413     int i;
2414     for (i = 0; i < len; i++)
2415         dst[i] += src[i] * mul;
2416 }
2417
2418 static void butterflies_float_c(float *restrict v1, float *restrict v2,
2419                                 int len)
2420 {
2421     int i;
2422     for (i = 0; i < len; i++) {
2423         float t = v1[i] - v2[i];
2424         v1[i] += v2[i];
2425         v2[i] = t;
2426     }
2427 }
2428
2429 static void butterflies_float_interleave_c(float *dst, const float *src0,
2430                                            const float *src1, int len)
2431 {
2432     int i;
2433     for (i = 0; i < len; i++) {
2434         float f1 = src0[i];
2435         float f2 = src1[i];
2436         dst[2*i    ] = f1 + f2;
2437         dst[2*i + 1] = f1 - f2;
2438     }
2439 }
2440
2441 static float scalarproduct_float_c(const float *v1, const float *v2, int len)
2442 {
2443     float p = 0.0;
2444     int i;
2445
2446     for (i = 0; i < len; i++)
2447         p += v1[i] * v2[i];
2448
2449     return p;
2450 }
2451
2452 static inline uint32_t clipf_c_one(uint32_t a, uint32_t mini,
2453                    uint32_t maxi, uint32_t maxisign)
2454 {
2455
2456     if(a > mini) return mini;
2457     else if((a^(1U<<31)) > maxisign) return maxi;
2458     else return a;
2459 }
2460
2461 static void vector_clipf_c_opposite_sign(float *dst, const float *src, float *min, float *max, int len){
2462     int i;
2463     uint32_t mini = *(uint32_t*)min;
2464     uint32_t maxi = *(uint32_t*)max;
2465     uint32_t maxisign = maxi ^ (1U<<31);
2466     uint32_t *dsti = (uint32_t*)dst;
2467     const uint32_t *srci = (const uint32_t*)src;
2468     for(i=0; i<len; i+=8) {
2469         dsti[i + 0] = clipf_c_one(srci[i + 0], mini, maxi, maxisign);
2470         dsti[i + 1] = clipf_c_one(srci[i + 1], mini, maxi, maxisign);
2471         dsti[i + 2] = clipf_c_one(srci[i + 2], mini, maxi, maxisign);
2472         dsti[i + 3] = clipf_c_one(srci[i + 3], mini, maxi, maxisign);
2473         dsti[i + 4] = clipf_c_one(srci[i + 4], mini, maxi, maxisign);
2474         dsti[i + 5] = clipf_c_one(srci[i + 5], mini, maxi, maxisign);
2475         dsti[i + 6] = clipf_c_one(srci[i + 6], mini, maxi, maxisign);
2476         dsti[i + 7] = clipf_c_one(srci[i + 7], mini, maxi, maxisign);
2477     }
2478 }
2479 static void vector_clipf_c(float *dst, const float *src, float min, float max, int len){
2480     int i;
2481     if(min < 0 && max > 0) {
2482         vector_clipf_c_opposite_sign(dst, src, &min, &max, len);
2483     } else {
2484         for(i=0; i < len; i+=8) {
2485             dst[i    ] = av_clipf(src[i    ], min, max);
2486             dst[i + 1] = av_clipf(src[i + 1], min, max);
2487             dst[i + 2] = av_clipf(src[i + 2], min, max);
2488             dst[i + 3] = av_clipf(src[i + 3], min, max);
2489             dst[i + 4] = av_clipf(src[i + 4], min, max);
2490             dst[i + 5] = av_clipf(src[i + 5], min, max);
2491             dst[i + 6] = av_clipf(src[i + 6], min, max);
2492             dst[i + 7] = av_clipf(src[i + 7], min, max);
2493         }
2494     }
2495 }
2496
2497 static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
2498 {
2499     int res = 0;
2500
2501     while (order--)
2502         res += *v1++ * *v2++;
2503
2504     return res;
2505 }
2506
2507 static int32_t scalarproduct_and_madd_int16_c(int16_t *v1, const int16_t *v2, const int16_t *v3, int order, int mul)
2508 {
2509     int res = 0;
2510     while (order--) {
2511         res   += *v1 * *v2++;
2512         *v1++ += mul * *v3++;
2513     }
2514     return res;
2515 }
2516
2517 static void apply_window_int16_c(int16_t *output, const int16_t *input,
2518                                  const int16_t *window, unsigned int len)
2519 {
2520     int i;
2521     int len2 = len >> 1;
2522
2523     for (i = 0; i < len2; i++) {
2524         int16_t w       = window[i];
2525         output[i]       = (MUL16(input[i],       w) + (1 << 14)) >> 15;
2526         output[len-i-1] = (MUL16(input[len-i-1], w) + (1 << 14)) >> 15;
2527     }
2528 }
2529
2530 static void vector_clip_int32_c(int32_t *dst, const int32_t *src, int32_t min,
2531                                 int32_t max, unsigned int len)
2532 {
2533     do {
2534         *dst++ = av_clip(*src++, min, max);
2535         *dst++ = av_clip(*src++, min, max);
2536         *dst++ = av_clip(*src++, min, max);
2537         *dst++ = av_clip(*src++, min, max);
2538         *dst++ = av_clip(*src++, min, max);
2539         *dst++ = av_clip(*src++, min, max);
2540         *dst++ = av_clip(*src++, min, max);
2541         *dst++ = av_clip(*src++, min, max);
2542         len -= 8;
2543     } while (len > 0);
2544 }
2545
2546 #define W0 2048
2547 #define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
2548 #define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
2549 #define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
2550 #define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
2551 #define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
2552 #define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
2553 #define W7 565  /* 2048*sqrt (2)*cos (7*pi/16) */
2554
2555 static void wmv2_idct_row(short * b)
2556 {
2557     int s1,s2;
2558     int a0,a1,a2,a3,a4,a5,a6,a7;
2559     /*step 1*/
2560     a1 = W1*b[1]+W7*b[7];
2561     a7 = W7*b[1]-W1*b[7];
2562     a5 = W5*b[5]+W3*b[3];
2563     a3 = W3*b[5]-W5*b[3];
2564     a2 = W2*b[2]+W6*b[6];
2565     a6 = W6*b[2]-W2*b[6];
2566     a0 = W0*b[0]+W0*b[4];
2567     a4 = W0*b[0]-W0*b[4];
2568     /*step 2*/
2569     s1 = (181*(a1-a5+a7-a3)+128)>>8;//1,3,5,7,
2570     s2 = (181*(a1-a5-a7+a3)+128)>>8;
2571     /*step 3*/
2572     b[0] = (a0+a2+a1+a5 + (1<<7))>>8;
2573     b[1] = (a4+a6 +s1   + (1<<7))>>8;
2574     b[2] = (a4-a6 +s2   + (1<<7))>>8;
2575     b[3] = (a0-a2+a7+a3 + (1<<7))>>8;
2576     b[4] = (a0-a2-a7-a3 + (1<<7))>>8;
2577     b[5] = (a4-a6 -s2   + (1<<7))>>8;
2578     b[6] = (a4+a6 -s1   + (1<<7))>>8;
2579     b[7] = (a0+a2-a1-a5 + (1<<7))>>8;
2580 }
2581 static void wmv2_idct_col(short * b)
2582 {
2583     int s1,s2;
2584     int a0,a1,a2,a3,a4,a5,a6,a7;
2585     /*step 1, with extended precision*/
2586     a1 = (W1*b[8*1]+W7*b[8*7] + 4)>>3;
2587     a7 = (W7*b[8*1]-W1*b[8*7] + 4)>>3;
2588     a5 = (W5*b[8*5]+W3*b[8*3] + 4)>>3;
2589     a3 = (W3*b[8*5]-W5*b[8*3] + 4)>>3;
2590     a2 = (W2*b[8*2]+W6*b[8*6] + 4)>>3;
2591     a6 = (W6*b[8*2]-W2*b[8*6] + 4)>>3;
2592     a0 = (W0*b[8*0]+W0*b[8*4]    )>>3;
2593     a4 = (W0*b[8*0]-W0*b[8*4]    )>>3;
2594     /*step 2*/
2595     s1 = (181*(a1-a5+a7-a3)+128)>>8;
2596     s2 = (181*(a1-a5-a7+a3)+128)>>8;
2597     /*step 3*/
2598     b[8*0] = (a0+a2+a1+a5 + (1<<13))>>14;
2599     b[8*1] = (a4+a6 +s1   + (1<<13))>>14;
2600     b[8*2] = (a4-a6 +s2   + (1<<13))>>14;
2601     b[8*3] = (a0-a2+a7+a3 + (1<<13))>>14;
2602
2603     b[8*4] = (a0-a2-a7-a3 + (1<<13))>>14;
2604     b[8*5] = (a4-a6 -s2   + (1<<13))>>14;
2605     b[8*6] = (a4+a6 -s1   + (1<<13))>>14;
2606     b[8*7] = (a0+a2-a1-a5 + (1<<13))>>14;
2607 }
2608 void ff_wmv2_idct_c(short * block){
2609     int i;
2610
2611     for(i=0;i<64;i+=8){
2612         wmv2_idct_row(block+i);
2613     }
2614     for(i=0;i<8;i++){
2615         wmv2_idct_col(block+i);
2616     }
2617 }
2618 /* XXX: those functions should be suppressed ASAP when all IDCTs are
2619  converted */
2620 static void ff_wmv2_idct_put_c(uint8_t *dest, int line_size, DCTELEM *block)
2621 {
2622     ff_wmv2_idct_c(block);
2623     ff_put_pixels_clamped_c(block, dest, line_size);
2624 }
2625 static void ff_wmv2_idct_add_c(uint8_t *dest, int line_size, DCTELEM *block)
2626 {
2627     ff_wmv2_idct_c(block);
2628     ff_add_pixels_clamped_c(block, dest, line_size);
2629 }
2630 static void ff_jref_idct_put(uint8_t *dest, int line_size, DCTELEM *block)
2631 {
2632     ff_j_rev_dct (block);
2633     ff_put_pixels_clamped_c(block, dest, line_size);
2634 }
2635 static void ff_jref_idct_add(uint8_t *dest, int line_size, DCTELEM *block)
2636 {
2637     ff_j_rev_dct (block);
2638     ff_add_pixels_clamped_c(block, dest, line_size);
2639 }
2640
2641 static void just_return(void *mem av_unused, int stride av_unused, int h av_unused) { return; }
2642
2643 /* init static data */
2644 av_cold void ff_dsputil_static_init(void)
2645 {
2646     int i;
2647
2648     for(i=0;i<256;i++) ff_cropTbl[i + MAX_NEG_CROP] = i;
2649     for(i=0;i<MAX_NEG_CROP;i++) {
2650         ff_cropTbl[i] = 0;
2651         ff_cropTbl[i + MAX_NEG_CROP + 256] = 255;
2652     }
2653
2654     for(i=0;i<512;i++) {
2655         ff_squareTbl[i] = (i - 256) * (i - 256);
2656     }
2657
2658     for(i=0; i<64; i++) ff_inv_zigzag_direct16[ff_zigzag_direct[i]]= i+1;
2659 }
2660
2661 int ff_check_alignment(void){
2662     static int did_fail=0;
2663     LOCAL_ALIGNED_16(int, aligned, [4]);
2664
2665     if((intptr_t)aligned & 15){
2666         if(!did_fail){
2667 #if HAVE_MMX || HAVE_ALTIVEC
2668             av_log(NULL, AV_LOG_ERROR,
2669                 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
2670                 "and may be very slow or crash. This is not a bug in libavcodec,\n"
2671                 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
2672                 "Do not report crashes to Libav developers.\n");
2673 #endif
2674             did_fail=1;
2675         }
2676         return -1;
2677     }
2678     return 0;
2679 }
2680
2681 av_cold void ff_dsputil_init(DSPContext* c, AVCodecContext *avctx)
2682 {
2683     int i, j;
2684
2685     ff_check_alignment();
2686
2687 #if CONFIG_ENCODERS
2688     if (avctx->bits_per_raw_sample == 10) {
2689         c->fdct    = ff_jpeg_fdct_islow_10;
2690         c->fdct248 = ff_fdct248_islow_10;
2691     } else {
2692         if(avctx->dct_algo==FF_DCT_FASTINT) {
2693             c->fdct    = ff_fdct_ifast;
2694             c->fdct248 = ff_fdct_ifast248;
2695         }
2696         else if(avctx->dct_algo==FF_DCT_FAAN) {
2697             c->fdct    = ff_faandct;
2698             c->fdct248 = ff_faandct248;
2699         }
2700         else {
2701             c->fdct    = ff_jpeg_fdct_islow_8; //slow/accurate/default
2702             c->fdct248 = ff_fdct248_islow_8;
2703         }
2704     }
2705 #endif //CONFIG_ENCODERS
2706
2707     if (avctx->bits_per_raw_sample == 10) {
2708         c->idct_put              = ff_simple_idct_put_10;
2709         c->idct_add              = ff_simple_idct_add_10;
2710         c->idct                  = ff_simple_idct_10;
2711         c->idct_permutation_type = FF_NO_IDCT_PERM;
2712     } else {
2713         if(avctx->idct_algo==FF_IDCT_INT){
2714             c->idct_put= ff_jref_idct_put;
2715             c->idct_add= ff_jref_idct_add;
2716             c->idct    = ff_j_rev_dct;
2717             c->idct_permutation_type= FF_LIBMPEG2_IDCT_PERM;
2718         }else if((CONFIG_VP3_DECODER || CONFIG_VP5_DECODER || CONFIG_VP6_DECODER ) &&
2719                 avctx->idct_algo==FF_IDCT_VP3){
2720             c->idct_put= ff_vp3_idct_put_c;
2721             c->idct_add= ff_vp3_idct_add_c;
2722             c->idct    = ff_vp3_idct_c;
2723             c->idct_permutation_type= FF_NO_IDCT_PERM;
2724         }else if(avctx->idct_algo==FF_IDCT_WMV2){
2725             c->idct_put= ff_wmv2_idct_put_c;
2726             c->idct_add= ff_wmv2_idct_add_c;
2727             c->idct    = ff_wmv2_idct_c;
2728             c->idct_permutation_type= FF_NO_IDCT_PERM;
2729         }else if(avctx->idct_algo==FF_IDCT_FAAN){
2730             c->idct_put= ff_faanidct_put;
2731             c->idct_add= ff_faanidct_add;
2732             c->idct    = ff_faanidct;
2733             c->idct_permutation_type= FF_NO_IDCT_PERM;
2734         }else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) {
2735             c->idct_put= ff_ea_idct_put_c;
2736             c->idct_permutation_type= FF_NO_IDCT_PERM;
2737         }else{ //accurate/default
2738             c->idct_put = ff_simple_idct_put_8;
2739             c->idct_add = ff_simple_idct_add_8;
2740             c->idct     = ff_simple_idct_8;
2741             c->idct_permutation_type= FF_NO_IDCT_PERM;
2742         }
2743     }
2744
2745     c->diff_pixels = diff_pixels_c;
2746     c->put_pixels_clamped = ff_put_pixels_clamped_c;
2747     c->put_signed_pixels_clamped = ff_put_signed_pixels_clamped_c;
2748     c->add_pixels_clamped = ff_add_pixels_clamped_c;
2749     c->sum_abs_dctelem = sum_abs_dctelem_c;
2750     c->gmc1 = gmc1_c;
2751     c->gmc = ff_gmc_c;
2752     c->pix_sum = pix_sum_c;
2753     c->pix_norm1 = pix_norm1_c;
2754
2755     c->fill_block_tab[0] = fill_block16_c;
2756     c->fill_block_tab[1] = fill_block8_c;
2757
2758     /* TODO [0] 16  [1] 8 */
2759     c->pix_abs[0][0] = pix_abs16_c;
2760     c->pix_abs[0][1] = pix_abs16_x2_c;
2761     c->pix_abs[0][2] = pix_abs16_y2_c;
2762     c->pix_abs[0][3] = pix_abs16_xy2_c;
2763     c->pix_abs[1][0] = pix_abs8_c;
2764     c->pix_abs[1][1] = pix_abs8_x2_c;
2765     c->pix_abs[1][2] = pix_abs8_y2_c;
2766     c->pix_abs[1][3] = pix_abs8_xy2_c;
2767
2768     c->put_tpel_pixels_tab[ 0] = put_tpel_pixels_mc00_c;
2769     c->put_tpel_pixels_tab[ 1] = put_tpel_pixels_mc10_c;
2770     c->put_tpel_pixels_tab[ 2] = put_tpel_pixels_mc20_c;
2771     c->put_tpel_pixels_tab[ 4] = put_tpel_pixels_mc01_c;
2772     c->put_tpel_pixels_tab[ 5] = put_tpel_pixels_mc11_c;
2773     c->put_tpel_pixels_tab[ 6] = put_tpel_pixels_mc21_c;
2774     c->put_tpel_pixels_tab[ 8] = put_tpel_pixels_mc02_c;
2775     c->put_tpel_pixels_tab[ 9] = put_tpel_pixels_mc12_c;
2776     c->put_tpel_pixels_tab[10] = put_tpel_pixels_mc22_c;
2777
2778     c->avg_tpel_pixels_tab[ 0] = avg_tpel_pixels_mc00_c;
2779     c->avg_tpel_pixels_tab[ 1] = avg_tpel_pixels_mc10_c;
2780     c->avg_tpel_pixels_tab[ 2] = avg_tpel_pixels_mc20_c;
2781     c->avg_tpel_pixels_tab[ 4] = avg_tpel_pixels_mc01_c;
2782     c->avg_tpel_pixels_tab[ 5] = avg_tpel_pixels_mc11_c;
2783     c->avg_tpel_pixels_tab[ 6] = avg_tpel_pixels_mc21_c;
2784     c->avg_tpel_pixels_tab[ 8] = avg_tpel_pixels_mc02_c;
2785     c->avg_tpel_pixels_tab[ 9] = avg_tpel_pixels_mc12_c;
2786     c->avg_tpel_pixels_tab[10] = avg_tpel_pixels_mc22_c;
2787
2788 #define dspfunc(PFX, IDX, NUM) \
2789     c->PFX ## _pixels_tab[IDX][ 0] = PFX ## NUM ## _mc00_c; \
2790     c->PFX ## _pixels_tab[IDX][ 1] = PFX ## NUM ## _mc10_c; \
2791     c->PFX ## _pixels_tab[IDX][ 2] = PFX ## NUM ## _mc20_c; \
2792     c->PFX ## _pixels_tab[IDX][ 3] = PFX ## NUM ## _mc30_c; \
2793     c->PFX ## _pixels_tab[IDX][ 4] = PFX ## NUM ## _mc01_c; \
2794     c->PFX ## _pixels_tab[IDX][ 5] = PFX ## NUM ## _mc11_c; \
2795     c->PFX ## _pixels_tab[IDX][ 6] = PFX ## NUM ## _mc21_c; \
2796     c->PFX ## _pixels_tab[IDX][ 7] = PFX ## NUM ## _mc31_c; \
2797     c->PFX ## _pixels_tab[IDX][ 8] = PFX ## NUM ## _mc02_c; \
2798     c->PFX ## _pixels_tab[IDX][ 9] = PFX ## NUM ## _mc12_c; \
2799     c->PFX ## _pixels_tab[IDX][10] = PFX ## NUM ## _mc22_c; \
2800     c->PFX ## _pixels_tab[IDX][11] = PFX ## NUM ## _mc32_c; \
2801     c->PFX ## _pixels_tab[IDX][12] = PFX ## NUM ## _mc03_c; \
2802     c->PFX ## _pixels_tab[IDX][13] = PFX ## NUM ## _mc13_c; \
2803     c->PFX ## _pixels_tab[IDX][14] = PFX ## NUM ## _mc23_c; \
2804     c->PFX ## _pixels_tab[IDX][15] = PFX ## NUM ## _mc33_c
2805
2806     dspfunc(put_qpel, 0, 16);
2807     dspfunc(put_no_rnd_qpel, 0, 16);
2808
2809     dspfunc(avg_qpel, 0, 16);
2810     /* dspfunc(avg_no_rnd_qpel, 0, 16); */
2811
2812     dspfunc(put_qpel, 1, 8);
2813     dspfunc(put_no_rnd_qpel, 1, 8);
2814
2815     dspfunc(avg_qpel, 1, 8);
2816     /* dspfunc(avg_no_rnd_qpel, 1, 8); */
2817
2818 #undef dspfunc
2819
2820 #if CONFIG_MLP_DECODER || CONFIG_TRUEHD_DECODER
2821     ff_mlp_init(c, avctx);
2822 #endif
2823 #if CONFIG_WMV2_DECODER || CONFIG_VC1_DECODER
2824     ff_intrax8dsp_init(c,avctx);
2825 #endif
2826
2827     c->put_mspel_pixels_tab[0]= ff_put_pixels8x8_c;
2828     c->put_mspel_pixels_tab[1]= put_mspel8_mc10_c;
2829     c->put_mspel_pixels_tab[2]= put_mspel8_mc20_c;
2830     c->put_mspel_pixels_tab[3]= put_mspel8_mc30_c;
2831     c->put_mspel_pixels_tab[4]= put_mspel8_mc02_c;
2832     c->put_mspel_pixels_tab[5]= put_mspel8_mc12_c;
2833     c->put_mspel_pixels_tab[6]= put_mspel8_mc22_c;
2834     c->put_mspel_pixels_tab[7]= put_mspel8_mc32_c;
2835
2836 #define SET_CMP_FUNC(name) \
2837     c->name[0]= name ## 16_c;\
2838     c->name[1]= name ## 8x8_c;
2839
2840     SET_CMP_FUNC(hadamard8_diff)
2841     c->hadamard8_diff[4]= hadamard8_intra16_c;
2842     c->hadamard8_diff[5]= hadamard8_intra8x8_c;
2843     SET_CMP_FUNC(dct_sad)
2844     SET_CMP_FUNC(dct_max)
2845 #if CONFIG_GPL
2846     SET_CMP_FUNC(dct264_sad)
2847 #endif
2848     c->sad[0]= pix_abs16_c;
2849     c->sad[1]= pix_abs8_c;
2850     c->sse[0]= sse16_c;
2851     c->sse[1]= sse8_c;
2852     c->sse[2]= sse4_c;
2853     SET_CMP_FUNC(quant_psnr)
2854     SET_CMP_FUNC(rd)
2855     SET_CMP_FUNC(bit)
2856     c->vsad[0]= vsad16_c;
2857     c->vsad[4]= vsad_intra16_c;
2858     c->vsad[5]= vsad_intra8_c;
2859     c->vsse[0]= vsse16_c;
2860     c->vsse[4]= vsse_intra16_c;
2861     c->vsse[5]= vsse_intra8_c;
2862     c->nsse[0]= nsse16_c;
2863     c->nsse[1]= nsse8_c;
2864 #if CONFIG_DWT
2865     ff_dsputil_init_dwt(c);
2866 #endif
2867
2868     c->ssd_int8_vs_int16 = ssd_int8_vs_int16_c;
2869
2870     c->add_bytes= add_bytes_c;
2871     c->diff_bytes= diff_bytes_c;
2872     c->add_hfyu_median_prediction= add_hfyu_median_prediction_c;
2873     c->sub_hfyu_median_prediction= sub_hfyu_median_prediction_c;
2874     c->add_hfyu_left_prediction  = add_hfyu_left_prediction_c;
2875     c->add_hfyu_left_prediction_bgr32 = add_hfyu_left_prediction_bgr32_c;
2876     c->bswap_buf= bswap_buf;
2877     c->bswap16_buf = bswap16_buf;
2878
2879     if (CONFIG_H263_DECODER || CONFIG_H263_ENCODER) {
2880         c->h263_h_loop_filter= h263_h_loop_filter_c;
2881         c->h263_v_loop_filter= h263_v_loop_filter_c;
2882     }
2883
2884     if (CONFIG_VP3_DECODER) {
2885         c->vp3_h_loop_filter= ff_vp3_h_loop_filter_c;
2886         c->vp3_v_loop_filter= ff_vp3_v_loop_filter_c;
2887         c->vp3_idct_dc_add= ff_vp3_idct_dc_add_c;
2888     }
2889
2890     c->h261_loop_filter= h261_loop_filter_c;
2891
2892     c->try_8x8basis= try_8x8basis_c;
2893     c->add_8x8basis= add_8x8basis_c;
2894
2895 #if CONFIG_VORBIS_DECODER
2896     c->vorbis_inverse_coupling = ff_vorbis_inverse_coupling;
2897 #endif
2898 #if CONFIG_AC3_DECODER
2899     c->ac3_downmix = ff_ac3_downmix_c;
2900 #endif
2901     c->vector_fmul = vector_fmul_c;
2902     c->vector_fmul_reverse = vector_fmul_reverse_c;
2903     c->vector_fmul_add = vector_fmul_add_c;
2904     c->vector_fmul_window = vector_fmul_window_c;
2905     c->vector_clipf = vector_clipf_c;
2906     c->scalarproduct_int16 = scalarproduct_int16_c;
2907     c->scalarproduct_and_madd_int16 = scalarproduct_and_madd_int16_c;
2908     c->apply_window_int16 = apply_window_int16_c;
2909     c->vector_clip_int32 = vector_clip_int32_c;
2910     c->scalarproduct_float = scalarproduct_float_c;
2911     c->butterflies_float = butterflies_float_c;
2912     c->butterflies_float_interleave = butterflies_float_interleave_c;
2913     c->vector_fmul_scalar = vector_fmul_scalar_c;
2914     c->vector_fmac_scalar = vector_fmac_scalar_c;
2915
2916     c->shrink[0]= av_image_copy_plane;
2917     c->shrink[1]= ff_shrink22;
2918     c->shrink[2]= ff_shrink44;
2919     c->shrink[3]= ff_shrink88;
2920
2921     c->prefetch= just_return;
2922
2923     memset(c->put_2tap_qpel_pixels_tab, 0, sizeof(c->put_2tap_qpel_pixels_tab));
2924     memset(c->avg_2tap_qpel_pixels_tab, 0, sizeof(c->avg_2tap_qpel_pixels_tab));
2925
2926 #undef FUNC
2927 #undef FUNCC
2928 #define FUNC(f, depth) f ## _ ## depth
2929 #define FUNCC(f, depth) f ## _ ## depth ## _c
2930
2931 #define dspfunc1(PFX, IDX, NUM, depth)\
2932     c->PFX ## _pixels_tab[IDX][0] = FUNCC(PFX ## _pixels ## NUM        , depth);\
2933     c->PFX ## _pixels_tab[IDX][1] = FUNCC(PFX ## _pixels ## NUM ## _x2 , depth);\
2934     c->PFX ## _pixels_tab[IDX][2] = FUNCC(PFX ## _pixels ## NUM ## _y2 , depth);\
2935     c->PFX ## _pixels_tab[IDX][3] = FUNCC(PFX ## _pixels ## NUM ## _xy2, depth)
2936
2937 #define dspfunc2(PFX, IDX, NUM, depth)\
2938     c->PFX ## _pixels_tab[IDX][ 0] = FUNCC(PFX ## NUM ## _mc00, depth);\
2939     c->PFX ## _pixels_tab[IDX][ 1] = FUNCC(PFX ## NUM ## _mc10, depth);\
2940     c->PFX ## _pixels_tab[IDX][ 2] = FUNCC(PFX ## NUM ## _mc20, depth);\
2941     c->PFX ## _pixels_tab[IDX][ 3] = FUNCC(PFX ## NUM ## _mc30, depth);\
2942     c->PFX ## _pixels_tab[IDX][ 4] = FUNCC(PFX ## NUM ## _mc01, depth);\
2943     c->PFX ## _pixels_tab[IDX][ 5] = FUNCC(PFX ## NUM ## _mc11, depth);\
2944     c->PFX ## _pixels_tab[IDX][ 6] = FUNCC(PFX ## NUM ## _mc21, depth);\
2945     c->PFX ## _pixels_tab[IDX][ 7] = FUNCC(PFX ## NUM ## _mc31, depth);\
2946     c->PFX ## _pixels_tab[IDX][ 8] = FUNCC(PFX ## NUM ## _mc02, depth);\
2947     c->PFX ## _pixels_tab[IDX][ 9] = FUNCC(PFX ## NUM ## _mc12, depth);\
2948     c->PFX ## _pixels_tab[IDX][10] = FUNCC(PFX ## NUM ## _mc22, depth);\
2949     c->PFX ## _pixels_tab[IDX][11] = FUNCC(PFX ## NUM ## _mc32, depth);\
2950     c->PFX ## _pixels_tab[IDX][12] = FUNCC(PFX ## NUM ## _mc03, depth);\
2951     c->PFX ## _pixels_tab[IDX][13] = FUNCC(PFX ## NUM ## _mc13, depth);\
2952     c->PFX ## _pixels_tab[IDX][14] = FUNCC(PFX ## NUM ## _mc23, depth);\
2953     c->PFX ## _pixels_tab[IDX][15] = FUNCC(PFX ## NUM ## _mc33, depth)
2954
2955
2956 #define BIT_DEPTH_FUNCS(depth, dct)\
2957     c->get_pixels                    = FUNCC(get_pixels   ## dct   , depth);\
2958     c->draw_edges                    = FUNCC(draw_edges            , depth);\
2959     c->emulated_edge_mc              = FUNC (ff_emulated_edge_mc   , depth);\
2960     c->clear_block                   = FUNCC(clear_block  ## dct   , depth);\
2961     c->clear_blocks                  = FUNCC(clear_blocks ## dct   , depth);\
2962     c->add_pixels8                   = FUNCC(add_pixels8  ## dct   , depth);\
2963     c->add_pixels4                   = FUNCC(add_pixels4  ## dct   , depth);\
2964     c->put_no_rnd_pixels_l2[0]       = FUNCC(put_no_rnd_pixels16_l2, depth);\
2965     c->put_no_rnd_pixels_l2[1]       = FUNCC(put_no_rnd_pixels8_l2 , depth);\
2966 \
2967     c->put_h264_chroma_pixels_tab[0] = FUNCC(put_h264_chroma_mc8   , depth);\
2968     c->put_h264_chroma_pixels_tab[1] = FUNCC(put_h264_chroma_mc4   , depth);\
2969     c->put_h264_chroma_pixels_tab[2] = FUNCC(put_h264_chroma_mc2   , depth);\
2970     c->avg_h264_chroma_pixels_tab[0] = FUNCC(avg_h264_chroma_mc8   , depth);\
2971     c->avg_h264_chroma_pixels_tab[1] = FUNCC(avg_h264_chroma_mc4   , depth);\
2972     c->avg_h264_chroma_pixels_tab[2] = FUNCC(avg_h264_chroma_mc2   , depth);\
2973 \
2974     dspfunc1(put       , 0, 16, depth);\
2975     dspfunc1(put       , 1,  8, depth);\
2976     dspfunc1(put       , 2,  4, depth);\
2977     dspfunc1(put       , 3,  2, depth);\
2978     dspfunc1(put_no_rnd, 0, 16, depth);\
2979     dspfunc1(put_no_rnd, 1,  8, depth);\
2980     dspfunc1(avg       , 0, 16, depth);\
2981     dspfunc1(avg       , 1,  8, depth);\
2982     dspfunc1(avg       , 2,  4, depth);\
2983     dspfunc1(avg       , 3,  2, depth);\
2984     dspfunc1(avg_no_rnd, 0, 16, depth);\
2985     dspfunc1(avg_no_rnd, 1,  8, depth);\
2986 \
2987     dspfunc2(put_h264_qpel, 0, 16, depth);\
2988     dspfunc2(put_h264_qpel, 1,  8, depth);\
2989     dspfunc2(put_h264_qpel, 2,  4, depth);\
2990     dspfunc2(put_h264_qpel, 3,  2, depth);\
2991     dspfunc2(avg_h264_qpel, 0, 16, depth);\
2992     dspfunc2(avg_h264_qpel, 1,  8, depth);\
2993     dspfunc2(avg_h264_qpel, 2,  4, depth);
2994
2995     switch (avctx->bits_per_raw_sample) {
2996     case 9:
2997         if (c->dct_bits == 32) {
2998             BIT_DEPTH_FUNCS(9, _32);
2999         } else {
3000             BIT_DEPTH_FUNCS(9, _16);
3001         }
3002         break;
3003     case 10:
3004         if (c->dct_bits == 32) {
3005             BIT_DEPTH_FUNCS(10, _32);
3006         } else {
3007             BIT_DEPTH_FUNCS(10, _16);
3008         }
3009         break;
3010     default:
3011         BIT_DEPTH_FUNCS(8, _16);
3012         break;
3013     }
3014
3015
3016     if (HAVE_MMX)        ff_dsputil_init_mmx   (c, avctx);
3017     if (ARCH_ARM)        ff_dsputil_init_arm   (c, avctx);
3018     if (HAVE_VIS)        ff_dsputil_init_vis   (c, avctx);
3019     if (ARCH_ALPHA)      ff_dsputil_init_alpha (c, avctx);
3020     if (ARCH_PPC)        ff_dsputil_init_ppc   (c, avctx);
3021     if (HAVE_MMI)        ff_dsputil_init_mmi   (c, avctx);
3022     if (ARCH_SH4)        ff_dsputil_init_sh4   (c, avctx);
3023     if (ARCH_BFIN)       ff_dsputil_init_bfin  (c, avctx);
3024
3025     for (i = 0; i < 4; i++) {
3026         for (j = 0; j < 16; j++) {
3027             if(!c->put_2tap_qpel_pixels_tab[i][j])
3028                 c->put_2tap_qpel_pixels_tab[i][j] =
3029                     c->put_h264_qpel_pixels_tab[i][j];
3030             if(!c->avg_2tap_qpel_pixels_tab[i][j])
3031                 c->avg_2tap_qpel_pixels_tab[i][j] =
3032                     c->avg_h264_qpel_pixels_tab[i][j];
3033         }
3034     }
3035
3036     ff_init_scantable_permutation(c->idct_permutation,
3037                                   c->idct_permutation_type);
3038 }