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