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

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