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