FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
dct-test.c
Go to the documentation of this file.
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 "idctdsp.h"
44 #include "simple_idct.h"
45 #include "xvididct.h"
46 #include "aandcttab.h"
47 #include "faandct.h"
48 #include "faanidct.h"
49 #include "dctref.h"
50 
51 struct algo {
52  const char *name;
53  void (*func)(int16_t *block);
55  int cpu_flag;
56  int nonspec;
57 };
58 
59 static const struct algo fdct_tab[] = {
60  { "REF-DBL", ff_ref_fdct, FF_IDCT_PERM_NONE },
61  { "IJG-AAN-INT", ff_fdct_ifast, FF_IDCT_PERM_NONE },
62  { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, FF_IDCT_PERM_NONE },
63 #if CONFIG_FAANDCT
64  { "FAAN", ff_faandct, FF_IDCT_PERM_NONE },
65 #endif /* CONFIG_FAANDCT */
66 };
67 
68 static void ff_prores_idct_wrap(int16_t *dst){
69  LOCAL_ALIGNED(16, int16_t, qmat, [64]);
70  int i;
71 
72  for(i=0; i<64; i++){
73  qmat[i]=4;
74  }
75  ff_prores_idct(dst, qmat);
76  for(i=0; i<64; i++) {
77  dst[i] -= 512;
78  }
79 }
80 
81 static const struct algo idct_tab[] = {
82  { "REF-DBL", ff_ref_idct, FF_IDCT_PERM_NONE },
84  { "SIMPLE-C", ff_simple_idct_8, FF_IDCT_PERM_NONE },
85  { "SIMPLE-C10", ff_simple_idct_10, FF_IDCT_PERM_NONE },
86  { "SIMPLE-C12", ff_simple_idct_12, FF_IDCT_PERM_NONE, 0, 1 },
87  { "PR-C", ff_prores_idct_wrap, FF_IDCT_PERM_NONE, 0, 1 },
88 #if CONFIG_FAANIDCT
89  { "FAANI", ff_faanidct, FF_IDCT_PERM_NONE },
90 #endif /* CONFIG_FAANIDCT */
91 #if CONFIG_MPEG4_DECODER
92  { "XVID", ff_xvid_idct, FF_IDCT_PERM_NONE, 0, 1 },
93 #endif /* CONFIG_MPEG4_DECODER */
94 };
95 
96 #if ARCH_ARM
97 #include "arm/dct-test.c"
98 #elif ARCH_PPC
99 #include "ppc/dct-test.c"
100 #elif ARCH_X86
101 #include "x86/dct-test.c"
102 #else
103 static const struct algo fdct_tab_arch[] = { { 0 } };
104 static const struct algo idct_tab_arch[] = { { 0 } };
105 #endif
106 
107 #define AANSCALE_BITS 12
108 
109 #define NB_ITS 20000
110 #define NB_ITS_SPEED 50000
111 
112 DECLARE_ALIGNED(16, static int16_t, block)[64];
113 DECLARE_ALIGNED(8, static int16_t, block1)[64];
114 
115 static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
116 {
117  int i, j;
118 
119  memset(block, 0, 64 * sizeof(*block));
120 
121  switch (test) {
122  case 0:
123  for (i = 0; i < 64; i++)
124  block[i] = (av_lfg_get(prng) % (2*vals)) -vals;
125  if (is_idct) {
126  ff_ref_fdct(block);
127  for (i = 0; i < 64; i++)
128  block[i] >>= 3;
129  }
130  break;
131  case 1:
132  j = av_lfg_get(prng) % 10 + 1;
133  for (i = 0; i < j; i++) {
134  int idx = av_lfg_get(prng) % 64;
135  block[idx] = av_lfg_get(prng) % (2*vals) -vals;
136  }
137  break;
138  case 2:
139  block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals);
140  block[63] = (block[0] & 1) ^ 1;
141  break;
142  }
143 }
144 
145 static void permute(int16_t dst[64], const int16_t src[64],
147 {
148  int i;
149 
150 #if ARCH_X86
151  if (permute_x86(dst, src, perm_type))
152  return;
153 #endif
154 
155  switch (perm_type) {
157  for (i = 0; i < 64; i++)
158  dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
159  break;
161  for (i = 0; i < 64; i++)
162  dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
163  break;
165  for (i = 0; i < 64; i++)
166  dst[(i>>3) | ((i<<3)&0x38)] = src[i];
167  break;
168  default:
169  for (i = 0; i < 64; i++)
170  dst[i] = src[i];
171  break;
172  }
173 }
174 
175 static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
176 {
177  void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
178  int it, i, scale;
179  int err_inf, v;
180  int64_t err2, ti, ti1, it1, err_sum = 0;
181  int64_t sysErr[64], sysErrMax = 0;
182  int maxout = 0;
183  int blockSumErrMax = 0, blockSumErr;
184  AVLFG prng;
185  const int vals=1<<bits;
186  double omse, ome;
187  int spec_err;
188 
189  av_lfg_init(&prng, 1);
190 
191  err_inf = 0;
192  err2 = 0;
193  for (i = 0; i < 64; i++)
194  sysErr[i] = 0;
195  for (it = 0; it < NB_ITS; it++) {
196  init_block(block1, test, is_idct, &prng, vals);
197  permute(block, block1, dct->perm_type);
198 
199  dct->func(block);
200  emms_c();
201 
202  if (!strcmp(dct->name, "IJG-AAN-INT")) {
203  for (i = 0; i < 64; i++) {
204  scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
205  block[i] = (block[i] * scale) >> AANSCALE_BITS;
206  }
207  }
208 
209  ref(block1);
210  if (!strcmp(dct->name, "PR-SSE2"))
211  for (i = 0; i < 64; i++)
212  block1[i] = av_clip(block1[i], 4-512, 1019-512);
213 
214  blockSumErr = 0;
215  for (i = 0; i < 64; i++) {
216  int err = block[i] - block1[i];
217  err_sum += err;
218  v = abs(err);
219  if (v > err_inf)
220  err_inf = v;
221  err2 += v * v;
222  sysErr[i] += block[i] - block1[i];
223  blockSumErr += v;
224  if (abs(block[i]) > maxout)
225  maxout = abs(block[i]);
226  }
227  if (blockSumErrMax < blockSumErr)
228  blockSumErrMax = blockSumErr;
229  }
230  for (i = 0; i < 64; i++)
231  sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
232 
233  for (i = 0; i < 64; i++) {
234  if (i % 8 == 0)
235  printf("\n");
236  printf("%7d ", (int) sysErr[i]);
237  }
238  printf("\n");
239 
240  omse = (double) err2 / NB_ITS / 64;
241  ome = (double) err_sum / NB_ITS / 64;
242 
243  spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
244 
245  printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
246  is_idct ? "IDCT" : "DCT", dct->name, err_inf,
247  omse, ome, (double) sysErrMax / NB_ITS,
248  maxout, blockSumErrMax);
249 
250  if (spec_err && !dct->nonspec) {
251  printf("Failed!\n");
252  return 1;
253  }
254 
255  if (!speed)
256  return 0;
257 
258  /* speed test */
259 
260  init_block(block, test, is_idct, &prng, vals);
261  permute(block1, block, dct->perm_type);
262 
263  ti = av_gettime_relative();
264  it1 = 0;
265  do {
266  for (it = 0; it < NB_ITS_SPEED; it++) {
267  memcpy(block, block1, sizeof(block));
268  dct->func(block);
269  }
270  emms_c();
271  it1 += NB_ITS_SPEED;
272  ti1 = av_gettime_relative() - ti;
273  } while (ti1 < 1000000);
274 
275  printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
276  (double) it1 * 1000.0 / (double) ti1);
277 
278  return 0;
279 }
280 
283 
284 static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
285 {
286  static int init;
287  static double c8[8][8];
288  static double c4[4][4];
289  double block1[64], block2[64], block3[64];
290  double s, sum, v;
291  int i, j, k;
292 
293  if (!init) {
294  init = 1;
295 
296  for (i = 0; i < 8; i++) {
297  sum = 0;
298  for (j = 0; j < 8; j++) {
299  s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
300  c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
301  sum += c8[i][j] * c8[i][j];
302  }
303  }
304 
305  for (i = 0; i < 4; i++) {
306  sum = 0;
307  for (j = 0; j < 4; j++) {
308  s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
309  c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
310  sum += c4[i][j] * c4[i][j];
311  }
312  }
313  }
314 
315  /* butterfly */
316  s = 0.5 * sqrt(2.0);
317  for (i = 0; i < 4; i++) {
318  for (j = 0; j < 8; j++) {
319  block1[8 * (2 * i) + j] =
320  (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
321  block1[8 * (2 * i + 1) + j] =
322  (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
323  }
324  }
325 
326  /* idct8 on lines */
327  for (i = 0; i < 8; i++) {
328  for (j = 0; j < 8; j++) {
329  sum = 0;
330  for (k = 0; k < 8; k++)
331  sum += c8[k][j] * block1[8 * i + k];
332  block2[8 * i + j] = sum;
333  }
334  }
335 
336  /* idct4 */
337  for (i = 0; i < 8; i++) {
338  for (j = 0; j < 4; j++) {
339  /* top */
340  sum = 0;
341  for (k = 0; k < 4; k++)
342  sum += c4[k][j] * block2[8 * (2 * k) + i];
343  block3[8 * (2 * j) + i] = sum;
344 
345  /* bottom */
346  sum = 0;
347  for (k = 0; k < 4; k++)
348  sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
349  block3[8 * (2 * j + 1) + i] = sum;
350  }
351  }
352 
353  /* clamp and store the result */
354  for (i = 0; i < 8; i++) {
355  for (j = 0; j < 8; j++) {
356  v = block3[8 * i + j];
357  if (v < 0) v = 0;
358  else if (v > 255) v = 255;
359  dest[i * linesize + j] = (int) rint(v);
360  }
361  }
362 }
363 
364 static void idct248_error(const char *name,
365  void (*idct248_put)(uint8_t *dest, int line_size,
366  int16_t *block),
367  int speed)
368 {
369  int it, i, it1, ti, ti1, err_max, v;
370  AVLFG prng;
371 
372  av_lfg_init(&prng, 1);
373 
374  /* just one test to see if code is correct (precision is less
375  important here) */
376  err_max = 0;
377  for (it = 0; it < NB_ITS; it++) {
378  /* XXX: use forward transform to generate values */
379  for (i = 0; i < 64; i++)
380  block1[i] = av_lfg_get(&prng) % 256 - 128;
381  block1[0] += 1024;
382 
383  for (i = 0; i < 64; i++)
384  block[i] = block1[i];
385  idct248_ref(img_dest1, 8, block);
386 
387  for (i = 0; i < 64; i++)
388  block[i] = block1[i];
389  idct248_put(img_dest, 8, block);
390 
391  for (i = 0; i < 64; i++) {
392  v = abs((int) img_dest[i] - (int) img_dest1[i]);
393  if (v == 255)
394  printf("%d %d\n", img_dest[i], img_dest1[i]);
395  if (v > err_max)
396  err_max = v;
397  }
398 #if 0
399  printf("ref=\n");
400  for(i=0;i<8;i++) {
401  int j;
402  for(j=0;j<8;j++) {
403  printf(" %3d", img_dest1[i*8+j]);
404  }
405  printf("\n");
406  }
407 
408  printf("out=\n");
409  for(i=0;i<8;i++) {
410  int j;
411  for(j=0;j<8;j++) {
412  printf(" %3d", img_dest[i*8+j]);
413  }
414  printf("\n");
415  }
416 #endif
417  }
418  printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
419 
420  if (!speed)
421  return;
422 
423  ti = av_gettime_relative();
424  it1 = 0;
425  do {
426  for (it = 0; it < NB_ITS_SPEED; it++) {
427  for (i = 0; i < 64; i++)
428  block[i] = block1[i];
429  idct248_put(img_dest, 8, block);
430  }
431  emms_c();
432  it1 += NB_ITS_SPEED;
433  ti1 = av_gettime_relative() - ti;
434  } while (ti1 < 1000000);
435 
436  printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
437  (double) it1 * 1000.0 / (double) ti1);
438 }
439 
440 static void help(void)
441 {
442  printf("dct-test [-i] [<test-number>] [<bits>]\n"
443  "test-number 0 -> test with random matrixes\n"
444  " 1 -> test with random sparse matrixes\n"
445  " 2 -> do 3. test from mpeg4 std\n"
446  "bits Number of time domain bits to use, 8 is default\n"
447  "-i test IDCT implementations\n"
448  "-4 test IDCT248 implementations\n"
449  "-t speed test\n");
450 }
451 
452 #if !HAVE_GETOPT
453 #include "compat/getopt.c"
454 #endif
455 
456 int main(int argc, char **argv)
457 {
458  int test_idct = 0, test_248_dct = 0;
459  int c, i;
460  int test = 1;
461  int speed = 0;
462  int err = 0;
463  int bits=8;
464 
465  ff_ref_dct_init();
466 
467  for (;;) {
468  c = getopt(argc, argv, "ih4t");
469  if (c == -1)
470  break;
471  switch (c) {
472  case 'i':
473  test_idct = 1;
474  break;
475  case '4':
476  test_248_dct = 1;
477  break;
478  case 't':
479  speed = 1;
480  break;
481  default:
482  case 'h':
483  help();
484  return 0;
485  }
486  }
487 
488  if (optind < argc)
489  test = atoi(argv[optind]);
490  if(optind+1 < argc) bits= atoi(argv[optind+1]);
491 
492  printf("ffmpeg DCT/IDCT test\n");
493 
494  if (test_248_dct) {
495  idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
496  } else {
497  const int cpu_flags = av_get_cpu_flags();
498  if (test_idct) {
499  for (i = 0; i < FF_ARRAY_ELEMS(idct_tab); i++)
500  err |= dct_error(&idct_tab[i], test, test_idct, speed, bits);
501 
502  for (i = 0; idct_tab_arch[i].name; i++)
503  if (!(~cpu_flags & idct_tab_arch[i].cpu_flag))
504  err |= dct_error(&idct_tab_arch[i], test, test_idct, speed, bits);
505  }
506 #if CONFIG_FDCTDSP
507  else {
508  for (i = 0; i < FF_ARRAY_ELEMS(fdct_tab); i++)
509  err |= dct_error(&fdct_tab[i], test, test_idct, speed, bits);
510 
511  for (i = 0; fdct_tab_arch[i].name; i++)
512  if (!(~cpu_flags & fdct_tab_arch[i].cpu_flag))
513  err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed, bits);
514  }
515 #endif /* CONFIG_FDCTDSP */
516  }
517 
518  if (err)
519  printf("Error: %d.\n", err);
520 
521  return !!err;
522 }
Definition: lfg.h:25
idct_permutation_type
Definition: idctdsp.h:35
const char * s
Definition: avisynth_c.h:631
void ff_fdct_ifast(int16_t *data)
Definition: jfdctfst.c:208
static const struct algo idct_tab[]
Definition: dct-test.c:81
static uint8_t img_dest[64]
Definition: dct-test.c:281
static int optind
Definition: getopt.c:37
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const char * name
Definition: dct-test.c:52
static const struct algo fdct_tab_arch[]
Definition: dct-test.c:103
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
int main(int argc, char **argv)
Definition: dct-test.c:456
static int permute_x86(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
Definition: dct-test.c:116
av_cold void ff_ref_dct_init(void)
Initialize the double precision discrete cosine transform functions fdct & idct.
Definition: dctref.c:41
int nonspec
Definition: dct-test.c:56
uint8_t bits
Definition: crc.c:296
uint8_t
void ff_faanidct(int16_t block[64])
Definition: faanidct.c:134
int cpu_flag
Definition: dct-test.c:55
void ff_simple_idct248_put(uint8_t *dest, int line_size, int16_t *block)
Definition: simple_idct.c:97
const uint16_t ff_aanscales[64]
Definition: aandcttab.c:26
static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
Definition: dct-test.c:145
void ff_prores_idct(int16_t *block, const int16_t *qmat)
Special version of ff_simple_idct_10() which does dequantization and scales by a factor of 2 more bet...
Definition: simple_idct.c:230
static int ref[MAX_W *MAX_W]
#define AANSCALE_BITS
Definition: dct-test.c:107
#define FFMAX(a, b)
Definition: common.h:94
static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
Definition: dct-test.c:175
static const struct algo fdct_tab[]
Definition: dct-test.c:59
Definition: dct-test.c:51
static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
Definition: dct-test.c:284
static void test(const char *pattern, const char *host)
Definition: noproxy-test.c:23
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
static void ff_prores_idct_wrap(int16_t *dst)
Definition: dct-test.c:68
#define src
Definition: vp9dsp.c:530
void ff_simple_idct_10(int16_t *block)
#define FF_ARRAY_ELEMS(a)
#define rint
Definition: tablegen.h:41
int cpu_flag
Definition: checkasm.c:186
void ff_jpeg_fdct_islow_8(int16_t *data)
void ff_j_rev_dct(int16_t *data)
#define NB_ITS_SPEED
Definition: dct-test.c:110
void ff_faandct(int16_t *data)
Definition: faandct.c:122
void ff_simple_idct_12(int16_t *block)
static int getopt(int argc, char *argv[], char *opts)
Definition: getopt.c:41
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:38
void ff_ref_fdct(short *block)
Transform 8x8 block of data with a double precision forward DCT This is a reference implementation...
Definition: dctref.c:59
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:30
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:76
void ff_xvid_idct(int16_t *const in)
Definition: xvididct.c:291
static int16_t block1[64]
Definition: dct-test.c:113
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AAN (Arai, Agui and Nakajima) (I)DCT tables.
static uint8_t img_dest1[64]
Definition: dct-test.c:282
common internal and external API header
#define LOCAL_ALIGNED(a, t, v,...)
Definition: internal.h:110
static double c[64]
enum idct_permutation_type perm_type
Definition: dct-test.c:54
static void idct248_error(const char *name, void(*idct248_put)(uint8_t *dest, int line_size, int16_t *block), int speed)
Definition: dct-test.c:364
void ff_ref_idct(short *block)
Transform 8x8 block of data with a double precision inverse DCT This is a reference implementation...
Definition: dctref.c:95
static const struct algo idct_tab_arch[]
Definition: dct-test.c:104
simple idct header.
#define NB_ITS
Definition: dct-test.c:109
#define M_PI
Definition: mathematics.h:46
Floating point AAN DCT
void(* func)(int16_t *block)
Definition: dct-test.c:53
static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
Definition: dct-test.c:115
static void help(void)
Definition: dct-test.c:440
void ff_simple_idct_8(int16_t *block)
const char * name
Definition: opengl_enc.c:103
static int16_t block[64]
Definition: dct-test.c:112