Libav
me_cmp.c
Go to the documentation of this file.
1 /*
2  * This file is part of Libav.
3  *
4  * Libav is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * Libav is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with Libav; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/attributes.h"
20 #include "avcodec.h"
21 #include "copy_block.h"
22 #include "simple_idct.h"
23 #include "me_cmp.h"
24 #include "mpegvideo.h"
25 #include "config.h"
26 
27 uint32_t ff_square_tab[512] = { 0, };
28 
29 static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
30  int line_size, int h)
31 {
32  int s = 0, i;
33  uint32_t *sq = ff_square_tab + 256;
34 
35  for (i = 0; i < h; i++) {
36  s += sq[pix1[0] - pix2[0]];
37  s += sq[pix1[1] - pix2[1]];
38  s += sq[pix1[2] - pix2[2]];
39  s += sq[pix1[3] - pix2[3]];
40  pix1 += line_size;
41  pix2 += line_size;
42  }
43  return s;
44 }
45 
46 static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
47  int line_size, int h)
48 {
49  int s = 0, i;
50  uint32_t *sq = ff_square_tab + 256;
51 
52  for (i = 0; i < h; i++) {
53  s += sq[pix1[0] - pix2[0]];
54  s += sq[pix1[1] - pix2[1]];
55  s += sq[pix1[2] - pix2[2]];
56  s += sq[pix1[3] - pix2[3]];
57  s += sq[pix1[4] - pix2[4]];
58  s += sq[pix1[5] - pix2[5]];
59  s += sq[pix1[6] - pix2[6]];
60  s += sq[pix1[7] - pix2[7]];
61  pix1 += line_size;
62  pix2 += line_size;
63  }
64  return s;
65 }
66 
67 static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
68  int line_size, int h)
69 {
70  int s = 0, i;
71  uint32_t *sq = ff_square_tab + 256;
72 
73  for (i = 0; i < h; i++) {
74  s += sq[pix1[0] - pix2[0]];
75  s += sq[pix1[1] - pix2[1]];
76  s += sq[pix1[2] - pix2[2]];
77  s += sq[pix1[3] - pix2[3]];
78  s += sq[pix1[4] - pix2[4]];
79  s += sq[pix1[5] - pix2[5]];
80  s += sq[pix1[6] - pix2[6]];
81  s += sq[pix1[7] - pix2[7]];
82  s += sq[pix1[8] - pix2[8]];
83  s += sq[pix1[9] - pix2[9]];
84  s += sq[pix1[10] - pix2[10]];
85  s += sq[pix1[11] - pix2[11]];
86  s += sq[pix1[12] - pix2[12]];
87  s += sq[pix1[13] - pix2[13]];
88  s += sq[pix1[14] - pix2[14]];
89  s += sq[pix1[15] - pix2[15]];
90 
91  pix1 += line_size;
92  pix2 += line_size;
93  }
94  return s;
95 }
96 
97 static int sum_abs_dctelem_c(int16_t *block)
98 {
99  int sum = 0, i;
100 
101  for (i = 0; i < 64; i++)
102  sum += FFABS(block[i]);
103  return sum;
104 }
105 
106 #define avg2(a, b) ((a + b + 1) >> 1)
107 #define avg4(a, b, c, d) ((a + b + c + d + 2) >> 2)
108 
109 static inline int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
110  int line_size, int h)
111 {
112  int s = 0, i;
113 
114  for (i = 0; i < h; i++) {
115  s += abs(pix1[0] - pix2[0]);
116  s += abs(pix1[1] - pix2[1]);
117  s += abs(pix1[2] - pix2[2]);
118  s += abs(pix1[3] - pix2[3]);
119  s += abs(pix1[4] - pix2[4]);
120  s += abs(pix1[5] - pix2[5]);
121  s += abs(pix1[6] - pix2[6]);
122  s += abs(pix1[7] - pix2[7]);
123  s += abs(pix1[8] - pix2[8]);
124  s += abs(pix1[9] - pix2[9]);
125  s += abs(pix1[10] - pix2[10]);
126  s += abs(pix1[11] - pix2[11]);
127  s += abs(pix1[12] - pix2[12]);
128  s += abs(pix1[13] - pix2[13]);
129  s += abs(pix1[14] - pix2[14]);
130  s += abs(pix1[15] - pix2[15]);
131  pix1 += line_size;
132  pix2 += line_size;
133  }
134  return s;
135 }
136 
137 static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
138  int line_size, int h)
139 {
140  int s = 0, i;
141 
142  for (i = 0; i < h; i++) {
143  s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
144  s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
145  s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
146  s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
147  s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
148  s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
149  s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
150  s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
151  s += abs(pix1[8] - avg2(pix2[8], pix2[9]));
152  s += abs(pix1[9] - avg2(pix2[9], pix2[10]));
153  s += abs(pix1[10] - avg2(pix2[10], pix2[11]));
154  s += abs(pix1[11] - avg2(pix2[11], pix2[12]));
155  s += abs(pix1[12] - avg2(pix2[12], pix2[13]));
156  s += abs(pix1[13] - avg2(pix2[13], pix2[14]));
157  s += abs(pix1[14] - avg2(pix2[14], pix2[15]));
158  s += abs(pix1[15] - avg2(pix2[15], pix2[16]));
159  pix1 += line_size;
160  pix2 += line_size;
161  }
162  return s;
163 }
164 
165 static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
166  int line_size, int h)
167 {
168  int s = 0, i;
169  uint8_t *pix3 = pix2 + line_size;
170 
171  for (i = 0; i < h; i++) {
172  s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
173  s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
174  s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
175  s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
176  s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
177  s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
178  s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
179  s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
180  s += abs(pix1[8] - avg2(pix2[8], pix3[8]));
181  s += abs(pix1[9] - avg2(pix2[9], pix3[9]));
182  s += abs(pix1[10] - avg2(pix2[10], pix3[10]));
183  s += abs(pix1[11] - avg2(pix2[11], pix3[11]));
184  s += abs(pix1[12] - avg2(pix2[12], pix3[12]));
185  s += abs(pix1[13] - avg2(pix2[13], pix3[13]));
186  s += abs(pix1[14] - avg2(pix2[14], pix3[14]));
187  s += abs(pix1[15] - avg2(pix2[15], pix3[15]));
188  pix1 += line_size;
189  pix2 += line_size;
190  pix3 += line_size;
191  }
192  return s;
193 }
194 
195 static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
196  int line_size, int h)
197 {
198  int s = 0, i;
199  uint8_t *pix3 = pix2 + line_size;
200 
201  for (i = 0; i < h; i++) {
202  s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
203  s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
204  s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
205  s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
206  s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
207  s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
208  s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
209  s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
210  s += abs(pix1[8] - avg4(pix2[8], pix2[9], pix3[8], pix3[9]));
211  s += abs(pix1[9] - avg4(pix2[9], pix2[10], pix3[9], pix3[10]));
212  s += abs(pix1[10] - avg4(pix2[10], pix2[11], pix3[10], pix3[11]));
213  s += abs(pix1[11] - avg4(pix2[11], pix2[12], pix3[11], pix3[12]));
214  s += abs(pix1[12] - avg4(pix2[12], pix2[13], pix3[12], pix3[13]));
215  s += abs(pix1[13] - avg4(pix2[13], pix2[14], pix3[13], pix3[14]));
216  s += abs(pix1[14] - avg4(pix2[14], pix2[15], pix3[14], pix3[15]));
217  s += abs(pix1[15] - avg4(pix2[15], pix2[16], pix3[15], pix3[16]));
218  pix1 += line_size;
219  pix2 += line_size;
220  pix3 += line_size;
221  }
222  return s;
223 }
224 
225 static inline int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
226  int line_size, int h)
227 {
228  int s = 0, i;
229 
230  for (i = 0; i < h; i++) {
231  s += abs(pix1[0] - pix2[0]);
232  s += abs(pix1[1] - pix2[1]);
233  s += abs(pix1[2] - pix2[2]);
234  s += abs(pix1[3] - pix2[3]);
235  s += abs(pix1[4] - pix2[4]);
236  s += abs(pix1[5] - pix2[5]);
237  s += abs(pix1[6] - pix2[6]);
238  s += abs(pix1[7] - pix2[7]);
239  pix1 += line_size;
240  pix2 += line_size;
241  }
242  return s;
243 }
244 
245 static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
246  int line_size, int h)
247 {
248  int s = 0, i;
249 
250  for (i = 0; i < h; i++) {
251  s += abs(pix1[0] - avg2(pix2[0], pix2[1]));
252  s += abs(pix1[1] - avg2(pix2[1], pix2[2]));
253  s += abs(pix1[2] - avg2(pix2[2], pix2[3]));
254  s += abs(pix1[3] - avg2(pix2[3], pix2[4]));
255  s += abs(pix1[4] - avg2(pix2[4], pix2[5]));
256  s += abs(pix1[5] - avg2(pix2[5], pix2[6]));
257  s += abs(pix1[6] - avg2(pix2[6], pix2[7]));
258  s += abs(pix1[7] - avg2(pix2[7], pix2[8]));
259  pix1 += line_size;
260  pix2 += line_size;
261  }
262  return s;
263 }
264 
265 static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
266  int line_size, int h)
267 {
268  int s = 0, i;
269  uint8_t *pix3 = pix2 + line_size;
270 
271  for (i = 0; i < h; i++) {
272  s += abs(pix1[0] - avg2(pix2[0], pix3[0]));
273  s += abs(pix1[1] - avg2(pix2[1], pix3[1]));
274  s += abs(pix1[2] - avg2(pix2[2], pix3[2]));
275  s += abs(pix1[3] - avg2(pix2[3], pix3[3]));
276  s += abs(pix1[4] - avg2(pix2[4], pix3[4]));
277  s += abs(pix1[5] - avg2(pix2[5], pix3[5]));
278  s += abs(pix1[6] - avg2(pix2[6], pix3[6]));
279  s += abs(pix1[7] - avg2(pix2[7], pix3[7]));
280  pix1 += line_size;
281  pix2 += line_size;
282  pix3 += line_size;
283  }
284  return s;
285 }
286 
287 static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2,
288  int line_size, int h)
289 {
290  int s = 0, i;
291  uint8_t *pix3 = pix2 + line_size;
292 
293  for (i = 0; i < h; i++) {
294  s += abs(pix1[0] - avg4(pix2[0], pix2[1], pix3[0], pix3[1]));
295  s += abs(pix1[1] - avg4(pix2[1], pix2[2], pix3[1], pix3[2]));
296  s += abs(pix1[2] - avg4(pix2[2], pix2[3], pix3[2], pix3[3]));
297  s += abs(pix1[3] - avg4(pix2[3], pix2[4], pix3[3], pix3[4]));
298  s += abs(pix1[4] - avg4(pix2[4], pix2[5], pix3[4], pix3[5]));
299  s += abs(pix1[5] - avg4(pix2[5], pix2[6], pix3[5], pix3[6]));
300  s += abs(pix1[6] - avg4(pix2[6], pix2[7], pix3[6], pix3[7]));
301  s += abs(pix1[7] - avg4(pix2[7], pix2[8], pix3[7], pix3[8]));
302  pix1 += line_size;
303  pix2 += line_size;
304  pix3 += line_size;
305  }
306  return s;
307 }
308 
309 static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
310 {
311  int score1 = 0, score2 = 0, x, y;
312 
313  for (y = 0; y < h; y++) {
314  for (x = 0; x < 16; x++)
315  score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]);
316  if (y + 1 < h) {
317  for (x = 0; x < 15; x++)
318  score2 += FFABS(s1[x] - s1[x + stride] -
319  s1[x + 1] + s1[x + stride + 1]) -
320  FFABS(s2[x] - s2[x + stride] -
321  s2[x + 1] + s2[x + stride + 1]);
322  }
323  s1 += stride;
324  s2 += stride;
325  }
326 
327  if (c)
328  return score1 + FFABS(score2) * c->avctx->nsse_weight;
329  else
330  return score1 + FFABS(score2) * 8;
331 }
332 
333 static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
334 {
335  int score1 = 0, score2 = 0, x, y;
336 
337  for (y = 0; y < h; y++) {
338  for (x = 0; x < 8; x++)
339  score1 += (s1[x] - s2[x]) * (s1[x] - s2[x]);
340  if (y + 1 < h) {
341  for (x = 0; x < 7; x++)
342  score2 += FFABS(s1[x] - s1[x + stride] -
343  s1[x + 1] + s1[x + stride + 1]) -
344  FFABS(s2[x] - s2[x + stride] -
345  s2[x + 1] + s2[x + stride + 1]);
346  }
347  s1 += stride;
348  s2 += stride;
349  }
350 
351  if (c)
352  return score1 + FFABS(score2) * c->avctx->nsse_weight;
353  else
354  return score1 + FFABS(score2) * 8;
355 }
356 
358  int stride, int h)
359 {
360  return 0;
361 }
362 
364 {
365  int i;
366 
367  memset(cmp, 0, sizeof(void *) * 6);
368 
369  for (i = 0; i < 6; i++) {
370  switch (type & 0xFF) {
371  case FF_CMP_SAD:
372  cmp[i] = c->sad[i];
373  break;
374  case FF_CMP_SATD:
375  cmp[i] = c->hadamard8_diff[i];
376  break;
377  case FF_CMP_SSE:
378  cmp[i] = c->sse[i];
379  break;
380  case FF_CMP_DCT:
381  cmp[i] = c->dct_sad[i];
382  break;
383  case FF_CMP_DCT264:
384  cmp[i] = c->dct264_sad[i];
385  break;
386  case FF_CMP_DCTMAX:
387  cmp[i] = c->dct_max[i];
388  break;
389  case FF_CMP_PSNR:
390  cmp[i] = c->quant_psnr[i];
391  break;
392  case FF_CMP_BIT:
393  cmp[i] = c->bit[i];
394  break;
395  case FF_CMP_RD:
396  cmp[i] = c->rd[i];
397  break;
398  case FF_CMP_VSAD:
399  cmp[i] = c->vsad[i];
400  break;
401  case FF_CMP_VSSE:
402  cmp[i] = c->vsse[i];
403  break;
404  case FF_CMP_ZERO:
405  cmp[i] = zero_cmp;
406  break;
407  case FF_CMP_NSSE:
408  cmp[i] = c->nsse[i];
409  break;
410  default:
412  "internal error in cmp function selection\n");
413  }
414  }
415 }
416 
417 #define BUTTERFLY2(o1, o2, i1, i2) \
418  o1 = (i1) + (i2); \
419  o2 = (i1) - (i2);
420 
421 #define BUTTERFLY1(x, y) \
422  { \
423  int a, b; \
424  a = x; \
425  b = y; \
426  x = a + b; \
427  y = a - b; \
428  }
429 
430 #define BUTTERFLYA(x, y) (FFABS((x) + (y)) + FFABS((x) - (y)))
431 
433  uint8_t *src, int stride, int h)
434 {
435  int i, temp[64], sum = 0;
436 
437  assert(h == 8);
438 
439  for (i = 0; i < 8; i++) {
440  // FIXME: try pointer walks
441  BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
442  src[stride * i + 0] - dst[stride * i + 0],
443  src[stride * i + 1] - dst[stride * i + 1]);
444  BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
445  src[stride * i + 2] - dst[stride * i + 2],
446  src[stride * i + 3] - dst[stride * i + 3]);
447  BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
448  src[stride * i + 4] - dst[stride * i + 4],
449  src[stride * i + 5] - dst[stride * i + 5]);
450  BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
451  src[stride * i + 6] - dst[stride * i + 6],
452  src[stride * i + 7] - dst[stride * i + 7]);
453 
454  BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
455  BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
456  BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
457  BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
458 
459  BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
460  BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
461  BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
462  BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
463  }
464 
465  for (i = 0; i < 8; i++) {
466  BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
467  BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
468  BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
469  BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
470 
471  BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
472  BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
473  BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
474  BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
475 
476  sum += BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i]) +
477  BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i]) +
478  BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i]) +
479  BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
480  }
481  return sum;
482 }
483 
485  uint8_t *dummy, int stride, int h)
486 {
487  int i, temp[64], sum = 0;
488 
489  assert(h == 8);
490 
491  for (i = 0; i < 8; i++) {
492  // FIXME: try pointer walks
493  BUTTERFLY2(temp[8 * i + 0], temp[8 * i + 1],
494  src[stride * i + 0], src[stride * i + 1]);
495  BUTTERFLY2(temp[8 * i + 2], temp[8 * i + 3],
496  src[stride * i + 2], src[stride * i + 3]);
497  BUTTERFLY2(temp[8 * i + 4], temp[8 * i + 5],
498  src[stride * i + 4], src[stride * i + 5]);
499  BUTTERFLY2(temp[8 * i + 6], temp[8 * i + 7],
500  src[stride * i + 6], src[stride * i + 7]);
501 
502  BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 2]);
503  BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 3]);
504  BUTTERFLY1(temp[8 * i + 4], temp[8 * i + 6]);
505  BUTTERFLY1(temp[8 * i + 5], temp[8 * i + 7]);
506 
507  BUTTERFLY1(temp[8 * i + 0], temp[8 * i + 4]);
508  BUTTERFLY1(temp[8 * i + 1], temp[8 * i + 5]);
509  BUTTERFLY1(temp[8 * i + 2], temp[8 * i + 6]);
510  BUTTERFLY1(temp[8 * i + 3], temp[8 * i + 7]);
511  }
512 
513  for (i = 0; i < 8; i++) {
514  BUTTERFLY1(temp[8 * 0 + i], temp[8 * 1 + i]);
515  BUTTERFLY1(temp[8 * 2 + i], temp[8 * 3 + i]);
516  BUTTERFLY1(temp[8 * 4 + i], temp[8 * 5 + i]);
517  BUTTERFLY1(temp[8 * 6 + i], temp[8 * 7 + i]);
518 
519  BUTTERFLY1(temp[8 * 0 + i], temp[8 * 2 + i]);
520  BUTTERFLY1(temp[8 * 1 + i], temp[8 * 3 + i]);
521  BUTTERFLY1(temp[8 * 4 + i], temp[8 * 6 + i]);
522  BUTTERFLY1(temp[8 * 5 + i], temp[8 * 7 + i]);
523 
524  sum +=
525  BUTTERFLYA(temp[8 * 0 + i], temp[8 * 4 + i])
526  + BUTTERFLYA(temp[8 * 1 + i], temp[8 * 5 + i])
527  + BUTTERFLYA(temp[8 * 2 + i], temp[8 * 6 + i])
528  + BUTTERFLYA(temp[8 * 3 + i], temp[8 * 7 + i]);
529  }
530 
531  sum -= FFABS(temp[8 * 0] + temp[8 * 4]); // -mean
532 
533  return sum;
534 }
535 
536 static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1,
537  uint8_t *src2, int stride, int h)
538 {
539  LOCAL_ALIGNED_16(int16_t, temp, [64]);
540 
541  assert(h == 8);
542 
543  s->pdsp.diff_pixels(temp, src1, src2, stride);
544  s->fdsp.fdct(temp);
545  return s->mecc.sum_abs_dctelem(temp);
546 }
547 
548 #if CONFIG_GPL
549 #define DCT8_1D \
550  { \
551  const int s07 = SRC(0) + SRC(7); \
552  const int s16 = SRC(1) + SRC(6); \
553  const int s25 = SRC(2) + SRC(5); \
554  const int s34 = SRC(3) + SRC(4); \
555  const int a0 = s07 + s34; \
556  const int a1 = s16 + s25; \
557  const int a2 = s07 - s34; \
558  const int a3 = s16 - s25; \
559  const int d07 = SRC(0) - SRC(7); \
560  const int d16 = SRC(1) - SRC(6); \
561  const int d25 = SRC(2) - SRC(5); \
562  const int d34 = SRC(3) - SRC(4); \
563  const int a4 = d16 + d25 + (d07 + (d07 >> 1)); \
564  const int a5 = d07 - d34 - (d25 + (d25 >> 1)); \
565  const int a6 = d07 + d34 - (d16 + (d16 >> 1)); \
566  const int a7 = d16 - d25 + (d34 + (d34 >> 1)); \
567  DST(0, a0 + a1); \
568  DST(1, a4 + (a7 >> 2)); \
569  DST(2, a2 + (a3 >> 1)); \
570  DST(3, a5 + (a6 >> 2)); \
571  DST(4, a0 - a1); \
572  DST(5, a6 - (a5 >> 2)); \
573  DST(6, (a2 >> 1) - a3); \
574  DST(7, (a4 >> 2) - a7); \
575  }
576 
577 static int dct264_sad8x8_c(MpegEncContext *s, uint8_t *src1,
578  uint8_t *src2, int stride, int h)
579 {
580  int16_t dct[8][8];
581  int i, sum = 0;
582 
583  s->pdsp.diff_pixels(dct[0], src1, src2, stride);
584 
585 #define SRC(x) dct[i][x]
586 #define DST(x, v) dct[i][x] = v
587  for (i = 0; i < 8; i++)
588  DCT8_1D
589 #undef SRC
590 #undef DST
591 
592 #define SRC(x) dct[x][i]
593 #define DST(x, v) sum += FFABS(v)
594  for (i = 0; i < 8; i++)
595  DCT8_1D
596 #undef SRC
597 #undef DST
598  return sum;
599 }
600 #endif
601 
602 static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1,
603  uint8_t *src2, int stride, int h)
604 {
605  LOCAL_ALIGNED_16(int16_t, temp, [64]);
606  int sum = 0, i;
607 
608  assert(h == 8);
609 
610  s->pdsp.diff_pixels(temp, src1, src2, stride);
611  s->fdsp.fdct(temp);
612 
613  for (i = 0; i < 64; i++)
614  sum = FFMAX(sum, FFABS(temp[i]));
615 
616  return sum;
617 }
618 
620  uint8_t *src2, int stride, int h)
621 {
622  LOCAL_ALIGNED_16(int16_t, temp, [64 * 2]);
623  int16_t *const bak = temp + 64;
624  int sum = 0, i;
625 
626  assert(h == 8);
627  s->mb_intra = 0;
628 
629  s->pdsp.diff_pixels(temp, src1, src2, stride);
630 
631  memcpy(bak, temp, 64 * sizeof(int16_t));
632 
633  s->block_last_index[0 /* FIXME */] =
634  s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
635  s->dct_unquantize_inter(s, temp, 0, s->qscale);
636  ff_simple_idct_8(temp); // FIXME
637 
638  for (i = 0; i < 64; i++)
639  sum += (temp[i] - bak[i]) * (temp[i] - bak[i]);
640 
641  return sum;
642 }
643 
644 static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
645  int stride, int h)
646 {
647  const uint8_t *scantable = s->intra_scantable.permutated;
648  LOCAL_ALIGNED_16(int16_t, temp, [64]);
649  LOCAL_ALIGNED_16(uint8_t, lsrc1, [64]);
650  LOCAL_ALIGNED_16(uint8_t, lsrc2, [64]);
651  int i, last, run, bits, level, distortion, start_i;
652  const int esc_length = s->ac_esc_length;
653  uint8_t *length, *last_length;
654 
655  assert(h == 8);
656 
657  copy_block8(lsrc1, src1, 8, stride, 8);
658  copy_block8(lsrc2, src2, 8, stride, 8);
659 
660  s->pdsp.diff_pixels(temp, lsrc1, lsrc2, 8);
661 
662  s->block_last_index[0 /* FIXME */] =
663  last =
664  s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
665 
666  bits = 0;
667 
668  if (s->mb_intra) {
669  start_i = 1;
670  length = s->intra_ac_vlc_length;
671  last_length = s->intra_ac_vlc_last_length;
672  bits += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
673  } else {
674  start_i = 0;
675  length = s->inter_ac_vlc_length;
676  last_length = s->inter_ac_vlc_last_length;
677  }
678 
679  if (last >= start_i) {
680  run = 0;
681  for (i = start_i; i < last; i++) {
682  int j = scantable[i];
683  level = temp[j];
684 
685  if (level) {
686  level += 64;
687  if ((level & (~127)) == 0)
688  bits += length[UNI_AC_ENC_INDEX(run, level)];
689  else
690  bits += esc_length;
691  run = 0;
692  } else
693  run++;
694  }
695  i = scantable[last];
696 
697  level = temp[i] + 64;
698 
699  assert(level - 64);
700 
701  if ((level & (~127)) == 0) {
702  bits += last_length[UNI_AC_ENC_INDEX(run, level)];
703  } else
704  bits += esc_length;
705  }
706 
707  if (last >= 0) {
708  if (s->mb_intra)
709  s->dct_unquantize_intra(s, temp, 0, s->qscale);
710  else
711  s->dct_unquantize_inter(s, temp, 0, s->qscale);
712  }
713 
714  s->idsp.idct_add(lsrc2, 8, temp);
715 
716  distortion = s->mecc.sse[1](NULL, lsrc2, lsrc1, 8, 8);
717 
718  return distortion + ((bits * s->qscale * s->qscale * 109 + 64) >> 7);
719 }
720 
721 static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2,
722  int stride, int h)
723 {
724  const uint8_t *scantable = s->intra_scantable.permutated;
725  LOCAL_ALIGNED_16(int16_t, temp, [64]);
726  int i, last, run, bits, level, start_i;
727  const int esc_length = s->ac_esc_length;
728  uint8_t *length, *last_length;
729 
730  assert(h == 8);
731 
732  s->pdsp.diff_pixels(temp, src1, src2, stride);
733 
734  s->block_last_index[0 /* FIXME */] =
735  last =
736  s->fast_dct_quantize(s, temp, 0 /* FIXME */, s->qscale, &i);
737 
738  bits = 0;
739 
740  if (s->mb_intra) {
741  start_i = 1;
742  length = s->intra_ac_vlc_length;
743  last_length = s->intra_ac_vlc_last_length;
744  bits += s->luma_dc_vlc_length[temp[0] + 256]; // FIXME: chroma
745  } else {
746  start_i = 0;
747  length = s->inter_ac_vlc_length;
748  last_length = s->inter_ac_vlc_last_length;
749  }
750 
751  if (last >= start_i) {
752  run = 0;
753  for (i = start_i; i < last; i++) {
754  int j = scantable[i];
755  level = temp[j];
756 
757  if (level) {
758  level += 64;
759  if ((level & (~127)) == 0)
760  bits += length[UNI_AC_ENC_INDEX(run, level)];
761  else
762  bits += esc_length;
763  run = 0;
764  } else
765  run++;
766  }
767  i = scantable[last];
768 
769  level = temp[i] + 64;
770 
771  assert(level - 64);
772 
773  if ((level & (~127)) == 0)
774  bits += last_length[UNI_AC_ENC_INDEX(run, level)];
775  else
776  bits += esc_length;
777  }
778 
779  return bits;
780 }
781 
782 #define VSAD_INTRA(size) \
783 static int vsad_intra ## size ## _c(MpegEncContext *c, \
784  uint8_t *s, uint8_t *dummy, \
785  int stride, int h) \
786 { \
787  int score = 0, x, y; \
788  \
789  for (y = 1; y < h; y++) { \
790  for (x = 0; x < size; x += 4) { \
791  score += FFABS(s[x] - s[x + stride]) + \
792  FFABS(s[x + 1] - s[x + stride + 1]) + \
793  FFABS(s[x + 2] - s[x + 2 + stride]) + \
794  FFABS(s[x + 3] - s[x + 3 + stride]); \
795  } \
796  s += stride; \
797  } \
798  \
799  return score; \
800 }
801 VSAD_INTRA(8)
802 VSAD_INTRA(16)
803 
804 static int vsad16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
805  int stride, int h)
806 {
807  int score = 0, x, y;
808 
809  for (y = 1; y < h; y++) {
810  for (x = 0; x < 16; x++)
811  score += FFABS(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);
812  s1 += stride;
813  s2 += stride;
814  }
815 
816  return score;
817 }
818 
819 #define SQ(a) ((a) * (a))
820 #define VSSE_INTRA(size) \
821 static int vsse_intra ## size ## _c(MpegEncContext *c, \
822  uint8_t *s, uint8_t *dummy, \
823  int stride, int h) \
824 { \
825  int score = 0, x, y; \
826  \
827  for (y = 1; y < h; y++) { \
828  for (x = 0; x < size; x += 4) { \
829  score += SQ(s[x] - s[x + stride]) + \
830  SQ(s[x + 1] - s[x + stride + 1]) + \
831  SQ(s[x + 2] - s[x + stride + 2]) + \
832  SQ(s[x + 3] - s[x + stride + 3]); \
833  } \
834  s += stride; \
835  } \
836  \
837  return score; \
838 }
839 VSSE_INTRA(8)
840 VSSE_INTRA(16)
841 
842 static int vsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2,
843  int stride, int h)
844 {
845  int score = 0, x, y;
846 
847  for (y = 1; y < h; y++) {
848  for (x = 0; x < 16; x++)
849  score += SQ(s1[x] - s2[x] - s1[x + stride] + s2[x + stride]);
850  s1 += stride;
851  s2 += stride;
852  }
853 
854  return score;
855 }
856 
857 #define WRAPPER8_16_SQ(name8, name16) \
858 static int name16(MpegEncContext *s, uint8_t *dst, uint8_t *src, \
859  int stride, int h) \
860 { \
861  int score = 0; \
862  \
863  score += name8(s, dst, src, stride, 8); \
864  score += name8(s, dst + 8, src + 8, stride, 8); \
865  if (h == 16) { \
866  dst += 8 * stride; \
867  src += 8 * stride; \
868  score += name8(s, dst, src, stride, 8); \
869  score += name8(s, dst + 8, src + 8, stride, 8); \
870  } \
871  return score; \
872 }
873 
874 WRAPPER8_16_SQ(hadamard8_diff8x8_c, hadamard8_diff16_c)
875 WRAPPER8_16_SQ(hadamard8_intra8x8_c, hadamard8_intra16_c)
876 WRAPPER8_16_SQ(dct_sad8x8_c, dct_sad16_c)
877 #if CONFIG_GPL
878 WRAPPER8_16_SQ(dct264_sad8x8_c, dct264_sad16_c)
879 #endif
880 WRAPPER8_16_SQ(dct_max8x8_c, dct_max16_c)
881 WRAPPER8_16_SQ(quant_psnr8x8_c, quant_psnr16_c)
882 WRAPPER8_16_SQ(rd8x8_c, rd16_c)
883 WRAPPER8_16_SQ(bit8x8_c, bit16_c)
884 
886 {
887  int i;
888 
889  for (i = 0; i < 512; i++)
890  ff_square_tab[i] = (i - 256) * (i - 256);
891 }
892 
894 {
896 
897  /* TODO [0] 16 [1] 8 */
898  c->pix_abs[0][0] = pix_abs16_c;
899  c->pix_abs[0][1] = pix_abs16_x2_c;
900  c->pix_abs[0][2] = pix_abs16_y2_c;
901  c->pix_abs[0][3] = pix_abs16_xy2_c;
902  c->pix_abs[1][0] = pix_abs8_c;
903  c->pix_abs[1][1] = pix_abs8_x2_c;
904  c->pix_abs[1][2] = pix_abs8_y2_c;
905  c->pix_abs[1][3] = pix_abs8_xy2_c;
906 
907 #define SET_CMP_FUNC(name) \
908  c->name[0] = name ## 16_c; \
909  c->name[1] = name ## 8x8_c;
910 
911  SET_CMP_FUNC(hadamard8_diff)
912  c->hadamard8_diff[4] = hadamard8_intra16_c;
914  SET_CMP_FUNC(dct_sad)
915  SET_CMP_FUNC(dct_max)
916 #if CONFIG_GPL
917  SET_CMP_FUNC(dct264_sad)
918 #endif
919  c->sad[0] = pix_abs16_c;
920  c->sad[1] = pix_abs8_c;
921  c->sse[0] = sse16_c;
922  c->sse[1] = sse8_c;
923  c->sse[2] = sse4_c;
924  SET_CMP_FUNC(quant_psnr)
925  SET_CMP_FUNC(rd)
926  SET_CMP_FUNC(bit)
927  c->vsad[0] = vsad16_c;
928  c->vsad[4] = vsad_intra16_c;
929  c->vsad[5] = vsad_intra8_c;
930  c->vsse[0] = vsse16_c;
931  c->vsse[4] = vsse_intra16_c;
932  c->vsse[5] = vsse_intra8_c;
933  c->nsse[0] = nsse16_c;
934  c->nsse[1] = nsse8_c;
935 
936  if (ARCH_ARM)
937  ff_me_cmp_init_arm(c, avctx);
938  if (ARCH_PPC)
939  ff_me_cmp_init_ppc(c, avctx);
940  if (ARCH_X86)
941  ff_me_cmp_init_x86(c, avctx);
942 }
#define avg4(a, b, c, d)
Definition: me_cmp.c:107
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:893
static int pix_abs16_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:137
av_cold void ff_me_cmp_init_ppc(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:747
IDCTDSPContext idsp
Definition: mpegvideo.h:354
#define ARCH_ARM
Definition: config.h:14
int(* sum_abs_dctelem)(int16_t *block)
Definition: me_cmp.h:39
#define FF_CMP_DCTMAX
Definition: avcodec.h:1482
static int nsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
Definition: me_cmp.c:309
#define BUTTERFLY1(x, y)
Definition: me_cmp.c:421
me_cmp_func dct_max[6]
Definition: me_cmp.h:51
#define ARCH_X86
Definition: config.h:33
static int dct_sad8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int stride, int h)
Definition: me_cmp.c:536
mpegvideo header.
void(* idct_add)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> add dest -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:77
uint8_t permutated[64]
Definition: idctdsp.h:31
uint8_t run
Definition: svq3.c:146
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:432
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:437
int stride
Definition: mace.c:144
int qscale
QP.
Definition: mpegvideo.h:332
me_cmp_func dct_sad[6]
Definition: me_cmp.h:44
int(* me_cmp_func)(struct MpegEncContext *c, uint8_t *blk1, uint8_t *blk2, int line_size, int h)
Definition: me_cmp.h:34
uint32_t ff_square_tab[512]
Definition: me_cmp.c:27
Macro definitions for various function/variable attributes.
me_cmp_func hadamard8_diff[6]
Definition: me_cmp.h:43
static int quant_psnr8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int stride, int h)
Definition: me_cmp.c:619
static int pix_abs8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:225
static int sse16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:67
uint8_t bits
Definition: crc.c:251
uint8_t
#define av_cold
Definition: attributes.h:66
#define SET_CMP_FUNC(name)
#define b
Definition: input.c:52
#define FF_CMP_VSSE
Definition: avcodec.h:1480
me_cmp_func dct264_sad[6]
Definition: me_cmp.h:52
void(* diff_pixels)(int16_t *block, const uint8_t *s1, const uint8_t *s2, int stride)
Definition: pixblockdsp.h:30
me_cmp_func nsse[6]
Definition: me_cmp.h:50
#define BUTTERFLY2(o1, o2, i1, i2)
Definition: me_cmp.c:417
#define avg2(a, b)
Definition: me_cmp.c:106
static int vsse16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
Definition: me_cmp.c:842
#define FF_CMP_SSE
Definition: avcodec.h:1472
static int pix_abs8_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:287
static int hadamard8_intra8x8_c(MpegEncContext *s, uint8_t *src, uint8_t *dummy, int stride, int h)
Definition: me_cmp.c:484
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
static int sse8_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:46
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:435
static int dct_max8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int stride, int h)
Definition: me_cmp.c:602
static int nsse8_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
Definition: me_cmp.c:333
PixblockDSPContext pdsp
Definition: mpegvideo.h:358
static int vsad16_c(MpegEncContext *c, uint8_t *s1, uint8_t *s2, int stride, int h)
Definition: me_cmp.c:804
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
me_cmp_func pix_abs[2][4]
Definition: me_cmp.h:61
#define FFMAX(a, b)
Definition: common.h:55
av_cold void ff_me_cmp_init_static(void)
Definition: me_cmp.c:885
me_cmp_func bit[6]
Definition: me_cmp.h:46
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:433
me_cmp_func vsse[6]
Definition: me_cmp.h:49
#define FF_CMP_BIT
Definition: avcodec.h:1476
static int pix_abs8_x2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:245
me_cmp_func vsad[6]
Definition: me_cmp.h:48
#define FFABS(a)
Definition: common.h:52
void(* dct_unquantize_inter)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:622
#define WRAPPER8_16_SQ(name8, name16)
Definition: me_cmp.c:857
void(* dct_unquantize_intra)(struct MpegEncContext *s, int16_t *block, int n, int qscale)
Definition: mpegvideo.h:620
static av_always_inline int cmp(MpegEncContext *s, const int x, const int y, const int subx, const int suby, const int size, const int h, int ref_index, int src_index, me_cmp_func cmp_func, me_cmp_func chroma_cmp_func, const int flags)
compares a block (either a full macroblock or a partition thereof) against a proposed motion-compensa...
Definition: motion_est.c:255
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:209
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
static int zero_cmp(MpegEncContext *s, uint8_t *a, uint8_t *b, int stride, int h)
Definition: me_cmp.c:357
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:431
#define FF_CMP_SAD
Definition: avcodec.h:1471
NULL
Definition: eval.c:55
uint8_t * luma_dc_vlc_length
Definition: mpegvideo.h:436
me_cmp_func rd[6]
Definition: me_cmp.h:47
Libavcodec external API header.
static int bit8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int stride, int h)
Definition: me_cmp.c:721
#define FF_CMP_RD
Definition: avcodec.h:1477
void ff_set_cmp(MECmpContext *c, me_cmp_func *cmp, int type)
Definition: me_cmp.c:363
main external API structure.
Definition: avcodec.h:1050
ScanTable intra_scantable
Definition: mpegvideo.h:214
#define FF_CMP_NSSE
Definition: avcodec.h:1481
static int pix_abs8_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:265
#define FF_CMP_SATD
Definition: avcodec.h:1473
FDCTDSPContext fdsp
Definition: mpegvideo.h:352
#define VSSE_INTRA(size)
Definition: me_cmp.c:820
#define FF_CMP_DCT
Definition: avcodec.h:1474
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:434
av_cold void ff_me_cmp_init_arm(MECmpContext *c, AVCodecContext *avctx)
#define FF_CMP_PSNR
Definition: avcodec.h:1475
#define FF_CMP_DCT264
Definition: avcodec.h:1483
static int pix_abs16_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:109
static int hadamard8_diff8x8_c(MpegEncContext *s, uint8_t *dst, uint8_t *src, int stride, int h)
Definition: me_cmp.c:432
#define SQ(a)
Definition: me_cmp.c:819
#define ARCH_PPC
Definition: config.h:24
uint8_t level
Definition: svq3.c:147
me_cmp_func sad[6]
Definition: me_cmp.h:41
me_cmp_func sse[6]
Definition: me_cmp.h:42
#define FF_CMP_ZERO
Definition: avcodec.h:1478
MpegEncContext.
Definition: mpegvideo.h:204
struct AVCodecContext * avctx
Definition: mpegvideo.h:221
static int sse4_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:29
int(* fast_dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:625
MECmpContext mecc
Definition: mpegvideo.h:355
static int pix_abs16_xy2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:195
int nsse_weight
noise vs.
Definition: avcodec.h:2631
#define BUTTERFLYA(x, y)
Definition: me_cmp.c:430
#define FF_CMP_VSAD
Definition: avcodec.h:1479
static int sum_abs_dctelem_c(int16_t *block)
Definition: me_cmp.c:97
simple idct header.
me_cmp_func quant_psnr[6]
Definition: me_cmp.h:45
static void copy_block8(uint8_t *dst, const uint8_t *src, int dstStride, int srcStride, int h)
Definition: copy_block.h:36
static int rd8x8_c(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int stride, int h)
Definition: me_cmp.c:644
#define DST(x, y)
Definition: vp9dsp.c:593
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:114
void ff_me_cmp_init_x86(MECmpContext *c, AVCodecContext *avctx)
static int pix_abs16_y2_c(MpegEncContext *v, uint8_t *pix1, uint8_t *pix2, int line_size, int h)
Definition: me_cmp.c:165
#define VSAD_INTRA(size)
Definition: me_cmp.c:782
void ff_simple_idct_8(int16_t *block)
#define SRC(x, y)
static int16_t block[64]
Definition: dct-test.c:88