git.sesse.net Git - ffmpeg/blob - libavcodec/me_cmp.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 #include "libavutil/attributes.h"
  24 #include "libavutil/internal.h"
  25 #include "libavutil/mem_internal.h"
  26 #include "avcodec.h"
  27 #include "copy_block.h"
  28 #include "simple_idct.h"
  29 #include "me_cmp.h"
  30 #include "mpegvideo.h"
  31 #include "config.h"
  32
  33 /* (i - 256) * (i - 256) */
  34 const uint32_t ff_square_tab[512] = {
  35     65536, 65025, 64516, 64009, 63504, 63001, 62500, 62001, 61504, 61009, 60516, 60025, 59536, 59049, 58564, 58081,
  36     57600, 57121, 56644, 56169, 55696, 55225, 54756, 54289, 53824, 53361, 52900, 52441, 51984, 51529, 51076, 50625,
  37     50176, 49729, 49284, 48841, 48400, 47961, 47524, 47089, 46656, 46225, 45796, 45369, 44944, 44521, 44100, 43681,
  38     43264, 42849, 42436, 42025, 41616, 41209, 40804, 40401, 40000, 39601, 39204, 38809, 38416, 38025, 37636, 37249,
  39     36864, 36481, 36100, 35721, 35344, 34969, 34596, 34225, 33856, 33489, 33124, 32761, 32400, 32041, 31684, 31329,
  40     30976, 30625, 30276, 29929, 29584, 29241, 28900, 28561, 28224, 27889, 27556, 27225, 26896, 26569, 26244, 25921,
  41     25600, 25281, 24964, 24649, 24336, 24025, 23716, 23409, 23104, 22801, 22500, 22201, 21904, 21609, 21316, 21025,
  42     20736, 20449, 20164, 19881, 19600, 19321, 19044, 18769, 18496, 18225, 17956, 17689, 17424, 17161, 16900, 16641,
  43     16384, 16129, 15876, 15625, 15376, 15129, 14884, 14641, 14400, 14161, 13924, 13689, 13456, 13225, 12996, 12769,
  44     12544, 12321, 12100, 11881, 11664, 11449, 11236, 11025, 10816, 10609, 10404, 10201, 10000,  9801,  9604,  9409,
  45      9216,  9025,  8836,  8649,  8464,  8281,  8100,  7921,  7744,  7569,  7396,  7225,  7056,  6889,  6724,  6561,
  46      6400,  6241,  6084,  5929,  5776,  5625,  5476,  5329,  5184,  5041,  4900,  4761,  4624,  4489,  4356,  4225,
  47      4096,  3969,  3844,  3721,  3600,  3481,  3364,  3249,  3136,  3025,  2916,  2809,  2704,  2601,  2500,  2401,
  48      2304,  2209,  2116,  2025,  1936,  1849,  1764,  1681,  1600,  1521,  1444,  1369,  1296,  1225,  1156,  1089,
  49      1024,   961,   900,   841,   784,   729,   676,   625,   576,   529,   484,   441,   400,   361,   324,   289,
  50       256,   225,   196,   169,   144,   121,   100,    81,    64,    49,    36,    25,    16,     9,     4,     1,
  51         0,     1,     4,     9,    16,    25,    36,    49,    64,    81,   100,   121,   144,   169,   196,   225,
  52       256,   289,   324,   361,   400,   441,   484,   529,   576,   625,   676,   729,   784,   841,   900,   961,
  53      1024,  1089,  1156,  1225,  1296,  1369,  1444,  1521,  1600,  1681,  1764,  1849,  1936,  2025,  2116,  2209,
  54      2304,  2401,  2500,  2601,  2704,  2809,  2916,  3025,  3136,  3249,  3364,  3481,  3600,  3721,  3844,  3969,
  55      4096,  4225,  4356,  4489,  4624,  4761,  4900,  5041,  5184,  5329,  5476,  5625,  5776,  5929,  6084,  6241,
  56      6400,  6561,  6724,  6889,  7056,  7225,  7396,  7569,  7744,  7921,  8100,  8281,  8464,  8649,  8836,  9025,
  57      9216,  9409,  9604,  9801, 10000, 10201, 10404, 10609, 10816, 11025, 11236, 11449, 11664, 11881, 12100, 12321,
  58     12544, 12769, 12996, 13225, 13456, 13689, 13924, 14161, 14400, 14641, 14884, 15129, 15376, 15625, 15876, 16129,
  59     16384, 16641, 16900, 17161, 17424, 17689, 17956, 18225, 18496, 18769, 19044, 19321, 19600, 19881, 20164, 20449,
  60     20736, 21025, 21316, 21609, 21904, 22201, 22500, 22801, 23104, 23409, 23716, 24025, 24336, 24649, 24964, 25281,
  61     25600, 25921, 26244, 26569, 26896, 27225, 27556, 27889, 28224, 28561, 28900, 29241, 29584, 29929, 30276, 30625,
  62     30976, 31329, 31684, 32041, 32400, 32761, 33124, 33489, 33856, 34225, 34596, 34969, 35344, 35721, 36100, 36481,
  63     36864, 37249, 37636, 38025, 38416, 38809, 39204, 39601, 40000, 40401, 40804, 41209, 41616, 42025, 42436, 42849,
  64     43264, 43681, 44100, 44521, 44944, 45369, 45796, 46225, 46656, 47089, 47524, 47961, 48400, 48841, 49284, 49729,
  65     50176, 50625, 51076, 51529, 51984, 52441, 52900, 53361, 53824, 54289, 54756, 55225, 55696, 56169, 56644, 57121,
  66     57600, 58081, 58564, 59049, 59536, 60025, 60516, 61009, 61504, 62001, 62500, 63001, 63504, 64009, 64516, 65025,
  67 };
  68
  69 static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
  70                   ptrdiff_t stride, int h)
  71 {
  72     int s = 0, i;
  73     const uint32_t *sq = ff_square_tab + 256;
  74
  75     for (i = 0; i < h; i++) {
  76         s    += sq[pix1[0] - pix2[0]];
  77         s    += sq[pix1[1] - pix2[1]];
  78         s    += sq[pix1[2] - pix2[2]];
  79         s    += sq[pix1[3] - pix2[3]];
  80         pix1 += stride;
  81         pix2 += stride;
  82     }
  83     return s;
  84 }
  85
  86 static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
  87                   ptrdiff_t stride, int h)
  88 {
  89     int s = 0, i;
  90     const uint32_t *sq = ff_square_tab + 256;
  91
  92     for (i = 0; i < h; i++) {
  93         s    += sq[pix1[0] - pix2[0]];
  94         s    += sq[pix1[1] - pix2[1]];
  95         s    += sq[pix1[2] - pix2[2]];
  96         s    += sq[pix1[3] - pix2[3]];
  97         s    += sq[pix1[4] - pix2[4]];
  98         s    += sq[pix1[5] - pix2[5]];
  99         s    += sq[pix1[6] - pix2[6]];
 100         s    += sq[pix1[7] - pix2[7]];
 101         pix1 += stride;
 102         pix2 += stride;
 103     }
 104     return s;
 105 }
 106
 107 static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 108                    ptrdiff_t stride, int h)
 109 {
 110     int s = 0, i;
 111     const uint32_t *sq = ff_square_tab + 256;
 112
 113     for (i = 0; i < h; i++) {
 114         s += sq[pix1[0]  - pix2[0]];
 115         s += sq[pix1[1]  - pix2[1]];
 116         s += sq[pix1[2]  - pix2[2]];
 117         s += sq[pix1[3]  - pix2[3]];
 118         s += sq[pix1[4]  - pix2[4]];
 119         s += sq[pix1[5]  - pix2[5]];
 120         s += sq[pix1[6]  - pix2[6]];
 121         s += sq[pix1[7]  - pix2[7]];
 122         s += sq[pix1[8]  - pix2[8]];
 123         s += sq[pix1[9]  - pix2[9]];
 124         s += sq[pix1[10] - pix2[10]];
 125         s += sq[pix1[11] - pix2[11]];
 126         s += sq[pix1[12] - pix2[12]];
 127         s += sq[pix1[13] - pix2[13]];
 128         s += sq[pix1[14] - pix2[14]];
 129         s += sq[pix1[15] - pix2[15]];
 130
 131         pix1 += stride;
 132         pix2 += stride;
 133     }
 134     return s;
 135 }
 136
 137 static int sum_abs_dctelem_c(int16_t *block)
 138 {
 139     int sum = 0, i;
 140
 141     for (i = 0; i < 64; i++)
 142         sum += FFABS(block[i]);
 143     return sum;
 144 }
 145
 146 #define avg2(a, b) (((a) + (b) + 1) >> 1)
 147 #define avg4(a, b, c, d) (((a) + (b) + (c) + (d) + 2) >> 2)
 148
 149 static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 150                               ptrdiff_t stride, int h)
 151 {
 152     int s = 0, i;
 153
 154     for (i = 0; i < h; i++) {
 155         s    += abs(pix1[0]  - pix2[0]);
 156         s    += abs(pix1[1]  - pix2[1]);
 157         s    += abs(pix1[2]  - pix2[2]);
 158         s    += abs(pix1[3]  - pix2[3]);
 159         s    += abs(pix1[4]  - pix2[4]);
 160         s    += abs(pix1[5]  - pix2[5]);
 161         s    += abs(pix1[6]  - pix2[6]);
 162         s    += abs(pix1[7]  - pix2[7]);
 163         s    += abs(pix1[8]  - pix2[8]);
 164         s    += abs(pix1[9]  - pix2[9]);
 165         s    += abs(pix1[10] - pix2[10]);
 166         s    += abs(pix1[11] - pix2[11]);
 167         s    += abs(pix1[12] - pix2[12]);
 168         s    += abs(pix1[13] - pix2[13]);
 169         s    += abs(pix1[14] - pix2[14]);
 170         s    += abs(pix1[15] - pix2[15]);
 171         pix1 += stride;
 172         pix2 += stride;
 173     }
 174     return s;
 175 }
 176
 177 static inline int pix_median_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 178                              ptrdiff_t stride, int h)
 179 {
 180     int s = 0, i, j;
 181
 182 #define V(x) (pix1[x] - pix2[x])
 183
 184     s    += abs(V(0));
 185     s    += abs(V(1) - V(0));
 186     s    += abs(V(2) - V(1));
 187     s    += abs(V(3) - V(2));
 188     s    += abs(V(4) - V(3));
 189     s    += abs(V(5) - V(4));
 190     s    += abs(V(6) - V(5));
 191     s    += abs(V(7) - V(6));
 192     s    += abs(V(8) - V(7));
 193     s    += abs(V(9) - V(8));
 194     s    += abs(V(10) - V(9));
 195     s    += abs(V(11) - V(10));
 196     s    += abs(V(12) - V(11));
 197     s    += abs(V(13) - V(12));
 198     s    += abs(V(14) - V(13));
 199     s    += abs(V(15) - V(14));
 200
 201     pix1 += stride;
 202     pix2 += stride;
 203
 204     for (i = 1; i < h; i++) {
 205         s    += abs(V(0) - V(-stride));
 206         for (j = 1; j < 16; j++)
 207             s    += abs(V(j) - mid_pred(V(j-stride), V(j-1), V(j-stride) + V(j-1) - V(j-stride-1)));
 208         pix1 += stride;
 209         pix2 += stride;
 210
 211     }
 212 #undef V
 213     return s;
 214 }
 215
 216 static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 217                           ptrdiff_t stride, int h)
 218 {
 219     int s = 0, i;
 220
 221     for (i = 0; i < h; i++) {
 222         s    += abs(pix1[0]  - avg2(pix2[0],  pix2[1]));
 223         s    += abs(pix1[1]  - avg2(pix2[1],  pix2[2]));
 224         s    += abs(pix1[2]  - avg2(pix2[2],  pix2[3]));
 225         s    += abs(pix1[3]  - avg2(pix2[3],  pix2[4]));
 226         s    += abs(pix1[4]  - avg2(pix2[4],  pix2[5]));
 227         s    += abs(pix1[5]  - avg2(pix2[5],  pix2[6]));
 228         s    += abs(pix1[6]  - avg2(pix2[6],  pix2[7]));
 229         s    += abs(pix1[7]  - avg2(pix2[7],  pix2[8]));
 230         s    += abs(pix1[8]  - avg2(pix2[8],  pix2[9]));
 231         s    += abs(pix1[9]  - avg2(pix2[9],  pix2[10]));
 232         s    += abs(pix1[10] - avg2(pix2[10], pix2[11]));
 233         s    += abs(pix1[11] - avg2(pix2[11], pix2[12]));
 234         s    += abs(pix1[12] - avg2(pix2[12], pix2[13]));
 235         s    += abs(pix1[13] - avg2(pix2[13], pix2[14]));
 236         s    += abs(pix1[14] - avg2(pix2[14], pix2[15]));
 237         s    += abs(pix1[15] - avg2(pix2[15], pix2[16]));
 238         pix1 += stride;
 239         pix2 += stride;
 240     }
 241     return s;
 242 }
 243
 244 static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 245                           ptrdiff_t stride, int h)
 246 {
 247     int s = 0, i;
 248     uint8_t *pix3 = pix2 + stride;
 249
 250     for (i = 0; i < h; i++) {
 251         s    += abs(pix1[0]  - avg2(pix2[0],  pix3[0]));
 252         s    += abs(pix1[1]  - avg2(pix2[1],  pix3[1]));
 253         s    += abs(pix1[2]  - avg2(pix2[2],  pix3[2]));
 254         s    += abs(pix1[3]  - avg2(pix2[3],  pix3[3]));
 255         s    += abs(pix1[4]  - avg2(pix2[4],  pix3[4]));
 256         s    += abs(pix1[5]  - avg2(pix2[5],  pix3[5]));
 257         s    += abs(pix1[6]  - avg2(pix2[6],  pix3[6]));
 258         s    += abs(pix1[7]  - avg2(pix2[7],  pix3[7]));
 259         s    += abs(pix1[8]  - avg2(pix2[8],  pix3[8]));
 260         s    += abs(pix1[9]  - avg2(pix2[9],  pix3[9]));
 261         s    += abs(pix1[10] - avg2(pix2[10], pix3[10]));
 262         s    += abs(pix1[11] - avg2(pix2[11], pix3[11]));
 263         s    += abs(pix1[12] - avg2(pix2[12], pix3[12]));
 264         s    += abs(pix1[13] - avg2(pix2[13], pix3[13]));
 265         s    += abs(pix1[14] - avg2(pix2[14], pix3[14]));
 266         s    += abs(pix1[15] - avg2(pix2[15], pix3[15]));
 267         pix1 += stride;
 268         pix2 += stride;
 269         pix3 += stride;
 270     }
 271     return s;
 272 }
 273
 274 static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 275                            ptrdiff_t stride, int h)
 276 {
 277     int s = 0, i;
 278     uint8_t *pix3 = pix2 + stride;
 279
 280     for (i = 0; i < h; i++) {
 281         s    += abs(pix1[0]  - avg4(pix2[0],  pix2[1],  pix3[0],  pix3[1]));
 282         s    += abs(pix1[1]  - avg4(pix2[1],  pix2[2],  pix3[1],  pix3[2]));
 283         s    += abs(pix1[2]  - avg4(pix2[2],  pix2[3],  pix3[2],  pix3[3]));
 284         s    += abs(pix1[3]  - avg4(pix2[3],  pix2[4],  pix3[3],  pix3[4]));
 285         s    += abs(pix1[4]  - avg4(pix2[4],  pix2[5],  pix3[4],  pix3[5]));
 286         s    += abs(pix1[5]  - avg4(pix2[5],  pix2[6],  pix3[5],  pix3[6]));
 287         s    += abs(pix1[6]  - avg4(pix2[6],  pix2[7],  pix3[6],  pix3[7]));
 288         s    += abs(pix1[7]  - avg4(pix2[7],  pix2[8],  pix3[7],  pix3[8]));
 289         s    += abs(pix1[8]  - avg4(pix2[8],  pix2[9],  pix3[8],  pix3[9]));
 290         s    += abs(pix1[9]  - avg4(pix2[9],  pix2[10], pix3[9],  pix3[10]));
 291         s    += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
 292         s    += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
 293         s    += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
 294         s    += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
 295         s    += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
 296         s    += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
 297         pix1 += stride;
 298         pix2 += stride;
 299         pix3 += stride;
 300     }
 301     return s;
 302 }
 303
 304 static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 305                              ptrdiff_t stride, int h)
 306 {
 307     int s = 0, i;
 308
 309     for (i = 0; i < h; i++) {
 310         s    += abs(pix1[0] - pix2[0]);
 311         s    += abs(pix1[1] - pix2[1]);
 312         s    += abs(pix1[2] - pix2[2]);
 313         s    += abs(pix1[3] - pix2[3]);
 314         s    += abs(pix1[4] - pix2[4]);
 315         s    += abs(pix1[5] - pix2[5]);
 316         s    += abs(pix1[6] - pix2[6]);
 317         s    += abs(pix1[7] - pix2[7]);
 318         pix1 += stride;
 319         pix2 += stride;
 320     }
 321     return s;
 322 }
 323
 324 static inline int pix_median_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 325                              ptrdiff_t stride, int h)
 326 {
 327     int s = 0, i, j;
 328
 329 #define V(x) (pix1[x] - pix2[x])
 330
 331     s    += abs(V(0));
 332     s    += abs(V(1) - V(0));
 333     s    += abs(V(2) - V(1));
 334     s    += abs(V(3) - V(2));
 335     s    += abs(V(4) - V(3));
 336     s    += abs(V(5) - V(4));
 337     s    += abs(V(6) - V(5));
 338     s    += abs(V(7) - V(6));
 339
 340     pix1 += stride;
 341     pix2 += stride;
 342
 343     for (i = 1; i < h; i++) {
 344         s    += abs(V(0) - V(-stride));
 345         for (j = 1; j < 8; j++)
 346             s    += abs(V(j) - mid_pred(V(j-stride), V(j-1), V(j-stride) + V(j-1) - V(j-stride-1)));
 347         pix1 += stride;
 348         pix2 += stride;
 349
 350     }
 351 #undef V
 352     return s;
 353 }
 354
 355 static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 356                          ptrdiff_t stride, int h)
 357 {
 358     int s = 0, i;
 359
 360     for (i = 0; i < h; i++) {
 361         s    += abs(pix1[0] - avg2(pix2[0], pix2[1]));
 362         s    += abs(pix1[1] - avg2(pix2[1], pix2[2]));
 363         s    += abs(pix1[2] - avg2(pix2[2], pix2[3]));
 364         s    += abs(pix1[3] - avg2(pix2[3], pix2[4]));
 365         s    += abs(pix1[4] - avg2(pix2[4], pix2[5]));
 366         s    += abs(pix1[5] - avg2(pix2[5], pix2[6]));
 367         s    += abs(pix1[6] - avg2(pix2[6], pix2[7]));
 368         s    += abs(pix1[7] - avg2(pix2[7], pix2[8]));
 369         pix1 += stride;
 370         pix2 += stride;
 371     }
 372     return s;
 373 }
 374
 375 static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 376                          ptrdiff_t stride, int h)
 377 {
 378     int s = 0, i;
 379     uint8_t *pix3 = pix2 + stride;
 380
 381     for (i = 0; i < h; i++) {
 382         s    += abs(pix1[0] - avg2(pix2[0], pix3[0]));
 383         s    += abs(pix1[1] - avg2(pix2[1], pix3[1]));
 384         s    += abs(pix1[2] - avg2(pix2[2], pix3[2]));
 385         s    += abs(pix1[3] - avg2(pix2[3], pix3[3]));
 386         s    += abs(pix1[4] - avg2(pix2[4], pix3[4]));
 387         s    += abs(pix1[5] - avg2(pix2[5], pix3[5]));
 388         s    += abs(pix1[6] - avg2(pix2[6], pix3[6]));
 389         s    += abs(pix1[7] - avg2(pix2[7], pix3[7]));
 390         pix1 += stride;
 391         pix2 += stride;
 392         pix3 += stride;
 393     }
 394     return s;
 395 }
 396
 397 static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
 398                           ptrdiff_t stride, int h)
 399 {
 400     int s = 0, i;
 401     uint8_t *pix3 = pix2 + stride;
 402
 403     for (i = 0; i < h; i++) {
 404         s    += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
 405         s    += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
 406         s    += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
 407         s    += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
 408         s    += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
 409         s    += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
 410         s    += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
 411         s    += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
 412         pix1 += stride;
 413         pix2 += stride;
 414         pix3 += stride;
 415     }
 416     return s;
 417 }
 418
 419 static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
 420                     ptrdiff_t 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,
 445                    ptrdiff_t stride, int h)
 446 {
 447     int score1 = 0, score2 = 0, x, y;
 448
 449     for (y = 0; y < h; y++) {
 450         for (x = 0; x < 8; x++)
 451             score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]);
 452         if (y + 1 < h) {
 453             for (x = 0; x < 7; x++)
 454                 score2 += FFABS(s1[x]     - s1[x + stride] -
 455                                 s1[x + 1] + s1[x + stride + 1]) -
 456                           FFABS(s2[x]     - s2[x + stride] -
 457                                 s2[x + 1] + s2[x + stride + 1]);
 458         }
 459         s1 += stride;
 460         s2 += stride;
 461     }
 462
 463     if (c)
 464         return score1 + FFABS(score2) * c->avctx->nsse_weight;
 465     else
 466         return score1 + FFABS(score2) * 8;
 467 }
 468
 469 static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b,
 470                     ptrdiff_t stride, int h)
 471 {
 472     return 0;
 473 }
 474
 475 void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
 476 {
 477     int i;
 478
 479     memset(cmp, 0, sizeof(void *) * 6);
 480
 481     for (i = 0; i < 6; i++) {
 482         switch (type & 0xFF) {
 483         case FF_CMP_SAD:
 484             cmp[i] = c->sad[i];
 485             break;
 486         case FF_CMP_MEDIAN_SAD:
 487             cmp[i] = c->median_sad[i];
 488             break;
 489         case FF_CMP_SATD:
 490             cmp[i] = c->hadamard8_diff[i];
 491             break;
 492         case FF_CMP_SSE:
 493             cmp[i] = c->sse[i];
 494             break;
 495         case FF_CMP_DCT:
 496             cmp[i] = c->dct_sad[i];
 497             break;
 498         case FF_CMP_DCT264:
 499             cmp[i] = c->dct264_sad[i];
 500             break;
 501         case FF_CMP_DCTMAX:
 502             cmp[i] = c->dct_max[i];
 503             break;
 504         case FF_CMP_PSNR:
 505             cmp[i] = c->quant_psnr[i];
 506             break;
 507         case FF_CMP_BIT:
 508             cmp[i] = c->bit[i];
 509             break;
 510         case FF_CMP_RD:
 511             cmp[i] = c->rd[i];
 512             break;
 513         case FF_CMP_VSAD:
 514             cmp[i] = c->vsad[i];
 515             break;
 516         case FF_CMP_VSSE:
 517             cmp[i] = c->vsse[i];
 518             break;
 519         case FF_CMP_ZERO:
 520             cmp[i] = zero_cmp;
 521             break;
 522         case FF_CMP_NSSE:
 523             cmp[i] = c->nsse[i];
 524             break;
 525 #if CONFIG_DWT
 526         case FF_CMP_W53:
 527             cmp[i]= c->w53[i];
 528             break;
 529         case FF_CMP_W97:
 530             cmp[i]= c->w97[i];
 531             break;
 532 #endif
 533         default:
 534             av_log(NULL, AV_LOG_ERROR,
 535                    "internal error in cmp function selection\n");
 536         }
 537     }
 538 }
 539
 540 #define BUTTERFLY2(o1, o2, i1, i2)              \
 541     o1 = (i1) + (i2);                           \
 542     o2 = (i1) - (i2);
 543
 544 #define BUTTERFLY1(x, y)                        \
 545     {                                           \
 546         int a, b;                               \
 547         a = x;                                  \
 548         b = y;                                  \
 549         x = a + b;                              \
 550         y = a - b;                              \
 551     }
 552
 553 #define BUTTERFLYA(x, y) (FFABS((x) + (y)) + FFABS((x) - (y)))
 554
 555 static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst,
 556                                uint8_t *src, ptrdiff_t stride, int h)
 557 {
 558     int i, temp[64], sum = 0;
 559
 560     av_assert2(h == 8);
 561
 562     for (i = 0; i < 8; i++) {
 563         // FIXME: try pointer walks
 564         BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
 565                    src[stride * i + 0] - dst[stride * i + 0],
 566                    src[stride * i + 1] - dst[stride * i + 1]);
 567         BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
 568                    src[stride * i + 2] - dst[stride * i + 2],
 569                    src[stride * i + 3] - dst[stride * i + 3]);
 570         BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
 571                    src[stride * i + 4] - dst[stride * i + 4],
 572                    src[stride * i + 5] - dst[stride * i + 5]);
 573         BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
 574                    src[stride * i + 6] - dst[stride * i + 6],
 575                    src[stride * i + 7] - dst[stride * i + 7]);
 576
 577         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
 578         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
 579         BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
 580         BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
 581
 582         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
 583         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
 584         BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
 585         BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
 586     }
 587
 588     for (i = 0; i < 8; i++) {
 589         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
 590         BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
 591         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
 592         BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
 593
 594         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
 595         BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
 596         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
 597         BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
 598
 599         sum += BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i]) +
 600                BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i]) +
 601                BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i]) +
 602                BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
 603     }
 604     return sum;
 605 }
 606
 607 static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src,
 608                                 uint8_t *dummy, ptrdiff_t stride, int h)
 609 {
 610     int i, temp[64], sum = 0;
 611
 612     av_assert2(h == 8);
 613
 614     for (i = 0; i < 8; i++) {
 615         // FIXME: try pointer walks
 616         BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
 617                    src[stride * i + 0], src[stride * i + 1]);
 618         BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
 619                    src[stride * i + 2], src[stride * i + 3]);
 620         BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
 621                    src[stride * i + 4], src[stride * i + 5]);
 622         BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
 623                    src[stride * i + 6], src[stride * i + 7]);
 624
 625         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
 626         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
 627         BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
 628         BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
 629
 630         BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
 631         BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
 632         BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
 633         BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
 634     }
 635
 636     for (i = 0; i < 8; i++) {
 637         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
 638         BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
 639         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
 640         BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
 641
 642         BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
 643         BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
 644         BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
 645         BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
 646
 647         sum +=
 648             BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i])
 649             + BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i])
 650             + BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i])
 651             + BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
 652     }
 653
 654     sum -= FFABS(temp[8 * 0] + temp[8 * 4]); // -mean
 655
 656     return sum;
 657 }
 658
 659 static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 660                         uint8_t *src2, ptrdiff_t stride, int h)
 661 {
 662     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 663
 664     av_assert2(h == 8);
 665
 666     s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 667     s->fdsp.fdct(temp);
 668     return s->mecc.sum_abs_dctelem(temp);
 669 }
 670
 671 #if CONFIG_GPL
 672 #define DCT8_1D                                         \
 673     {                                                   \
 674         const int s07 = SRC(0) + SRC(7);                \
 675         const int s16 = SRC(1) + SRC(6);                \
 676         const int s25 = SRC(2) + SRC(5);                \
 677         const int s34 = SRC(3) + SRC(4);                \
 678         const int a0  = s07 + s34;                      \
 679         const int a1  = s16 + s25;                      \
 680         const int a2  = s07 - s34;                      \
 681         const int a3  = s16 - s25;                      \
 682         const int d07 = SRC(0) - SRC(7);                \
 683         const int d16 = SRC(1) - SRC(6);                \
 684         const int d25 = SRC(2) - SRC(5);                \
 685         const int d34 = SRC(3) - SRC(4);                \
 686         const int a4  = d16 + d25 + (d07 + (d07 >> 1)); \
 687         const int a5  = d07 - d34 - (d25 + (d25 >> 1)); \
 688         const int a6  = d07 + d34 - (d16 + (d16 >> 1)); \
 689         const int a7  = d16 - d25 + (d34 + (d34 >> 1)); \
 690         DST(0, a0 + a1);                                \
 691         DST(1, a4 + (a7 >> 2));                         \
 692         DST(2, a2 + (a3 >> 1));                         \
 693         DST(3, a5 + (a6 >> 2));                         \
 694         DST(4, a0 - a1);                                \
 695         DST(5, a6 - (a5 >> 2));                         \
 696         DST(6, (a2 >> 1) - a3);                         \
 697         DST(7, (a4 >> 2) - a7);                         \
 698     }
 699
 700 static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
 701                            uint8_t *src2, ptrdiff_t stride, int h)
 702 {
 703     int16_t dct[8][8];
 704     int i, sum = 0;
 705
 706     s->pdsp.diff_pixels_unaligned(dct[0], src1, src2, stride);
 707
 708 #define SRC(x) dct[i][x]
 709 #define DST(x, v) dct[i][x] = v
 710     for (i = 0; i < 8; i++)
 711         DCT8_1D
 712 #undef SRC
 713 #undef DST
 714
 715 #define SRC(x) dct[x][i]
 716 #define DST(x, v) sum += FFABS(v)
 717         for (i = 0; i < 8; i++)
 718             DCT8_1D
 719 #undef SRC
 720 #undef DST
 721             return sum;
 722 }
 723 #endif
 724
 725 static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
 726                         uint8_t *src2, ptrdiff_t stride, int h)
 727 {
 728     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 729     int sum = 0, i;
 730
 731     av_assert2(h == 8);
 732
 733     s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 734     s->fdsp.fdct(temp);
 735
 736     for (i = 0; i < 64; i++)
 737         sum = FFMAX(sum, FFABS(temp[i]));
 738
 739     return sum;
 740 }
 741
 742 static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1,
 743                            uint8_t *src2, ptrdiff_t stride, int h)
 744 {
 745     LOCAL_ALIGNED_16(int16_t, temp, [64 * 2]);
 746     int16_t *const bak = temp + 64;
 747     int sum = 0, i;
 748
 749     av_assert2(h == 8);
 750     s->mb_intra = 0;
 751
 752     s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 753
 754     memcpy(bak, temp, 64 * sizeof(int16_t));
 755
 756     s->block_last_index[0 /* FIXME */] =
 757         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 758     s->dct_unquantize_inter(s, temp, 0, s->qscale);
 759     ff_simple_idct_int16_8bit(temp); // FIXME
 760
 761     for (i = 0; i < 64; i++)
 762         sum += (temp[i] - bak[i]) * (temp[i] - bak[i]);
 763
 764     return sum;
 765 }
 766
 767 static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 768                    ptrdiff_t stride, int h)
 769 {
 770     const uint8_t *scantable = s->intra_scantable.permutated;
 771     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 772     LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
 773     LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
 774     int i, last, run, bits, level, distortion, start_i;
 775     const int esc_length = s->ac_esc_length;
 776     uint8_t *length, *last_length;
 777
 778     av_assert2(h == 8);
 779
 780     copy_block8(lsrc1, src1, 8, stride, 8);
 781     copy_block8(lsrc2, src2, 8, stride, 8);
 782
 783     s->pdsp.diff_pixels(temp, lsrc1, lsrc2, 8);
 784
 785     s->block_last_index[0 /* FIXME */] =
 786     last                               =
 787         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 788
 789     bits = 0;
 790
 791     if (s->mb_intra) {
 792         start_i     = 1;
 793         length      = s->intra_ac_vlc_length;
 794         last_length = s->intra_ac_vlc_last_length;
 795         bits       += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
 796     } else {
 797         start_i     = 0;
 798         length      = s->inter_ac_vlc_length;
 799         last_length = s->inter_ac_vlc_last_length;
 800     }
 801
 802     if (last >= start_i) {
 803         run = 0;
 804         for (i = start_i; i < last; i++) {
 805             int j = scantable[i];
 806             level = temp[j];
 807
 808             if (level) {
 809                 level += 64;
 810                 if ((level & (~127)) == 0)
 811                     bits += length[UNI_AC_ENC_INDEX(run, level)];
 812                 else
 813                     bits += esc_length;
 814                 run = 0;
 815             } else
 816                 run++;
 817         }
 818         i = scantable[last];
 819
 820         level = temp[i] + 64;
 821
 822         av_assert2(level - 64);
 823
 824         if ((level & (~127)) == 0) {
 825             bits += last_length[UNI_AC_ENC_INDEX(run, level)];
 826         } else
 827             bits += esc_length;
 828     }
 829
 830     if (last >= 0) {
 831         if (s->mb_intra)
 832             s->dct_unquantize_intra(s, temp, 0, s->qscale);
 833         else
 834             s->dct_unquantize_inter(s, temp, 0, s->qscale);
 835     }
 836
 837     s->idsp.idct_add(lsrc2, 8, temp);
 838
 839     distortion = s->mecc.sse[1](NULL, lsrc2, lsrc1, 8, 8);
 840
 841     return distortion + ((bits * s->qscale * s->qscale * 109 + 64) >> 7);
 842 }
 843
 844 static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
 845                     ptrdiff_t stride, int h)
 846 {
 847     const uint8_t *scantable = s->intra_scantable.permutated;
 848     LOCAL_ALIGNED_16(int16_t, temp, [64]);
 849     int i, last, run, bits, level, start_i;
 850     const int esc_length = s->ac_esc_length;
 851     uint8_t *length, *last_length;
 852
 853     av_assert2(h == 8);
 854
 855     s->pdsp.diff_pixels_unaligned(temp, src1, src2, stride);
 856
 857     s->block_last_index[0 /* FIXME */] =
 858     last                               =
 859         s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
 860
 861     bits = 0;
 862
 863     if (s->mb_intra) {
 864         start_i     = 1;
 865         length      = s->intra_ac_vlc_length;
 866         last_length = s->intra_ac_vlc_last_length;
 867         bits       += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
 868     } else {
 869         start_i     = 0;
 870         length      = s->inter_ac_vlc_length;
 871         last_length = s->inter_ac_vlc_last_length;
 872     }
 873
 874     if (last >= start_i) {
 875         run = 0;
 876         for (i = start_i; i < last; i++) {
 877             int j = scantable[i];
 878             level = temp[j];
 879
 880             if (level) {
 881                 level += 64;
 882                 if ((level & (~127)) == 0)
 883                     bits += length[UNI_AC_ENC_INDEX(run, level)];
 884                 else
 885                     bits += esc_length;
 886                 run = 0;
 887             } else
 888                 run++;
 889         }
 890         i = scantable[last];
 891
 892         level = temp[i] + 64;
 893
 894         av_assert2(level - 64);
 895
 896         if ((level & (~127)) == 0)
 897             bits += last_length[UNI_AC_ENC_INDEX(run, level)];
 898         else
 899             bits += esc_length;
 900     }
 901
 902     return bits;
 903 }
 904
 905 #define VSAD_INTRA(size)                                                \
 906 static int vsad_intra ## size ## _c(MpegEncContext *c,                  \
 907                                     uint8_t *s, uint8_t *dummy,         \
 908                                     ptrdiff_t stride, int h)            \
 909 {                                                                       \
 910     int score = 0, x, y;                                                \
 911                                                                         \
 912     for (y = 1; y < h; y++) {                                           \
 913         for (x = 0; x < size; x += 4) {                                 \
 914             score += FFABS(s[x]     - s[x + stride])     +              \
 915                      FFABS(s[x + 1] - s[x + stride + 1]) +              \
 916                      FFABS(s[x + 2] - s[x + 2 + stride]) +              \
 917                      FFABS(s[x + 3] - s[x + 3 + stride]);               \
 918         }                                                               \
 919         s += stride;                                                    \
 920     }                                                                   \
 921                                                                         \
 922     return score;                                                       \
 923 }
 924 VSAD_INTRA(8)
 925 VSAD_INTRA(16)
 926
 927 #define VSAD(size)                                                             \
 928 static int vsad ## size ## _c(MpegEncContext *c,                               \
 929                               uint8_t *s1, uint8_t *s2,                        \
 930                               ptrdiff_t stride, int h)                               \
 931 {                                                                              \
 932     int score = 0, x, y;                                                       \
 933                                                                                \
 934     for (y = 1; y < h; y++) {                                                  \
 935         for (x = 0; x < size; x++)                                             \
 936             score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);   \
 937         s1 += stride;                                                          \
 938         s2 += stride;                                                          \
 939     }                                                                          \
 940                                                                                \
 941     return score;                                                              \
 942 }
 943 VSAD(8)
 944 VSAD(16)
 945
 946 #define SQ(a) ((a) * (a))
 947 #define VSSE_INTRA(size)                                                \
 948 static int vsse_intra ## size ## _c(MpegEncContext *c,                  \
 949                                     uint8_t *s, uint8_t *dummy,         \
 950                                     ptrdiff_t stride, int h)            \
 951 {                                                                       \
 952     int score = 0, x, y;                                                \
 953                                                                         \
 954     for (y = 1; y < h; y++) {                                           \
 955         for (x = 0; x < size; x += 4) {                                 \
 956             score += SQ(s[x]     - s[x + stride]) +                     \
 957                      SQ(s[x + 1] - s[x + stride + 1]) +                 \
 958                      SQ(s[x + 2] - s[x + stride + 2]) +                 \
 959                      SQ(s[x + 3] - s[x + stride + 3]);                  \
 960         }                                                               \
 961         s += stride;                                                    \
 962     }                                                                   \
 963                                                                         \
 964     return score;                                                       \
 965 }
 966 VSSE_INTRA(8)
 967 VSSE_INTRA(16)
 968
 969 #define VSSE(size)                                                             \
 970 static int vsse ## size ## _c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,     \
 971                               ptrdiff_t stride, int h)                         \
 972 {                                                                              \
 973     int score = 0, x, y;                                                       \
 974                                                                                \
 975     for (y = 1; y < h; y++) {                                                  \
 976         for (x = 0; x < size; x++)                                             \
 977             score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);      \
 978         s1 += stride;                                                          \
 979         s2 += stride;                                                          \
 980     }                                                                          \
 981                                                                                \
 982     return score;                                                              \
 983 }
 984 VSSE(8)
 985 VSSE(16)
 986
 987 #define WRAPPER8_16_SQ(name8, name16)                                   \
 988 static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src,        \
 989                   ptrdiff_t stride, int h)                              \
 990 {                                                                       \
 991     int score = 0;                                                      \
 992                                                                         \
 993     score += name8(s, dst, src, stride, 8);                             \
 994     score += name8(s, dst + 8, src + 8, stride, 8);                     \
 995     if (h == 16) {                                                      \
 996         dst   += 8 * stride;                                            \
 997         src   += 8 * stride;                                            \
 998         score += name8(s, dst, src, stride, 8);                         \
 999         score += name8(s, dst + 8, src + 8, stride, 8);                 \
1000     }                                                                   \
1001     return score;                                                       \
1002 }
1003
1004 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
1005 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
1006 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
1007 #if CONFIG_GPL
1008 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
1009 #endif
1010 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
1011 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
1012 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
1013 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
1014
1015 av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
1016 {
1017     c->sum_abs_dctelem = sum_abs_dctelem_c;
1018
1019     /* TODO [0] 16  [1] 8 */
1020     c->pix_abs[0][0] = pix_abs16_c;
1021     c->pix_abs[0][1] = pix_abs16_x2_c;
1022     c->pix_abs[0][2] = pix_abs16_y2_c;
1023     c->pix_abs[0][3] = pix_abs16_xy2_c;
1024     c->pix_abs[1][0] = pix_abs8_c;
1025     c->pix_abs[1][1] = pix_abs8_x2_c;
1026     c->pix_abs[1][2] = pix_abs8_y2_c;
1027     c->pix_abs[1][3] = pix_abs8_xy2_c;
1028
1029 #define SET_CMP_FUNC(name)                      \
1030     c->name[0] = name ## 16_c;                  \
1031     c->name[1] = name ## 8x8_c;
1032
1033     SET_CMP_FUNC(hadamard8_diff)
1034     c->hadamard8_diff[4] = hadamard8_intra16_c;
1035     c->hadamard8_diff[5] = hadamard8_intra8x8_c;
1036     SET_CMP_FUNC(dct_sad)
1037     SET_CMP_FUNC(dct_max)
1038 #if CONFIG_GPL
1039     SET_CMP_FUNC(dct264_sad)
1040 #endif
1041     c->sad[0] = pix_abs16_c;
1042     c->sad[1] = pix_abs8_c;
1043     c->sse[0] = sse16_c;
1044     c->sse[1] = sse8_c;
1045     c->sse[2] = sse4_c;
1046     SET_CMP_FUNC(quant_psnr)
1047     SET_CMP_FUNC(rd)
1048     SET_CMP_FUNC(bit)
1049     c->vsad[0] = vsad16_c;
1050     c->vsad[1] = vsad8_c;
1051     c->vsad[4] = vsad_intra16_c;
1052     c->vsad[5] = vsad_intra8_c;
1053     c->vsse[0] = vsse16_c;
1054     c->vsse[1] = vsse8_c;
1055     c->vsse[4] = vsse_intra16_c;
1056     c->vsse[5] = vsse_intra8_c;
1057     c->nsse[0] = nsse16_c;
1058     c->nsse[1] = nsse8_c;
1059 #if CONFIG_SNOW_DECODER || CONFIG_SNOW_ENCODER
1060     ff_dsputil_init_dwt(c);
1061 #endif
1062
1063     if (ARCH_ALPHA)
1064         ff_me_cmp_init_alpha(c, avctx);
1065     if (ARCH_ARM)
1066         ff_me_cmp_init_arm(c, avctx);
1067     if (ARCH_PPC)
1068         ff_me_cmp_init_ppc(c, avctx);
1069     if (ARCH_X86)
1070         ff_me_cmp_init_x86(c, avctx);
1071     if (ARCH_MIPS)
1072         ff_me_cmp_init_mips(c, avctx);
1073
1074     c->median_sad[0] = pix_median_abs16_c;
1075     c->median_sad[1] = pix_median_abs8_c;
1076 }