libavcodec/dct-test.c

   1 /* DCT test. (c) 2001 Fabrice Bellard.
   2    Started from sample code by Juan J. Sierralta P.
   3 */
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <sys/time.h>
   8 #include <unistd.h>
   9 #include <getopt.h>
  10
  11 #include "dsputil.h"
  12
  13 #include "i386/mmx.h"
  14
  15 /* reference fdct/idct */
  16 extern void fdct(DCTELEM *block);
  17 extern void idct(DCTELEM *block);
  18 extern void init_fdct();
  19
  20 extern void j_rev_dct(DCTELEM *data);
  21 extern void ff_mmx_idct(DCTELEM *data);
  22 extern void ff_mmxext_idct(DCTELEM *data);
  23
  24 #define AANSCALE_BITS 12
  25 static const unsigned short aanscales[64] = {
  26     /* precomputed values scaled up by 14 bits */
  27     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  28     22725, 31521, 29692, 26722, 22725, 17855, 12299,  6270,
  29     21407, 29692, 27969, 25172, 21407, 16819, 11585,  5906,
  30     19266, 26722, 25172, 22654, 19266, 15137, 10426,  5315,
  31     16384, 22725, 21407, 19266, 16384, 12873,  8867,  4520,
  32     12873, 17855, 16819, 15137, 12873, 10114,  6967,  3552,
  33     8867, 12299, 11585, 10426,  8867,  6967,  4799,  2446,
  34     4520,  6270,  5906,  5315,  4520,  3552,  2446,  1247
  35 };
  36
  37 INT64 gettime(void)
  38 {
  39     struct timeval tv;
  40     gettimeofday(&tv,NULL);
  41     return (INT64)tv.tv_sec * 1000000 + tv.tv_usec;
  42 }
  43
  44 #define NB_ITS 20000
  45 #define NB_ITS_SPEED 50000
  46
  47 static short idct_mmx_perm[64];
  48
  49 void idct_mmx_init(void)
  50 {
  51     int i;
  52
  53     /* the mmx/mmxext idct uses a reordered input, so we patch scan tables */
  54     for (i = 0; i < 64; i++) {
  55         idct_mmx_perm[i] = (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
  56     }
  57 }
  58
  59 static DCTELEM block[64] __attribute__ ((aligned (8)));
  60 static DCTELEM block1[64] __attribute__ ((aligned (8)));
  61
  62 void dct_error(const char *name, int is_idct,
  63                void (*fdct_func)(DCTELEM *block),
  64                void (*fdct_ref)(DCTELEM *block))
  65 {
  66     int it, i, scale;
  67     int err_inf, v;
  68     INT64 err2, ti, ti1, it1;
  69
  70     srandom(0);
  71
  72     err_inf = 0;
  73     err2 = 0;
  74     for(it=0;it<NB_ITS;it++) {
  75         for(i=0;i<64;i++)
  76             block1[i] = random() % 256;
  77
  78         /* for idct test, generate inverse idct data */
  79         if (is_idct)
  80             fdct(block1);
  81
  82         if (fdct_func == ff_mmx_idct ||
  83             fdct_func == j_rev_dct) {
  84             for(i=0;i<64;i++)
  85                 block[idct_mmx_perm[i]] = block1[i];
  86         } else {
  87             memcpy(block, block1, sizeof(DCTELEM) * 64);
  88         }
  89
  90         fdct_func(block);
  91         emms(); /* for ff_mmx_idct */
  92
  93         if (fdct_func == fdct_ifast) {
  94             for(i=0; i<64; i++) {
  95                 scale = (1 << (AANSCALE_BITS + 11)) / aanscales[i];
  96                 block[i] = (block[i] * scale) >> AANSCALE_BITS;
  97             }
  98         }
  99
 100         fdct_ref(block1);
 101
 102         for(i=0;i<64;i++) {
 103             v = abs(block[i] - block1[i]);
 104             if (v > err_inf)
 105                 err_inf = v;
 106             err2 += v * v;
 107         }
 108     }
 109     printf("%s %s: err_inf=%d err2=%0.2f\n",
 110            is_idct ? "IDCT" : "DCT",
 111            name, err_inf, (double)err2 / NB_ITS / 64.0);
 112
 113     /* speed test */
 114     for(i=0;i<64;i++)
 115         block1[i] = 255 - 63 + i;
 116
 117     /* for idct test, generate inverse idct data */
 118     if (is_idct)
 119         fdct(block1);
 120     if (fdct_func == ff_mmx_idct ||
 121         fdct_func == j_rev_dct) {
 122         for(i=0;i<64;i++)
 123             block[idct_mmx_perm[i]] = block1[i];
 124     }
 125
 126     ti = gettime();
 127     it1 = 0;
 128     do {
 129         for(it=0;it<NB_ITS_SPEED;it++) {
 130             memcpy(block, block1, sizeof(DCTELEM) * 64);
 131             fdct_func(block);
 132         }
 133         it1 += NB_ITS_SPEED;
 134         ti1 = gettime() - ti;
 135     } while (ti1 < 1000000);
 136     emms();
 137
 138     printf("%s %s: %0.1f kdct/s\n",
 139            is_idct ? "IDCT" : "DCT",
 140            name, (double)it1 * 1000.0 / (double)ti1);
 141 }
 142
 143 void help(void)
 144 {
 145     printf("dct-test [-i]\n"
 146            "test DCT implementations\n");
 147     exit(1);
 148 }
 149
 150 int main(int argc, char **argv)
 151 {
 152     int test_idct = 0;
 153     int c;
 154
 155     init_fdct();
 156     idct_mmx_init();
 157
 158     for(;;) {
 159         c = getopt(argc, argv, "ih");
 160         if (c == -1)
 161             break;
 162         switch(c) {
 163         case 'i':
 164             test_idct = 1;
 165             break;
 166         case 'h':
 167             help();
 168             break;
 169         }
 170     }
 171
 172     printf("ffmpeg DCT/IDCT test\n");
 173
 174     if (!test_idct) {
 175         dct_error("REF", 0, fdct, fdct); /* only to verify code ! */
 176         dct_error("AAN", 0, fdct_ifast, fdct);
 177         dct_error("MMX", 0, fdct_mmx, fdct);
 178     } else {
 179         dct_error("REF", 1, idct, idct);
 180         dct_error("INT", 1, j_rev_dct, idct);
 181         dct_error("MMX", 1, ff_mmx_idct, idct);
 182         //    dct_error("MMX", 1, ff_mmxext_idct, idct);
 183     }
 184     return 0;
 185 }