doc/filters: itemize unsharp examples
[ffmpeg.git] / libavcodec / dct-test.c
1 /*
2  * (c) 2001 Fabrice Bellard
3  *     2007 Marc Hoffman <marc.hoffman@analog.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * DCT test (c) 2001 Fabrice Bellard
25  * Started from sample code by Juan J. Sierralta P.
26  */
27
28 #include "config.h"
29 #include <stdlib.h>
30 #include <stdio.h>
31 #include <string.h>
32 #if HAVE_UNISTD_H
33 #include <unistd.h>
34 #endif
35 #include <math.h>
36
37 #include "libavutil/cpu.h"
38 #include "libavutil/common.h"
39 #include "libavutil/lfg.h"
40 #include "libavutil/time.h"
41
42 #include "dct.h"
43 #include "simple_idct.h"
44 #include "aandcttab.h"
45 #include "faandct.h"
46 #include "faanidct.h"
47 #include "x86/idct_xvid.h"
48 #include "dctref.h"
49
50 #undef printf
51
52 void ff_mmx_idct(int16_t *data);
53 void ff_mmxext_idct(int16_t *data);
54
55 // BFIN
56 void ff_bfin_idct(int16_t *block);
57 void ff_bfin_fdct(int16_t *block);
58
59 // ALTIVEC
60 void ff_fdct_altivec(int16_t *block);
61
62 // ARM
63 void ff_j_rev_dct_arm(int16_t *data);
64 void ff_simple_idct_arm(int16_t *data);
65 void ff_simple_idct_armv5te(int16_t *data);
66 void ff_simple_idct_armv6(int16_t *data);
67 void ff_simple_idct_neon(int16_t *data);
68
69 void ff_simple_idct_axp(int16_t *data);
70
71 struct algo {
72     const char *name;
73     void (*func)(int16_t *block);
74     enum formattag { NO_PERM, MMX_PERM, MMX_SIMPLE_PERM, SCALE_PERM,
75                      SSE2_PERM, PARTTRANS_PERM, TRANSPOSE_PERM } format;
76     int mm_support;
77     int nonspec;
78 };
79
80 static int cpu_flags;
81
82 static const struct algo fdct_tab[] = {
83     { "REF-DBL",        ff_ref_fdct,           NO_PERM    },
84     { "FAAN",           ff_faandct,            NO_PERM    },
85     { "IJG-AAN-INT",    ff_fdct_ifast,         SCALE_PERM },
86     { "IJG-LLM-INT",    ff_jpeg_fdct_islow_8,  NO_PERM    },
87
88 #if HAVE_MMX_INLINE
89     { "MMX",            ff_fdct_mmx,           NO_PERM,   AV_CPU_FLAG_MMX     },
90     { "MMXEXT",         ff_fdct_mmxext,        NO_PERM,   AV_CPU_FLAG_MMXEXT  },
91     { "SSE2",           ff_fdct_sse2,          NO_PERM,   AV_CPU_FLAG_SSE2    },
92 #endif
93
94 #if HAVE_ALTIVEC
95     { "altivecfdct",    ff_fdct_altivec,       NO_PERM,   AV_CPU_FLAG_ALTIVEC },
96 #endif
97
98 #if ARCH_BFIN
99     { "BFINfdct",       ff_bfin_fdct,          NO_PERM  },
100 #endif
101
102     { 0 }
103 };
104
105 #if ARCH_X86_64 && HAVE_MMX && HAVE_YASM
106 void ff_prores_idct_put_10_sse2(uint16_t *dst, int linesize,
107                                 int16_t *block, int16_t *qmat);
108
109 static void ff_prores_idct_put_10_sse2_wrap(int16_t *dst){
110     DECLARE_ALIGNED(16, static int16_t, qmat)[64];
111     DECLARE_ALIGNED(16, static int16_t, tmp)[64];
112     int i;
113
114     for(i=0; i<64; i++){
115         qmat[i]=4;
116         tmp[i]= dst[i];
117     }
118     ff_prores_idct_put_10_sse2(dst, 16, tmp, qmat);
119 }
120 #endif
121
122 static const struct algo idct_tab[] = {
123     { "FAANI",          ff_faanidct,           NO_PERM  },
124     { "REF-DBL",        ff_ref_idct,           NO_PERM  },
125     { "INT",            ff_j_rev_dct,          MMX_PERM },
126     { "SIMPLE-C",       ff_simple_idct_8,      NO_PERM  },
127
128 #if HAVE_MMX_INLINE
129 #if CONFIG_GPL
130     { "LIBMPEG2-MMX",   ff_mmx_idct,           MMX_PERM,  AV_CPU_FLAG_MMX,  1 },
131     { "LIBMPEG2-MMX2",  ff_mmxext_idct,        MMX_PERM,  AV_CPU_FLAG_MMX2, 1 },
132 #endif
133     { "SIMPLE-MMX",     ff_simple_idct_mmx,  MMX_SIMPLE_PERM, AV_CPU_FLAG_MMX },
134     { "XVID-MMX",       ff_idct_xvid_mmx,      NO_PERM,   AV_CPU_FLAG_MMX,  1 },
135     { "XVID-MMXEXT",    ff_idct_xvid_mmxext,   NO_PERM,   AV_CPU_FLAG_MMXEXT, 1 },
136     { "XVID-SSE2",      ff_idct_xvid_sse2,     SSE2_PERM, AV_CPU_FLAG_SSE2, 1 },
137 #if ARCH_X86_64 && HAVE_YASM
138     { "PR-SSE2",        ff_prores_idct_put_10_sse2_wrap,     TRANSPOSE_PERM, AV_CPU_FLAG_SSE2, 1 },
139 #endif
140 #endif
141
142 #if ARCH_BFIN
143     { "BFINidct",       ff_bfin_idct,          NO_PERM  },
144 #endif
145
146 #if ARCH_ARM
147     { "SIMPLE-ARM",     ff_simple_idct_arm,    NO_PERM  },
148     { "INT-ARM",        ff_j_rev_dct_arm,      MMX_PERM },
149 #endif
150 #if HAVE_ARMV5TE
151     { "SIMPLE-ARMV5TE", ff_simple_idct_armv5te,NO_PERM,   AV_CPU_FLAG_ARMV5TE },
152 #endif
153 #if HAVE_ARMV6
154     { "SIMPLE-ARMV6",   ff_simple_idct_armv6,  MMX_PERM,  AV_CPU_FLAG_ARMV6   },
155 #endif
156 #if HAVE_NEON
157     { "SIMPLE-NEON",    ff_simple_idct_neon, PARTTRANS_PERM, AV_CPU_FLAG_NEON },
158 #endif
159
160 #if ARCH_ALPHA
161     { "SIMPLE-ALPHA",   ff_simple_idct_axp,    NO_PERM },
162 #endif
163
164     { 0 }
165 };
166
167 #define AANSCALE_BITS 12
168
169 #define NB_ITS 20000
170 #define NB_ITS_SPEED 50000
171
172 static short idct_mmx_perm[64];
173
174 static short idct_simple_mmx_perm[64] = {
175     0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
176     0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
177     0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
178     0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
179     0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
180     0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
181     0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
182     0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
183 };
184
185 static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };
186
187 static void idct_mmx_init(void)
188 {
189     int i;
190
191     /* the mmx/mmxext idct uses a reordered input, so we patch scan tables */
192     for (i = 0; i < 64; i++) {
193         idct_mmx_perm[i] = (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
194     }
195 }
196
197 DECLARE_ALIGNED(16, static int16_t, block)[64];
198 DECLARE_ALIGNED(8,  static int16_t, block1)[64];
199
200 static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
201 {
202     int i, j;
203
204     memset(block, 0, 64 * sizeof(*block));
205
206     switch (test) {
207     case 0:
208         for (i = 0; i < 64; i++)
209             block[i] = (av_lfg_get(prng) % (2*vals)) -vals;
210         if (is_idct) {
211             ff_ref_fdct(block);
212             for (i = 0; i < 64; i++)
213                 block[i] >>= 3;
214         }
215         break;
216     case 1:
217         j = av_lfg_get(prng) % 10 + 1;
218         for (i = 0; i < j; i++) {
219             int idx = av_lfg_get(prng) % 64;
220             block[idx] = av_lfg_get(prng) % (2*vals) -vals;
221         }
222         break;
223     case 2:
224         block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals);
225         block[63] = (block[0] & 1) ^ 1;
226         break;
227     }
228 }
229
230 static void permute(int16_t dst[64], const int16_t src[64], int perm)
231 {
232     int i;
233
234     if (perm == MMX_PERM) {
235         for (i = 0; i < 64; i++)
236             dst[idct_mmx_perm[i]] = src[i];
237     } else if (perm == MMX_SIMPLE_PERM) {
238         for (i = 0; i < 64; i++)
239             dst[idct_simple_mmx_perm[i]] = src[i];
240     } else if (perm == SSE2_PERM) {
241         for (i = 0; i < 64; i++)
242             dst[(i & 0x38) | idct_sse2_row_perm[i & 7]] = src[i];
243     } else if (perm == PARTTRANS_PERM) {
244         for (i = 0; i < 64; i++)
245             dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
246     } else if (perm == TRANSPOSE_PERM) {
247         for (i = 0; i < 64; i++)
248             dst[(i>>3) | ((i<<3)&0x38)] = src[i];
249     } else {
250         for (i = 0; i < 64; i++)
251             dst[i] = src[i];
252     }
253 }
254
255 static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
256 {
257     void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
258     int it, i, scale;
259     int err_inf, v;
260     int64_t err2, ti, ti1, it1, err_sum = 0;
261     int64_t sysErr[64], sysErrMax = 0;
262     int maxout = 0;
263     int blockSumErrMax = 0, blockSumErr;
264     AVLFG prng;
265     const int vals=1<<bits;
266     double omse, ome;
267     int spec_err;
268
269     av_lfg_init(&prng, 1);
270
271     err_inf = 0;
272     err2 = 0;
273     for (i = 0; i < 64; i++)
274         sysErr[i] = 0;
275     for (it = 0; it < NB_ITS; it++) {
276         init_block(block1, test, is_idct, &prng, vals);
277         permute(block, block1, dct->format);
278
279         dct->func(block);
280         emms_c();
281
282         if (dct->format == SCALE_PERM) {
283             for (i = 0; i < 64; i++) {
284                 scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
285                 block[i] = (block[i] * scale) >> AANSCALE_BITS;
286             }
287         }
288
289         ref(block1);
290
291         blockSumErr = 0;
292         for (i = 0; i < 64; i++) {
293             int err = block[i] - block1[i];
294             err_sum += err;
295             v = abs(err);
296             if (v > err_inf)
297                 err_inf = v;
298             err2 += v * v;
299             sysErr[i] += block[i] - block1[i];
300             blockSumErr += v;
301             if (abs(block[i]) > maxout)
302                 maxout = abs(block[i]);
303         }
304         if (blockSumErrMax < blockSumErr)
305             blockSumErrMax = blockSumErr;
306     }
307     for (i = 0; i < 64; i++)
308         sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
309
310     for (i = 0; i < 64; i++) {
311         if (i % 8 == 0)
312             printf("\n");
313         printf("%7d ", (int) sysErr[i]);
314     }
315     printf("\n");
316
317     omse = (double) err2 / NB_ITS / 64;
318     ome  = (double) err_sum / NB_ITS / 64;
319
320     spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
321
322     printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
323            is_idct ? "IDCT" : "DCT", dct->name, err_inf,
324            omse, ome, (double) sysErrMax / NB_ITS,
325            maxout, blockSumErrMax);
326
327     if (spec_err && !dct->nonspec)
328         return 1;
329
330     if (!speed)
331         return 0;
332
333     /* speed test */
334
335     init_block(block, test, is_idct, &prng, vals);
336     permute(block1, block, dct->format);
337
338     ti = av_gettime();
339     it1 = 0;
340     do {
341         for (it = 0; it < NB_ITS_SPEED; it++) {
342             memcpy(block, block1, sizeof(block));
343             dct->func(block);
344         }
345         emms_c();
346         it1 += NB_ITS_SPEED;
347         ti1 = av_gettime() - ti;
348     } while (ti1 < 1000000);
349
350     printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
351            (double) it1 * 1000.0 / (double) ti1);
352
353     return 0;
354 }
355
356 DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
357 DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
358
359 static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
360 {
361     static int init;
362     static double c8[8][8];
363     static double c4[4][4];
364     double block1[64], block2[64], block3[64];
365     double s, sum, v;
366     int i, j, k;
367
368     if (!init) {
369         init = 1;
370
371         for (i = 0; i < 8; i++) {
372             sum = 0;
373             for (j = 0; j < 8; j++) {
374                 s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
375                 c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
376                 sum += c8[i][j] * c8[i][j];
377             }
378         }
379
380         for (i = 0; i < 4; i++) {
381             sum = 0;
382             for (j = 0; j < 4; j++) {
383                 s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
384                 c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
385                 sum += c4[i][j] * c4[i][j];
386             }
387         }
388     }
389
390     /* butterfly */
391     s = 0.5 * sqrt(2.0);
392     for (i = 0; i < 4; i++) {
393         for (j = 0; j < 8; j++) {
394             block1[8 * (2 * i) + j] =
395                 (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
396             block1[8 * (2 * i + 1) + j] =
397                 (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
398         }
399     }
400
401     /* idct8 on lines */
402     for (i = 0; i < 8; i++) {
403         for (j = 0; j < 8; j++) {
404             sum = 0;
405             for (k = 0; k < 8; k++)
406                 sum += c8[k][j] * block1[8 * i + k];
407             block2[8 * i + j] = sum;
408         }
409     }
410
411     /* idct4 */
412     for (i = 0; i < 8; i++) {
413         for (j = 0; j < 4; j++) {
414             /* top */
415             sum = 0;
416             for (k = 0; k < 4; k++)
417                 sum += c4[k][j] * block2[8 * (2 * k) + i];
418             block3[8 * (2 * j) + i] = sum;
419
420             /* bottom */
421             sum = 0;
422             for (k = 0; k < 4; k++)
423                 sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
424             block3[8 * (2 * j + 1) + i] = sum;
425         }
426     }
427
428     /* clamp and store the result */
429     for (i = 0; i < 8; i++) {
430         for (j = 0; j < 8; j++) {
431             v = block3[8 * i + j];
432             if      (v < 0)   v = 0;
433             else if (v > 255) v = 255;
434             dest[i * linesize + j] = (int) rint(v);
435         }
436     }
437 }
438
439 static void idct248_error(const char *name,
440                           void (*idct248_put)(uint8_t *dest, int line_size,
441                                               int16_t *block),
442                           int speed)
443 {
444     int it, i, it1, ti, ti1, err_max, v;
445     AVLFG prng;
446
447     av_lfg_init(&prng, 1);
448
449     /* just one test to see if code is correct (precision is less
450        important here) */
451     err_max = 0;
452     for (it = 0; it < NB_ITS; it++) {
453         /* XXX: use forward transform to generate values */
454         for (i = 0; i < 64; i++)
455             block1[i] = av_lfg_get(&prng) % 256 - 128;
456         block1[0] += 1024;
457
458         for (i = 0; i < 64; i++)
459             block[i] = block1[i];
460         idct248_ref(img_dest1, 8, block);
461
462         for (i = 0; i < 64; i++)
463             block[i] = block1[i];
464         idct248_put(img_dest, 8, block);
465
466         for (i = 0; i < 64; i++) {
467             v = abs((int) img_dest[i] - (int) img_dest1[i]);
468             if (v == 255)
469                 printf("%d %d\n", img_dest[i], img_dest1[i]);
470             if (v > err_max)
471                 err_max = v;
472         }
473 #if 0
474         printf("ref=\n");
475         for(i=0;i<8;i++) {
476             int j;
477             for(j=0;j<8;j++) {
478                 printf(" %3d", img_dest1[i*8+j]);
479             }
480             printf("\n");
481         }
482
483         printf("out=\n");
484         for(i=0;i<8;i++) {
485             int j;
486             for(j=0;j<8;j++) {
487                 printf(" %3d", img_dest[i*8+j]);
488             }
489             printf("\n");
490         }
491 #endif
492     }
493     printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
494
495     if (!speed)
496         return;
497
498     ti = av_gettime();
499     it1 = 0;
500     do {
501         for (it = 0; it < NB_ITS_SPEED; it++) {
502             for (i = 0; i < 64; i++)
503                 block[i] = block1[i];
504             idct248_put(img_dest, 8, block);
505         }
506         emms_c();
507         it1 += NB_ITS_SPEED;
508         ti1 = av_gettime() - ti;
509     } while (ti1 < 1000000);
510
511     printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
512            (double) it1 * 1000.0 / (double) ti1);
513 }
514
515 static void help(void)
516 {
517     printf("dct-test [-i] [<test-number>] [<bits>]\n"
518            "test-number 0 -> test with random matrixes\n"
519            "            1 -> test with random sparse matrixes\n"
520            "            2 -> do 3. test from mpeg4 std\n"
521            "bits        Number of time domain bits to use, 8 is default\n"
522            "-i          test IDCT implementations\n"
523            "-4          test IDCT248 implementations\n"
524            "-t          speed test\n");
525 }
526
527 #if !HAVE_GETOPT
528 #include "compat/getopt.c"
529 #endif
530
531 int main(int argc, char **argv)
532 {
533     int test_idct = 0, test_248_dct = 0;
534     int c, i;
535     int test = 1;
536     int speed = 0;
537     int err = 0;
538     int bits=8;
539
540     cpu_flags = av_get_cpu_flags();
541
542     ff_ref_dct_init();
543     idct_mmx_init();
544
545     for (;;) {
546         c = getopt(argc, argv, "ih4t");
547         if (c == -1)
548             break;
549         switch (c) {
550         case 'i':
551             test_idct = 1;
552             break;
553         case '4':
554             test_248_dct = 1;
555             break;
556         case 't':
557             speed = 1;
558             break;
559         default:
560         case 'h':
561             help();
562             return 0;
563         }
564     }
565
566     if (optind < argc)
567         test = atoi(argv[optind]);
568     if(optind+1 < argc) bits= atoi(argv[optind+1]);
569
570     printf("ffmpeg DCT/IDCT test\n");
571
572     if (test_248_dct) {
573         idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
574     } else {
575         const struct algo *algos = test_idct ? idct_tab : fdct_tab;
576         for (i = 0; algos[i].name; i++)
577             if (!(~cpu_flags & algos[i].mm_support)) {
578                 err |= dct_error(&algos[i], test, test_idct, speed, bits);
579             }
580     }
581
582     return err;
583 }