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