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

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