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  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file
  25  * DSP utils
  26  */
  27
  28 #include "libavutil/attributes.h"
  29 #include "libavutil/imgutils.h"
  30 #include "libavutil/internal.h"
  31 #include "avcodec.h"
  32 #include "copy_block.h"
  33 #include "dct.h"
  34 #include "dsputil.h"
  35 #include "simple_idct.h"
  36 #include "faandct.h"
  37 #include "imgconvert.h"
  38 #include "mathops.h"
  39 #include "mpegvideo.h"
  40 #include "config.h"
  41
  42 uint32_t ff_square_tab[512] = { 0, };
  43
  44 #define BIT_DEPTH 16
  45 #include "dsputilenc_template.c"
  46 #undef BIT_DEPTH
  47
  48 #define BIT_DEPTH 8
  49 #include "dsputilenc_template.c"
  50
  51 static int pix_sum_c(uint8_t *pix, int line_size)
  52 {
  53     int s = 0, i, j;
  54
  55     for (i = 0; i < 16; i++) {
  56         for (j = 0; j < 16; j += 8) {
  57             s   += pix[0];
  58             s   += pix[1];
  59             s   += pix[2];
  60             s   += pix[3];
  61             s   += pix[4];
  62             s   += pix[5];
  63             s   += pix[6];
  64             s   += pix[7];
  65             pix += 8;
  66         }
  67         pix += line_size - 16;
  68     }
  69     return s;
  70 }
  71
  72 static int pix_norm1_c(uint8_t *pix, int line_size)
  73 {
  74     int s = 0, i, j;
  75     uint32_t *sq = ff_square_tab + 256;
  76
  77     for (i = 0; i < 16; i++) {
  78         for (j = 0; j < 16; j += 8) {
  79 #if 0
  80             s += sq[pix[0]];
  81             s += sq[pix[1]];
  82             s += sq[pix[2]];
  83             s += sq[pix[3]];
  84             s += sq[pix[4]];
  85             s += sq[pix[5]];
  86             s += sq[pix[6]];
  87             s += sq[pix[7]];
  88 #else
  89 #if HAVE_FAST_64BIT
  90             register uint64_t x = *(uint64_t *) pix;
  91             s += sq[x         & 0xff];
  92             s += sq[(x >>  8) & 0xff];
  93             s += sq[(x >> 16) & 0xff];
  94             s += sq[(x >> 24) & 0xff];
  95             s += sq[(x >> 32) & 0xff];
  96             s += sq[(x >> 40) & 0xff];
  97             s += sq[(x >> 48) & 0xff];
  98             s += sq[(x >> 56) & 0xff];
  99 #else
 100             register uint32_t x = *(uint32_t *) pix;
 101             s += sq[x         & 0xff];
 102             s += sq[(x >>  8) & 0xff];
 103             s += sq[(x >> 16) & 0xff];
 104             s += sq[(x >> 24) & 0xff];
 105             x  = *(uint32_t *) (pix + 4);
 106             s += sq[x         & 0xff];
 107             s += sq[(x >>  8) & 0xff];
 108             s += sq[(x >> 16) & 0xff];
 109             s += sq[(x >> 24) & 0xff];
 110 #endif
 111 #endif
 112             pix += 8;
 113         }
 114         pix += line_size - 16;
 115     }
 116     return s;
 117 }
 118
 119 static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 120                   int line_size, int h)
 121 {
 122     int s = 0, i;
 123     uint32_t *sq = ff_square_tab + 256;
 124
 125     for (i = 0; i < h; i++) {
 126         s    += sq[pix1[0] - pix2[0]];
 127         s    += sq[pix1[1] - pix2[1]];
 128         s    += sq[pix1[2] - pix2[2]];
 129         s    += sq[pix1[3] - pix2[3]];
 130         pix1 += line_size;
 131         pix2 += line_size;
 132     }
 133     return s;
 134 }
 135
 136 static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 137                   int line_size, int h)
 138 {
 139     int s = 0, i;
 140     uint32_t *sq = ff_square_tab + 256;
 141
 142     for (i = 0; i < h; i++) {
 143         s    += sq[pix1[0] - pix2[0]];
 144         s    += sq[pix1[1] - pix2[1]];
 145         s    += sq[pix1[2] - pix2[2]];
 146         s    += sq[pix1[3] - pix2[3]];
 147         s    += sq[pix1[4] - pix2[4]];
 148         s    += sq[pix1[5] - pix2[5]];
 149         s    += sq[pix1[6] - pix2[6]];
 150         s    += sq[pix1[7] - pix2[7]];
 151         pix1 += line_size;
 152         pix2 += line_size;
 153     }
 154     return s;
 155 }
 156
 157 static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 158                    int line_size, int h)
 159 {
 160     int s = 0, i;
 161     uint32_t *sq = ff_square_tab + 256;
 162
 163     for (i = 0; i < h; i++) {
 164         s += sq[pix1[0]  - pix2[0]];
 165         s += sq[pix1[1]  - pix2[1]];
 166         s += sq[pix1[2]  - pix2[2]];
 167         s += sq[pix1[3]  - pix2[3]];
 168         s += sq[pix1[4]  - pix2[4]];
 169         s += sq[pix1[5]  - pix2[5]];
 170         s += sq[pix1[6]  - pix2[6]];
 171         s += sq[pix1[7]  - pix2[7]];
 172         s += sq[pix1[8]  - pix2[8]];
 173         s += sq[pix1[9]  - pix2[9]];
 174         s += sq[pix1[10] - pix2[10]];
 175         s += sq[pix1[11] - pix2[11]];
 176         s += sq[pix1[12] - pix2[12]];
 177         s += sq[pix1[13] - pix2[13]];
 178         s += sq[pix1[14] - pix2[14]];
 179         s += sq[pix1[15] - pix2[15]];
 180
 181         pix1 += line_size;
 182         pix2 += line_size;
 183     }
 184     return s;
 185 }
 186
 187 static void diff_pixels_c(int16_t *av_restrict block, const uint8_t *s1,
 188                           const uint8_t *s2, int stride)
 189 {
 190     int i;
 191
 192     /* read the pixels */
 193     for (i = 0; i < 8; i++) {
 194         block[0] = s1[0] - s2[0];
 195         block[1] = s1[1] - s2[1];
 196         block[2] = s1[2] - s2[2];
 197         block[3] = s1[3] - s2[3];
 198         block[4] = s1[4] - s2[4];
 199         block[5] = s1[5] - s2[5];
 200         block[6] = s1[6] - s2[6];
 201         block[7] = s1[7] - s2[7];
 202         s1      += stride;
 203         s2      += stride;
 204         block   += 8;
 205     }
 206 }
 207
 208 static int sum_abs_dctelem_c(int16_t *block)
 209 {
 210     int sum = 0, i;
 211
 212     for (i = 0; i < 64; i++)
 213         sum += FFABS(block[i]);
 214     return sum;
 215 }
 216
 217 #define avg2(a, b) ((a + b + 1) >> 1)
 218 #define avg4(a, b, c, d) ((a + b + c + d + 2) >> 2)
 219
 220 static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 221                               int line_size, int h)
 222 {
 223     int s = 0, i;
 224
 225     for (i = 0; i < h; i++) {
 226         s    += abs(pix1[0]  - pix2[0]);
 227         s    += abs(pix1[1]  - pix2[1]);
 228         s    += abs(pix1[2]  - pix2[2]);
 229         s    += abs(pix1[3]  - pix2[3]);
 230         s    += abs(pix1[4]  - pix2[4]);
 231         s    += abs(pix1[5]  - pix2[5]);
 232         s    += abs(pix1[6]  - pix2[6]);
 233         s    += abs(pix1[7]  - pix2[7]);
 234         s    += abs(pix1[8]  - pix2[8]);
 235         s    += abs(pix1[9]  - pix2[9]);
 236         s    += abs(pix1[10] - pix2[10]);
 237         s    += abs(pix1[11] - pix2[11]);
 238         s    += abs(pix1[12] - pix2[12]);
 239         s    += abs(pix1[13] - pix2[13]);
 240         s    += abs(pix1[14] - pix2[14]);
 241         s    += abs(pix1[15] - pix2[15]);
 242         pix1 += line_size;
 243         pix2 += line_size;
 244     }
 245     return s;
 246 }
 247
 248 static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 249                           int line_size, int h)
 250 {
 251     int s = 0, i;
 252
 253     for (i = 0; i < h; i++) {
 254         s    += abs(pix1[0]  - avg2(pix2[0],  pix2[1]));
 255         s    += abs(pix1[1]  - avg2(pix2[1],  pix2[2]));
 256         s    += abs(pix1[2]  - avg2(pix2[2],  pix2[3]));
 257         s    += abs(pix1[3]  - avg2(pix2[3],  pix2[4]));
 258         s    += abs(pix1[4]  - avg2(pix2[4],  pix2[5]));
 259         s    += abs(pix1[5]  - avg2(pix2[5],  pix2[6]));
 260         s    += abs(pix1[6]  - avg2(pix2[6],  pix2[7]));
 261         s    += abs(pix1[7]  - avg2(pix2[7],  pix2[8]));
 262         s    += abs(pix1[8]  - avg2(pix2[8],  pix2[9]));
 263         s    += abs(pix1[9]  - avg2(pix2[9],  pix2[10]));
 264         s    += abs(pix1[10] - avg2(pix2[10], pix2[11]));
 265         s    += abs(pix1[11] - avg2(pix2[11], pix2[12]));
 266         s    += abs(pix1[12] - avg2(pix2[12], pix2[13]));
 267         s    += abs(pix1[13] - avg2(pix2[13], pix2[14]));
 268         s    += abs(pix1[14] - avg2(pix2[14], pix2[15]));
 269         s    += abs(pix1[15] - avg2(pix2[15], pix2[16]));
 270         pix1 += line_size;
 271         pix2 += line_size;
 272     }
 273     return s;
 274 }
 275
 276 static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 277                           int line_size, int h)
 278 {
 279     int s = 0, i;
 280     uint8_t *pix3 = pix2 + line_size;
 281
 282     for (i = 0; i < h; i++) {
 283         s    += abs(pix1[0]  - avg2(pix2[0],  pix3[0]));
 284         s    += abs(pix1[1]  - avg2(pix2[1],  pix3[1]));
 285         s    += abs(pix1[2]  - avg2(pix2[2],  pix3[2]));
 286         s    += abs(pix1[3]  - avg2(pix2[3],  pix3[3]));
 287         s    += abs(pix1[4]  - avg2(pix2[4],  pix3[4]));
 288         s    += abs(pix1[5]  - avg2(pix2[5],  pix3[5]));
 289         s    += abs(pix1[6]  - avg2(pix2[6],  pix3[6]));
 290         s    += abs(pix1[7]  - avg2(pix2[7],  pix3[7]));
 291         s    += abs(pix1[8]  - avg2(pix2[8],  pix3[8]));
 292         s    += abs(pix1[9]  - avg2(pix2[9],  pix3[9]));
 293         s    += abs(pix1[10] - avg2(pix2[10], pix3[10]));
 294         s    += abs(pix1[11] - avg2(pix2[11], pix3[11]));
 295         s    += abs(pix1[12] - avg2(pix2[12], pix3[12]));
 296         s    += abs(pix1[13] - avg2(pix2[13], pix3[13]));
 297         s    += abs(pix1[14] - avg2(pix2[14], pix3[14]));
 298         s    += abs(pix1[15] - avg2(pix2[15], pix3[15]));
 299         pix1 += line_size;
 300         pix2 += line_size;
 301         pix3 += line_size;
 302     }
 303     return s;
 304 }
 305
 306 static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 307                            int line_size, int h)
 308 {
 309     int s = 0, i;
 310     uint8_t *pix3 = pix2 + line_size;
 311
 312     for (i = 0; i < h; i++) {
 313         s    += abs(pix1[0]  - avg4(pix2[0],  pix2[1],  pix3[0],  pix3[1]));
 314         s    += abs(pix1[1]  - avg4(pix2[1],  pix2[2],  pix3[1],  pix3[2]));
 315         s    += abs(pix1[2]  - avg4(pix2[2],  pix2[3],  pix3[2],  pix3[3]));
 316         s    += abs(pix1[3]  - avg4(pix2[3],  pix2[4],  pix3[3],  pix3[4]));
 317         s    += abs(pix1[4]  - avg4(pix2[4],  pix2[5],  pix3[4],  pix3[5]));
 318         s    += abs(pix1[5]  - avg4(pix2[5],  pix2[6],  pix3[5],  pix3[6]));
 319         s    += abs(pix1[6]  - avg4(pix2[6],  pix2[7],  pix3[6],  pix3[7]));
 320         s    += abs(pix1[7]  - avg4(pix2[7],  pix2[8],  pix3[7],  pix3[8]));
 321         s    += abs(pix1[8]  - avg4(pix2[8],  pix2[9],  pix3[8],  pix3[9]));
 322         s    += abs(pix1[9]  - avg4(pix2[9],  pix2[10], pix3[9],  pix3[10]));
 323         s    += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
 324         s    += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
 325         s    += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
 326         s    += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
 327         s    += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
 328         s    += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
 329         pix1 += line_size;
 330         pix2 += line_size;
 331         pix3 += line_size;
 332     }
 333     return s;
 334 }
 335
 336 static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 337                              int line_size, int h)
 338 {
 339     int s = 0, i;
 340
 341     for (i = 0; i < h; i++) {
 342         s    += abs(pix1[0] - pix2[0]);
 343         s    += abs(pix1[1] - pix2[1]);
 344         s    += abs(pix1[2] - pix2[2]);
 345         s    += abs(pix1[3] - pix2[3]);
 346         s    += abs(pix1[4] - pix2[4]);
 347         s    += abs(pix1[5] - pix2[5]);
 348         s    += abs(pix1[6] - pix2[6]);
 349         s    += abs(pix1[7] - pix2[7]);
 350         pix1 += line_size;
 351         pix2 += line_size;
 352     }
 353     return s;
 354 }
 355
 356 static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 357                          int line_size, int h)
 358 {
 359     int s = 0, i;
 360
 361     for (i = 0; i < h; i++) {
 362         s    += abs(pix1[0] - avg2(pix2[0], pix2[1]));
 363         s    += abs(pix1[1] - avg2(pix2[1], pix2[2]));
 364         s    += abs(pix1[2] - avg2(pix2[2], pix2[3]));
 365         s    += abs(pix1[3] - avg2(pix2[3], pix2[4]));
 366         s    += abs(pix1[4] - avg2(pix2[4], pix2[5]));
 367         s    += abs(pix1[5] - avg2(pix2[5], pix2[6]));
 368         s    += abs(pix1[6] - avg2(pix2[6], pix2[7]));
 369         s    += abs(pix1[7] - avg2(pix2[7], pix2[8]));
 370         pix1 += line_size;
 371         pix2 += line_size;
 372     }
 373     return s;
 374 }
 375
 376 static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 377                          int line_size, int h)
 378 {
 379     int s = 0, i;
 380     uint8_t *pix3 = pix2 + line_size;
 381
 382     for (i = 0; i < h; i++) {
 383         s    += abs(pix1[0] - avg2(pix2[0], pix3[0]));
 384         s    += abs(pix1[1] - avg2(pix2[1], pix3[1]));
 385         s    += abs(pix1[2] - avg2(pix2[2], pix3[2]));
 386         s    += abs(pix1[3] - avg2(pix2[3], pix3[3]));
 387         s    += abs(pix1[4] - avg2(pix2[4], pix3[4]));
 388         s    += abs(pix1[5] - avg2(pix2[5], pix3[5]));
 389         s    += abs(pix1[6] - avg2(pix2[6], pix3[6]));
 390         s    += abs(pix1[7] - avg2(pix2[7], pix3[7]));
 391         pix1 += line_size;
 392         pix2 += line_size;
 393         pix3 += line_size;
 394     }
 395     return s;
 396 }
 397
 398 static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 399                           int line_size, int h)
 400 {
 401     int s = 0, i;
 402     uint8_t *pix3 = pix2 + line_size;
 403
 404     for (i = 0; i < h; i++) {
 405         s    += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
 406         s    += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
 407         s    += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
 408         s    += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
 409         s    += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
 410         s    += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
 411         s    += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
 412         s    += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
 413         pix1 += line_size;
 414         pix2 += line_size;
 415         pix3 += line_size;
 416     }
 417     return s;
 418 }
 419
 420 static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
 421 {
 422     int score1 = 0, score2 = 0, x, y;
 423
 424     for (y = 0; y < h; y++) {
 425         for (x = 0; x < 16; x++)
 426             score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]);
 427         if (y + 1 < h) {
 428             for (x = 0; x < 15; x++)
 429                 score2 += FFABS(s1[x]     - s1[x + stride] -
 430                                 s1[x + 1] + s1[x + stride + 1]) -
 431                           FFABS(s2[x]     - s2[x + stride] -
 432                                 s2[x + 1] + s2[x + stride + 1]);
 433         }
 434         s1 += stride;
 435         s2 += stride;
 436     }
 437
 438     if (c)
 439         return score1 + FFABS(score2) * c->avctx->nsse_weight;
 440     else
 441         return score1 + FFABS(score2) * 8;
 442 }
 443
 444 static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
 445 {
 446     int score1 = 0, score2 = 0, x, y;
 447
 448     for (y = 0; y < h; y++) {
 449         for (x = 0; x < 8; x++)
 450             score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]);
 451         if (y + 1 < h) {
 452             for (x = 0; x < 7; x++)
 453                 score2 += FFABS(s1[x]     - s1[x + stride] -
 454                                 s1[x + 1] + s1[x + stride + 1]) -
 455                           FFABS(s2[x]     - s2[x + stride] -
 456                                 s2[x + 1] + s2[x + stride + 1]);
 457         }
 458         s1 += stride;
 459         s2 += stride;
 460     }
 461
 462     if (c)
 463         return score1 + FFABS(score2) * c->avctx->nsse_weight;
 464     else
 465         return score1 + FFABS(score2) * 8;
 466 }
 467
 468 static int try_8x8basis_c(int16_t rem[64], int16_t weight[64],
 469                           int16_t basis[64], int scale)
 470 {
 471     int i;
 472     unsigned int sum = 0;
 473
 474     for (i = 0; i < 8 * 8; i++) {
 475         int b = rem[i] + ((basis[i] * scale +
 476                            (1 << (BASIS_SHIFT - RECON_SHIFT - 1))) >>
 477                           (BASIS_SHIFT - RECON_SHIFT));
 478         int w = weight[i];
 479         b >>= RECON_SHIFT;
 480         av_assert2(-512 < b && b < 512);
 481
 482         sum += (w * b) * (w * b) >> 4;
 483     }
 484     return sum >> 2;
 485 }
 486
 487 static void add_8x8basis_c(int16_t rem[64], int16_t basis[64], int scale)
 488 {
 489     int i;
 490
 491     for (i = 0; i < 8 * 8; i++)
 492         rem[i] += (basis[i] * scale +
 493                    (1 << (BASIS_SHIFT - RECON_SHIFT - 1))) >>
 494                   (BASIS_SHIFT - RECON_SHIFT);
 495 }
 496
 497 static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
 498                     int stride, int h)
 499 {
 500     return 0;
 501 }
 502
 503 void ff_set_cmp(DSPContext *c, me_cmp_func *cmp, int type)
 504 {
 505     int i;
 506
 507     memset(cmp, 0, sizeof(void *) * 6);
 508
 509     for (i = 0; i < 6; i++) {
 510         switch (type & 0xFF) {
 511         case FF_CMP_SAD:
 512             cmp[i] = c->sad[i];
 513             break;
 514         case FF_CMP_SATD:
 515             cmp[i] = c->hadamard8_diff[i];
 516             break;
 517         case FF_CMP_SSE:
 518             cmp[i] = c->sse[i];
 519             break;
 520         case FF_CMP_DCT:
 521             cmp[i] = c->dct_sad[i];
 522             break;
 523         case FF_CMP_DCT264:
 524             cmp[i] = c->dct264_sad[i];
 525             break;
 526         case FF_CMP_DCTMAX:
 527             cmp[i] = c->dct_max[i];
 528             break;
 529         case FF_CMP_PSNR:
 530             cmp[i] = c->quant_psnr[i];
 531             break;
 532         case FF_CMP_BIT:
 533             cmp[i] = c->bit[i];
 534             break;
 535         case FF_CMP_RD:
 536             cmp[i] = c->rd[i];
 537             break;
 538         case FF_CMP_VSAD:
 539             cmp[i] = c->vsad[i];
 540             break;
 541         case FF_CMP_VSSE:
 542             cmp[i] = c->vsse[i];
 543             break;
 544         case FF_CMP_ZERO:
 545             cmp[i] = zero_cmp;
 546             break;
 547         case FF_CMP_NSSE:
 548             cmp[i] = c->nsse[i];
 549             break;
 550 #if CONFIG_DWT
 551         case FF_CMP_W53:
 552             cmp[i]= c->w53[i];
 553             break;
 554         case FF_CMP_W97:
 555             cmp[i]= c->w97[i];
 556             break;
 557 #endif
 558         default:
 559             av_log(NULL, AV_LOG_ERROR,
 560                    "internal error in cmp function selection\n");
 561         }
 562     }
 563 }
 564
 565 #define BUTTERFLY2(o1, o2, i1, i2)              \
 566     o1 = (i1) + (i2);                           \
 567     o2 = (i1) - (i2);
 568
 569 #define BUTTERFLY1(x, y)                        \
 570     {                                           \
 571         int a, b;                               \
 572         a = x;                                  \
 573         b = y;                                  \
 574         x = a + b;                              \
 575         y = a - b;                              \
 576     }
 577
 578 #define BUTTERFLYA(x, y) (FFABS((x) + (y)) + FFABS((x) - (y)))
 579
 580 static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst,
 581                                uint8_t *src, int stride, int h)
 582 {
 583     int i, temp[64], sum = 0;
 584
 585     av_assert2(h == 8);
 586
 587     for (i = 0; i < 8; i++) {
 588         // FIXME: try pointer walks
 589         BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
 590                    src[stride * i + 0] - dst[stride * i + 0],
 591                    src[stride * i + 1] - dst[stride * i + 1]);
 592         BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
 593                    src[stride * i + 2] - dst[stride * i + 2],
 594                    src[stride * i + 3] - dst[stride * i + 3]);
 595         BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
 596                    src[stride * i + 4] - dst[stride * i + 4],
 597                    src[stride * i + 5] - dst[stride * i + 5]);
 598         BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
 599                    src[stride * i + 6] - dst[stride * i + 6],
 600                    src[stride * i + 7] - dst[stride * i + 7]);
 601
 602         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
 603         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
 604         BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
 605         BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
 606
 607         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
 608         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
 609         BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
 610         BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
 611     }
 612
 613     for (i = 0; i < 8; i++) {
 614         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
 615         BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
 616         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
 617         BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
 618
 619         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
 620         BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
 621         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
 622         BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
 623
 624         sum += BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i]) +
 625                BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i]) +
 626                BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i]) +
 627                BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
 628     }
 629     return sum;
 630 }
 631
 632 static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src,
 633                                 uint8_t *dummy, int stride, int h)
 634 {
 635     int i, temp[64], sum = 0;
 636
 637     av_assert2(h == 8);
 638
 639     for (i = 0; i < 8; i++) {
 640         // FIXME: try pointer walks
 641         BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
 642                    src[stride * i + 0], src[stride * i + 1]);
 643         BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
 644                    src[stride * i + 2], src[stride * i + 3]);
 645         BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
 646                    src[stride * i + 4], src[stride * i + 5]);
 647         BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
 648                    src[stride * i + 6], src[stride * i + 7]);
 649
 650         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
 651         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
 652         BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
 653         BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
 654
 655         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
 656         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
 657         BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
 658         BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
 659     }
 660
 661     for (i = 0; i < 8; i++) {
 662         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
 663         BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
 664         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
 665         BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
 666
 667         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
 668         BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
 669         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
 670         BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
 671
 672         sum +=
 673             BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i])
 674             + BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i])
 675             + BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i])
 676             + BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
 677     }
 678
 679     sum -= FFABS(temp[8 * 0] + temp[8 * 4]); // -mean
 680
 681     return sum;
 682 }
 683
 684 static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 685                         uint8_t *src2, int stride, int h)
 686 {
 687     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 688
 689     av_assert2(h == 8);
 690
 691     s->dsp.diff_pixels(temp, src1, src2, stride);
 692     s->dsp.fdct(temp);
 693     return s->dsp.sum_abs_dctelem(temp);
 694 }
 695
 696 #if CONFIG_GPL
 697 #define DCT8_1D                                         \
 698     {                                                   \
 699         const int s07 = SRC(0) + SRC(7);                \
 700         const int s16 = SRC(1) + SRC(6);                \
 701         const int s25 = SRC(2) + SRC(5);                \
 702         const int s34 = SRC(3) + SRC(4);                \
 703         const int a0  = s07 + s34;                      \
 704         const int a1  = s16 + s25;                      \
 705         const int a2  = s07 - s34;                      \
 706         const int a3  = s16 - s25;                      \
 707         const int d07 = SRC(0) - SRC(7);                \
 708         const int d16 = SRC(1) - SRC(6);                \
 709         const int d25 = SRC(2) - SRC(5);                \
 710         const int d34 = SRC(3) - SRC(4);                \
 711         const int a4  = d16 + d25 + (d07 + (d07 >> 1)); \
 712         const int a5  = d07 - d34 - (d25 + (d25 >> 1)); \
 713         const int a6  = d07 + d34 - (d16 + (d16 >> 1)); \
 714         const int a7  = d16 - d25 + (d34 + (d34 >> 1)); \
 715         DST(0, a0 + a1);                                \
 716         DST(1, a4 + (a7 >> 2));                         \
 717         DST(2, a2 + (a3 >> 1));                         \
 718         DST(3, a5 + (a6 >> 2));                         \
 719         DST(4, a0 - a1);                                \
 720         DST(5, a6 - (a5 >> 2));                         \
 721         DST(6, (a2 >> 1) - a3);                         \
 722         DST(7, (a4 >> 2) - a7);                         \
 723     }
 724
 725 static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 726                            uint8_t *src2, int stride, int h)
 727 {
 728     int16_t dct[8][8];
 729     int i, sum = 0;
 730
 731     s->dsp.diff_pixels(dct[0], src1, src2, stride);
 732
 733 #define SRC(x) dct[i][x]
 734 #define DST(x, v) dct[i][x] = v
 735     for (i = 0; i < 8; i++)
 736         DCT8_1D
 737 #undef SRC
 738 #undef DST
 739
 740 #define SRC(x) dct[x][i]
 741 #define DST(x, v) sum += FFABS(v)
 742         for (i = 0; i < 8; i++)
 743             DCT8_1D
 744 #undef SRC
 745 #undef DST
 746             return sum;
 747 }
 748 #endif
 749
 750 static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
 751                         uint8_t *src2, int stride, int h)
 752 {
 753     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 754     int sum = 0, i;
 755
 756     av_assert2(h == 8);
 757
 758     s->dsp.diff_pixels(temp, src1, src2, stride);
 759     s->dsp.fdct(temp);
 760
 761     for (i = 0; i < 64; i++)
 762         sum = FFMAX(sum, FFABS(temp[i]));
 763
 764     return sum;
 765 }
 766
 767 static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1,
 768                            uint8_t *src2, int stride, int h)
 769 {
 770     LOCAL_ALIGNED_16(int16_t, temp, [64 * 2]);
 771     int16_t *const bak = temp + 64;
 772     int sum = 0, i;
 773
 774     av_assert2(h == 8);
 775     s->mb_intra = 0;
 776
 777     s->dsp.diff_pixels(temp, src1, src2, stride);
 778
 779     memcpy(bak, temp, 64 * sizeof(int16_t));
 780
 781     s->block_last_index[0 /* FIXME */] =
 782         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 783     s->dct_unquantize_inter(s, temp, 0, s->qscale);
 784     ff_simple_idct_8(temp); // FIXME
 785
 786     for (i = 0; i < 64; i++)
 787         sum += (temp[i] - bak[i]) * (temp[i] - bak[i]);
 788
 789     return sum;
 790 }
 791
 792 static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 793                    int stride, int h)
 794 {
 795     const uint8_t *scantable = s->intra_scantable.permutated;
 796     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 797     LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
 798     LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
 799     int i, last, run, bits, level, distortion, start_i;
 800     const int esc_length = s->ac_esc_length;
 801     uint8_t *length, *last_length;
 802
 803     av_assert2(h == 8);
 804
 805     copy_block8(lsrc1, src1, 8, stride, 8);
 806     copy_block8(lsrc2, src2, 8, stride, 8);
 807
 808     s->dsp.diff_pixels(temp, lsrc1, lsrc2, 8);
 809
 810     s->block_last_index[0 /* FIXME */] =
 811     last                               =
 812         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 813
 814     bits = 0;
 815
 816     if (s->mb_intra) {
 817         start_i     = 1;
 818         length      = s->intra_ac_vlc_length;
 819         last_length = s->intra_ac_vlc_last_length;
 820         bits       += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
 821     } else {
 822         start_i     = 0;
 823         length      = s->inter_ac_vlc_length;
 824         last_length = s->inter_ac_vlc_last_length;
 825     }
 826
 827     if (last >= start_i) {
 828         run = 0;
 829         for (i = start_i; i < last; i++) {
 830             int j = scantable[i];
 831             level = temp[j];
 832
 833             if (level) {
 834                 level += 64;
 835                 if ((level & (~127)) == 0)
 836                     bits += length[UNI_AC_ENC_INDEX(run, level)];
 837                 else
 838                     bits += esc_length;
 839                 run = 0;
 840             } else
 841                 run++;
 842         }
 843         i = scantable[last];
 844
 845         level = temp[i] + 64;
 846
 847         av_assert2(level - 64);
 848
 849         if ((level & (~127)) == 0) {
 850             bits += last_length[UNI_AC_ENC_INDEX(run, level)];
 851         } else
 852             bits += esc_length;
 853     }
 854
 855     if (last >= 0) {
 856         if (s->mb_intra)
 857             s->dct_unquantize_intra(s, temp, 0, s->qscale);
 858         else
 859             s->dct_unquantize_inter(s, temp, 0, s->qscale);
 860     }
 861
 862     s->idsp.idct_add(lsrc2, 8, temp);
 863
 864     distortion = s->dsp.sse[1](NULL, lsrc2, lsrc1, 8, 8);
 865
 866     return distortion + ((bits * s->qscale * s->qscale * 109 + 64) >> 7);
 867 }
 868
 869 static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 870                     int stride, int h)
 871 {
 872     const uint8_t *scantable = s->intra_scantable.permutated;
 873     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 874     int i, last, run, bits, level, start_i;
 875     const int esc_length = s->ac_esc_length;
 876     uint8_t *length, *last_length;
 877
 878     av_assert2(h == 8);
 879
 880     s->dsp.diff_pixels(temp, src1, src2, stride);
 881
 882     s->block_last_index[0 /* FIXME */] =
 883     last                               =
 884         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 885
 886     bits = 0;
 887
 888     if (s->mb_intra) {
 889         start_i     = 1;
 890         length      = s->intra_ac_vlc_length;
 891         last_length = s->intra_ac_vlc_last_length;
 892         bits       += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
 893     } else {
 894         start_i     = 0;
 895         length      = s->inter_ac_vlc_length;
 896         last_length = s->inter_ac_vlc_last_length;
 897     }
 898
 899     if (last >= start_i) {
 900         run = 0;
 901         for (i = start_i; i < last; i++) {
 902             int j = scantable[i];
 903             level = temp[j];
 904
 905             if (level) {
 906                 level += 64;
 907                 if ((level & (~127)) == 0)
 908                     bits += length[UNI_AC_ENC_INDEX(run, level)];
 909                 else
 910                     bits += esc_length;
 911                 run = 0;
 912             } else
 913                 run++;
 914         }
 915         i = scantable[last];
 916
 917         level = temp[i] + 64;
 918
 919         av_assert2(level - 64);
 920
 921         if ((level & (~127)) == 0)
 922             bits += last_length[UNI_AC_ENC_INDEX(run, level)];
 923         else
 924             bits += esc_length;
 925     }
 926
 927     return bits;
 928 }
 929
 930 #define VSAD_INTRA(size)                                                \
 931 static int vsad_intra ## size ## _c(MpegEncContext *c,                  \
 932                                     uint8_t *s, uint8_t *dummy,         \
 933                                     int stride, int h)                  \
 934 {                                                                       \
 935     int score = 0, x, y;                                                \
 936                                                                         \
 937     for (y = 1; y < h; y++) {                                           \
 938         for (x = 0; x < size; x += 4) {                                 \
 939             score += FFABS(s[x]     - s[x + stride])     +              \
 940                      FFABS(s[x + 1] - s[x + stride + 1]) +              \
 941                      FFABS(s[x + 2] - s[x + 2 + stride]) +              \
 942                      FFABS(s[x + 3] - s[x + 3 + stride]);               \
 943         }                                                               \
 944         s += stride;                                                    \
 945     }                                                                   \
 946                                                                         \
 947     return score;                                                       \
 948 }
 949 VSAD_INTRA(8)
 950 VSAD_INTRA(16)
 951
 952 #define VSAD(size)                                                             \
 953 static int vsad ## size ## _c(MpegEncContext *c,                               \
 954                               uint8_t *s1, uint8_t *s2,                        \
 955                               int stride, int h)                               \
 956 {                                                                              \
 957     int score = 0, x, y;                                                       \
 958                                                                                \
 959     for (y = 1; y < h; y++) {                                                  \
 960         for (x = 0; x < size; x++)                                             \
 961             score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);   \
 962         s1 += stride;                                                          \
 963         s2 += stride;                                                          \
 964     }                                                                          \
 965                                                                                \
 966     return score;                                                              \
 967 }
 968 VSAD(8)
 969 VSAD(16)
 970
 971 #define SQ(a) ((a) * (a))
 972 #define VSSE_INTRA(size)                                                \
 973 static int vsse_intra ## size ## _c(MpegEncContext *c,                  \
 974                                     uint8_t *s, uint8_t *dummy,         \
 975                                     int stride, int h)                  \
 976 {                                                                       \
 977     int score = 0, x, y;                                                \
 978                                                                         \
 979     for (y = 1; y < h; y++) {                                           \
 980         for (x = 0; x < size; x += 4) {                                 \
 981             score += SQ(s[x]     - s[x + stride]) +                     \
 982                      SQ(s[x + 1] - s[x + stride + 1]) +                 \
 983                      SQ(s[x + 2] - s[x + stride + 2]) +                 \
 984                      SQ(s[x + 3] - s[x + stride + 3]);                  \
 985         }                                                               \
 986         s += stride;                                                    \
 987     }                                                                   \
 988                                                                         \
 989     return score;                                                       \
 990 }
 991 VSSE_INTRA(8)
 992 VSSE_INTRA(16)
 993
 994 #define VSSE(size)                                                             \
 995 static int vsse ## size ## _c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,     \
 996                     int stride, int h)                                         \
 997 {                                                                              \
 998     int score = 0, x, y;                                                       \
 999                                                                                \
1000     for (y = 1; y < h; y++) {                                                  \
1001         for (x = 0; x < size; x++)                                             \
1002             score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);      \
1003         s1 += stride;                                                          \
1004         s2 += stride;                                                          \
1005     }                                                                          \
1006                                                                                \
1007     return score;                                                              \
1008 }
1009 VSSE(8)
1010 VSSE(16)
1011
1012 #define WRAPPER8_16_SQ(name8, name16)                                   \
1013 static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src,        \
1014                   int stride, int h)                                    \
1015 {                                                                       \
1016     int score = 0;                                                      \
1017                                                                         \
1018     score += name8(s, dst, src, stride, 8);                             \
1019     score += name8(s, dst + 8, src + 8, stride, 8);                     \
1020     if (h == 16) {                                                      \
1021         dst   += 8 * stride;                                            \
1022         src   += 8 * stride;                                            \
1023         score += name8(s, dst, src, stride, 8);                         \
1024         score += name8(s, dst + 8, src + 8, stride, 8);                 \
1025     }                                                                   \
1026     return score;                                                       \
1027 }
1028
1029 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
1030 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
1031 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
1032 #if CONFIG_GPL
1033 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
1034 #endif
1035 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
1036 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
1037 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
1038 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
1039
1040 /* draw the edges of width 'w' of an image of size width, height */
1041 // FIXME: Check that this is OK for MPEG-4 interlaced.
1042 static void draw_edges_8_c(uint8_t *buf, int wrap, int width, int height,
1043                            int w, int h, int sides)
1044 {
1045     uint8_t *ptr = buf, *last_line;
1046     int i;
1047
1048     /* left and right */
1049     for (i = 0; i < height; i++) {
1050         memset(ptr - w, ptr[0], w);
1051         memset(ptr + width, ptr[width - 1], w);
1052         ptr += wrap;
1053     }
1054
1055     /* top and bottom + corners */
1056     buf -= w;
1057     last_line = buf + (height - 1) * wrap;
1058     if (sides & EDGE_TOP)
1059         for (i = 0; i < h; i++)
1060             // top
1061             memcpy(buf - (i + 1) * wrap, buf, width + w + w);
1062     if (sides & EDGE_BOTTOM)
1063         for (i = 0; i < h; i++)
1064             // bottom
1065             memcpy(last_line + (i + 1) * wrap, last_line, width + w + w);
1066 }
1067
1068 /* init static data */
1069 av_cold void ff_dsputil_static_init(void)
1070 {
1071     int i;
1072
1073     for (i = 0; i < 512; i++)
1074         ff_square_tab[i] = (i - 256) * (i - 256);
1075 }
1076
1077 int ff_check_alignment(void)
1078 {
1079     static int did_fail = 0;
1080     LOCAL_ALIGNED_16(int, aligned, [4]);
1081
1082     if ((intptr_t)aligned & 15) {
1083         if (!did_fail) {
1084 #if HAVE_MMX || HAVE_ALTIVEC
1085             av_log(NULL, AV_LOG_ERROR,
1086                 "Compiler did not align stack variables. Libavcodec has been miscompiled\n"
1087                 "and may be very slow or crash. This is not a bug in libavcodec,\n"
1088                 "but in the compiler. You may try recompiling using gcc >= 4.2.\n"
1089                 "Do not report crashes to FFmpeg developers.\n");
1090 #endif
1091             did_fail=1;
1092         }
1093         return -1;
1094     }
1095     return 0;
1096 }
1097
1098 av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
1099 {
1100     const unsigned high_bit_depth = avctx->bits_per_raw_sample > 8;
1101
1102     ff_check_alignment();
1103
1104 #if CONFIG_ENCODERS
1105     if (avctx->bits_per_raw_sample == 10) {
1106         c->fdct    = ff_jpeg_fdct_islow_10;
1107         c->fdct248 = ff_fdct248_islow_10;
1108     } else {
1109         if (avctx->dct_algo == FF_DCT_FASTINT) {
1110             c->fdct    = ff_fdct_ifast;
1111             c->fdct248 = ff_fdct_ifast248;
1112         } else if (avctx->dct_algo == FF_DCT_FAAN) {
1113             c->fdct    = ff_faandct;
1114             c->fdct248 = ff_faandct248;
1115         } else {
1116             c->fdct    = ff_jpeg_fdct_islow_8; // slow/accurate/default
1117             c->fdct248 = ff_fdct248_islow_8;
1118         }
1119     }
1120 #endif /* CONFIG_ENCODERS */
1121
1122     c->diff_pixels = diff_pixels_c;
1123
1124     c->sum_abs_dctelem = sum_abs_dctelem_c;
1125
1126     c->pix_sum   = pix_sum_c;
1127     c->pix_norm1 = pix_norm1_c;
1128
1129     /* TODO [0] 16  [1] 8 */
1130     c->pix_abs[0][0] = pix_abs16_c;
1131     c->pix_abs[0][1] = pix_abs16_x2_c;
1132     c->pix_abs[0][2] = pix_abs16_y2_c;
1133     c->pix_abs[0][3] = pix_abs16_xy2_c;
1134     c->pix_abs[1][0] = pix_abs8_c;
1135     c->pix_abs[1][1] = pix_abs8_x2_c;
1136     c->pix_abs[1][2] = pix_abs8_y2_c;
1137     c->pix_abs[1][3] = pix_abs8_xy2_c;
1138
1139 #define SET_CMP_FUNC(name)                      \
1140     c->name[0] = name ## 16_c;                  \
1141     c->name[1] = name ## 8x8_c;
1142
1143     SET_CMP_FUNC(hadamard8_diff)
1144     c->hadamard8_diff[4] = hadamard8_intra16_c;
1145     c->hadamard8_diff[5] = hadamard8_intra8x8_c;
1146     SET_CMP_FUNC(dct_sad)
1147     SET_CMP_FUNC(dct_max)
1148 #if CONFIG_GPL
1149     SET_CMP_FUNC(dct264_sad)
1150 #endif
1151     c->sad[0] = pix_abs16_c;
1152     c->sad[1] = pix_abs8_c;
1153     c->sse[0] = sse16_c;
1154     c->sse[1] = sse8_c;
1155     c->sse[2] = sse4_c;
1156     SET_CMP_FUNC(quant_psnr)
1157     SET_CMP_FUNC(rd)
1158     SET_CMP_FUNC(bit)
1159     c->vsad[0] = vsad16_c;
1160     c->vsad[1] = vsad8_c;
1161     c->vsad[4] = vsad_intra16_c;
1162     c->vsad[5] = vsad_intra8_c;
1163     c->vsse[0] = vsse16_c;
1164     c->vsse[1] = vsse8_c;
1165     c->vsse[4] = vsse_intra16_c;
1166     c->vsse[5] = vsse_intra8_c;
1167     c->nsse[0] = nsse16_c;
1168     c->nsse[1] = nsse8_c;
1169 #if CONFIG_SNOW_DECODER || CONFIG_SNOW_ENCODER
1170     ff_dsputil_init_dwt(c);
1171 #endif
1172
1173     c->try_8x8basis = try_8x8basis_c;
1174     c->add_8x8basis = add_8x8basis_c;
1175
1176     c->shrink[0] = av_image_copy_plane;
1177     c->shrink[1] = ff_shrink22;
1178     c->shrink[2] = ff_shrink44;
1179     c->shrink[3] = ff_shrink88;
1180
1181     c->draw_edges = draw_edges_8_c;
1182
1183     switch (avctx->bits_per_raw_sample) {
1184     case 9:
1185     case 10:
1186     case 12:
1187     case 14:
1188         c->get_pixels = get_pixels_16_c;
1189         break;
1190     default:
1191         if (avctx->bits_per_raw_sample<=8 || avctx->codec_type != AVMEDIA_TYPE_VIDEO) {
1192             c->get_pixels = get_pixels_8_c;
1193         }
1194         break;
1195     }
1196
1197
1198     if (ARCH_ALPHA)
1199         ff_dsputil_init_alpha(c, avctx);
1200     if (ARCH_ARM)
1201         ff_dsputil_init_arm(c, avctx, high_bit_depth);
1202     if (ARCH_PPC)
1203         ff_dsputil_init_ppc(c, avctx, high_bit_depth);
1204     if (ARCH_X86)
1205         ff_dsputil_init_x86(c, avctx, high_bit_depth);
1206 }
1207
1208 av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx)
1209 {
1210     ff_dsputil_init(c, avctx);
1211 }
1212
1213 av_cold void avpriv_dsputil_init(DSPContext *c, AVCodecContext *avctx)
1214 {
1215     ff_dsputil_init(c, avctx);
1216 }