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

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