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