FFmpeg
dct.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 "config_components.h"
30 #include <stdlib.h>
31 #include <stdio.h>
32 #include <string.h>
33 #if HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 #include <math.h>
37 
38 #include "libavutil/cpu.h"
39 #include "libavutil/common.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/lfg.h"
42 #include "libavutil/mem_internal.h"
43 #include "libavutil/time.h"
44 
45 #include "libavcodec/dct.h"
46 #include "libavcodec/fdctdsp.h"
47 #include "libavcodec/idctdsp.h"
48 #include "libavcodec/simple_idct.h"
49 #include "libavcodec/xvididct.h"
50 #include "libavcodec/aandcttab.h"
51 #include "libavcodec/faandct.h"
52 #include "libavcodec/faanidct.h"
53 #include "libavcodec/dctref.h"
54 #if CONFIG_PRORES_DECODER
55 #include "libavcodec/proresdsp.c"
56 #endif
57 
58 struct algo {
59  const char *name;
60  void (*func)(int16_t *block);
61  enum idct_permutation_type perm_type;
62  int cpu_flag;
63  int nonspec;
64 };
65 
66 static const struct algo fdct_tab[] = {
67  { "REF-DBL", ff_ref_fdct, FF_IDCT_PERM_NONE },
68  { "IJG-AAN-INT", ff_fdct_ifast, FF_IDCT_PERM_NONE },
69  { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, FF_IDCT_PERM_NONE },
70 #if CONFIG_FAANDCT
71  { "FAAN", ff_faandct, FF_IDCT_PERM_NONE },
72 #endif /* CONFIG_FAANDCT */
73 };
74 
75 #if CONFIG_PRORES_DECODER
76 static void ff_prores_idct_wrap(int16_t *dst){
77  LOCAL_ALIGNED(16, int16_t, qmat, [64]);
78  int i;
79 
80  for(i=0; i<64; i++){
81  qmat[i]=4;
82  }
83  prores_idct_10(dst, qmat);
84  for(i=0; i<64; i++) {
85  dst[i] -= 512;
86  }
87 }
88 #endif
89 
90 static const struct algo idct_tab[] = {
91  { "REF-DBL", ff_ref_idct, FF_IDCT_PERM_NONE },
92  { "INT", ff_j_rev_dct, FF_IDCT_PERM_LIBMPEG2 },
93  { "SIMPLE-C", ff_simple_idct_int16_8bit, FF_IDCT_PERM_NONE },
94  { "SIMPLE-C10", ff_simple_idct_int16_10bit, FF_IDCT_PERM_NONE },
95  { "SIMPLE-C12", ff_simple_idct_int16_12bit, FF_IDCT_PERM_NONE, 0, 1 },
96 #if CONFIG_PRORES_DECODER
97  { "PR-C", ff_prores_idct_wrap, FF_IDCT_PERM_NONE, 0, 1 },
98 #endif
99 #if CONFIG_FAANIDCT
100  { "FAANI", ff_faanidct, FF_IDCT_PERM_NONE },
101 #endif /* CONFIG_FAANIDCT */
102 #if CONFIG_MPEG4_DECODER
103  { "XVID", ff_xvid_idct, FF_IDCT_PERM_NONE, 0, 1 },
104 #endif /* CONFIG_MPEG4_DECODER */
105 };
106 
107 #if ARCH_AARCH64
108 #include "aarch64/dct.c"
109 #elif ARCH_ARM
110 #include "arm/dct.c"
111 #elif ARCH_PPC
112 #include "ppc/dct.c"
113 #elif ARCH_X86
114 #include "x86/dct.c"
115 #else
116 static const struct algo fdct_tab_arch[] = { { 0 } };
117 static const struct algo idct_tab_arch[] = { { 0 } };
118 #endif
119 
120 #define AANSCALE_BITS 12
121 
122 #define NB_ITS 20000
123 #define NB_ITS_SPEED 50000
124 
125 DECLARE_ALIGNED(16, static int16_t, block)[64];
126 DECLARE_ALIGNED(8, static int16_t, block1)[64];
127 
128 static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
129 {
130  int i, j;
131 
132  memset(block, 0, 64 * sizeof(*block));
133 
134  switch (test) {
135  case 0:
136  for (i = 0; i < 64; i++)
137  block[i] = (av_lfg_get(prng) % (2*vals)) -vals;
138  if (is_idct) {
139  ff_ref_fdct(block);
140  for (i = 0; i < 64; i++)
141  block[i] >>= 3;
142  }
143  break;
144  case 1:
145  j = av_lfg_get(prng) % 10 + 1;
146  for (i = 0; i < j; i++) {
147  int idx = av_lfg_get(prng) % 64;
148  block[idx] = av_lfg_get(prng) % (2*vals) -vals;
149  }
150  break;
151  case 2:
152  block[ 0] = av_lfg_get(prng) % (16*vals) - (8*vals);
153  block[63] = (block[0] & 1) ^ 1;
154  break;
155  }
156 }
157 
158 static void permute(int16_t dst[64], const int16_t src[64],
159  enum idct_permutation_type perm_type)
160 {
161  int i;
162 
163 #if ARCH_X86
164  if (permute_x86(dst, src, perm_type))
165  return;
166 #endif
167 
168  switch (perm_type) {
169  case FF_IDCT_PERM_LIBMPEG2:
170  for (i = 0; i < 64; i++)
171  dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
172  break;
173  case FF_IDCT_PERM_PARTTRANS:
174  for (i = 0; i < 64; i++)
175  dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
176  break;
177  case FF_IDCT_PERM_TRANSPOSE:
178  for (i = 0; i < 64; i++)
179  dst[(i>>3) | ((i<<3)&0x38)] = src[i];
180  break;
181  default:
182  for (i = 0; i < 64; i++)
183  dst[i] = src[i];
184  break;
185  }
186 }
187 
188 static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
189 {
190  void (*ref)(int16_t *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
191  int it, i, scale;
192  int err_inf, v;
193  int64_t err2, ti, ti1, it1, err_sum = 0;
194  int64_t sysErr[64], sysErrMax = 0;
195  int64_t err2_matrix[64], err2_max = 0;
196  int maxout = 0;
197  int blockSumErrMax = 0, blockSumErr;
198  AVLFG prng;
199  const int vals=1<<bits;
200  double omse, ome;
201  int spec_err;
202 
203  av_lfg_init(&prng, 1);
204 
205  err_inf = 0;
206  err2 = 0;
207  for (i = 0; i < 64; i++)
208  err2_matrix[i] = sysErr[i] = 0;
209  for (it = 0; it < NB_ITS; it++) {
210  init_block(block1, test, is_idct, &prng, vals);
211  permute(block, block1, dct->perm_type);
212 
213  dct->func(block);
214 
215  if (!strcmp(dct->name, "IJG-AAN-INT")) {
216  for (i = 0; i < 64; i++) {
217  scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
218  block[i] = (block[i] * scale) >> AANSCALE_BITS;
219  }
220  }
221 
222  ref(block1);
223  if (!strcmp(dct->name, "PR-SSE2"))
224  for (i = 0; i < 64; i++)
225  block1[i] = av_clip(block1[i], 4-512, 1019-512);
226 
227  blockSumErr = 0;
228  for (i = 0; i < 64; i++) {
229  int err = block[i] - block1[i];
230  err_sum += err;
231  v = abs(err);
232  if (v > err_inf)
233  err_inf = v;
234  err2_matrix[i] += v * (int64_t)v;
235  err2 += v * (int64_t)v;
236  sysErr[i] += block[i] - block1[i];
237  blockSumErr += v;
238  if (abs(block[i]) > maxout)
239  maxout = abs(block[i]);
240  }
241  if (blockSumErrMax < blockSumErr)
242  blockSumErrMax = blockSumErr;
243  }
244  for (i = 0; i < 64; i++) {
245  sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
246  err2_max = FFMAX(err2_max , FFABS(err2_matrix[i]));
247  }
248 
249  for (i = 0; i < 64; i++) {
250  if (i % 8 == 0)
251  printf("\n");
252  printf("%7d ", (int) sysErr[i]);
253  }
254  printf("\n");
255 
256  omse = (double) err2 / NB_ITS / 64;
257  ome = (double) err_sum / NB_ITS / 64;
258 
259  spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
260  if (test < 2)
261  spec_err = is_idct && ((double) err2_max / NB_ITS > 0.06 || (double) sysErrMax / NB_ITS > 0.015);
262 
263  printf("%s %s: max_err=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
264  is_idct ? "IDCT" : "DCT", dct->name, err_inf,
265  omse, ome, (double) sysErrMax / NB_ITS,
266  maxout, blockSumErrMax);
267 
268  if (spec_err && !dct->nonspec) {
269  printf("Failed!\n");
270  return 1;
271  }
272 
273  if (!speed)
274  return 0;
275 
276  /* speed test */
277 
278  init_block(block, test, is_idct, &prng, vals);
279  permute(block1, block, dct->perm_type);
280 
281  ti = av_gettime_relative();
282  it1 = 0;
283  do {
284  for (it = 0; it < NB_ITS_SPEED; it++) {
285  memcpy(block, block1, sizeof(block));
286  dct->func(block);
287  }
288  it1 += NB_ITS_SPEED;
289  ti1 = av_gettime_relative() - ti;
290  } while (ti1 < 1000000);
291 
292  printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
293  (double) it1 * 1000.0 / (double) ti1);
294 
295  return 0;
296 }
297 
298 DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
299 DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
300 
301 static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
302 {
303  static int init;
304  static double c8[8][8];
305  static double c4[4][4];
306  double block1[64], block2[64], block3[64];
307  double s, sum, v;
308  int i, j, k;
309 
310  if (!init) {
311  init = 1;
312 
313  for (i = 0; i < 8; i++) {
314  sum = 0;
315  for (j = 0; j < 8; j++) {
316  s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
317  c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
318  sum += c8[i][j] * c8[i][j];
319  }
320  }
321 
322  for (i = 0; i < 4; i++) {
323  sum = 0;
324  for (j = 0; j < 4; j++) {
325  s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
326  c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
327  sum += c4[i][j] * c4[i][j];
328  }
329  }
330  }
331 
332  /* butterfly */
333  s = 0.5 * sqrt(2.0);
334  for (i = 0; i < 4; i++) {
335  for (j = 0; j < 8; j++) {
336  block1[8 * (2 * i) + j] =
337  (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
338  block1[8 * (2 * i + 1) + j] =
339  (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
340  }
341  }
342 
343  /* idct8 on lines */
344  for (i = 0; i < 8; i++) {
345  for (j = 0; j < 8; j++) {
346  sum = 0;
347  for (k = 0; k < 8; k++)
348  sum += c8[k][j] * block1[8 * i + k];
349  block2[8 * i + j] = sum;
350  }
351  }
352 
353  /* idct4 */
354  for (i = 0; i < 8; i++) {
355  for (j = 0; j < 4; j++) {
356  /* top */
357  sum = 0;
358  for (k = 0; k < 4; k++)
359  sum += c4[k][j] * block2[8 * (2 * k) + i];
360  block3[8 * (2 * j) + i] = sum;
361 
362  /* bottom */
363  sum = 0;
364  for (k = 0; k < 4; k++)
365  sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
366  block3[8 * (2 * j + 1) + i] = sum;
367  }
368  }
369 
370  /* clamp and store the result */
371  for (i = 0; i < 8; i++) {
372  for (j = 0; j < 8; j++) {
373  v = block3[8 * i + j];
374  if (v < 0) v = 0;
375  else if (v > 255) v = 255;
376  dest[i * linesize + j] = (int) rint(v);
377  }
378  }
379 }
380 
381 static void idct248_error(const char *name,
382  void (*idct248_put)(uint8_t *dest,
383  ptrdiff_t line_size,
384  int16_t *block),
385  int speed)
386 {
387  int it, i, it1, ti, ti1, err_max, v;
388  AVLFG prng;
389 
390  av_lfg_init(&prng, 1);
391 
392  /* just one test to see if code is correct (precision is less
393  important here) */
394  err_max = 0;
395  for (it = 0; it < NB_ITS; it++) {
396  /* XXX: use forward transform to generate values */
397  for (i = 0; i < 64; i++)
398  block1[i] = av_lfg_get(&prng) % 256 - 128;
399  block1[0] += 1024;
400 
401  for (i = 0; i < 64; i++)
402  block[i] = block1[i];
403  idct248_ref(img_dest1, 8, block);
404 
405  for (i = 0; i < 64; i++)
406  block[i] = block1[i];
407  idct248_put(img_dest, 8, block);
408 
409  for (i = 0; i < 64; i++) {
410  v = abs((int) img_dest[i] - (int) img_dest1[i]);
411  if (v == 255)
412  printf("%d %d\n", img_dest[i], img_dest1[i]);
413  if (v > err_max)
414  err_max = v;
415  }
416 #if 0
417  printf("ref=\n");
418  for(i=0;i<8;i++) {
419  int j;
420  for(j=0;j<8;j++) {
421  printf(" %3d", img_dest1[i*8+j]);
422  }
423  printf("\n");
424  }
425 
426  printf("out=\n");
427  for(i=0;i<8;i++) {
428  int j;
429  for(j=0;j<8;j++) {
430  printf(" %3d", img_dest[i*8+j]);
431  }
432  printf("\n");
433  }
434 #endif
435  }
436  printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
437 
438  if (!speed)
439  return;
440 
441  ti = av_gettime_relative();
442  it1 = 0;
443  do {
444  for (it = 0; it < NB_ITS_SPEED; it++) {
445  for (i = 0; i < 64; i++)
446  block[i] = block1[i];
447  idct248_put(img_dest, 8, block);
448  }
449  it1 += NB_ITS_SPEED;
450  ti1 = av_gettime_relative() - ti;
451  } while (ti1 < 1000000);
452 
453  printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
454  (double) it1 * 1000.0 / (double) ti1);
455 }
456 
457 static void help(void)
458 {
459  printf("dct-test [-i] [<test-number>] [<bits>]\n"
460  "test-number 0 -> test with random matrixes\n"
461  " 1 -> test with random sparse matrixes\n"
462  " 2 -> do 3. test from MPEG-4 std\n"
463  "bits Number of time domain bits to use, 8 is default\n"
464  "-i test IDCT implementations\n"
465  "-4 test IDCT248 implementations\n"
466  "-t speed test\n");
467 }
468 
469 #if !HAVE_GETOPT
470 #include "compat/getopt.c"
471 #endif
472 
473 int main(int argc, char **argv)
474 {
475  int test_idct = 0, test_248_dct = 0;
476  int c, i;
477  int test = 1;
478  int speed = 0;
479  int err = 0;
480  int bits=8;
481 
482  ff_ref_dct_init();
483 
484  for (;;) {
485  c = getopt(argc, argv, "ih4t");
486  if (c == -1)
487  break;
488  switch (c) {
489  case 'i':
490  test_idct = 1;
491  break;
492  case '4':
493  test_248_dct = 1;
494  break;
495  case 't':
496  speed = 1;
497  break;
498  default:
499  case 'h':
500  help();
501  return 0;
502  }
503  }
504 
505  if (optind < argc)
506  test = atoi(argv[optind]);
507  if(optind+1 < argc) bits= atoi(argv[optind+1]);
508 
509  printf("ffmpeg DCT/IDCT test\n");
510 
511  if (test_248_dct) {
512  idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
513  } else {
514  const int cpu_flags = av_get_cpu_flags();
515  if (test_idct) {
516  for (i = 0; i < FF_ARRAY_ELEMS(idct_tab); i++)
517  err |= dct_error(&idct_tab[i], test, test_idct, speed, bits);
518 
519  for (i = 0; idct_tab_arch[i].name; i++)
520  if (!(~cpu_flags & idct_tab_arch[i].cpu_flag))
521  err |= dct_error(&idct_tab_arch[i], test, test_idct, speed, bits);
522  }
523 #if CONFIG_FDCTDSP
524  else {
525  for (i = 0; i < FF_ARRAY_ELEMS(fdct_tab); i++)
526  err |= dct_error(&fdct_tab[i], test, test_idct, speed, bits);
527 
528  for (i = 0; fdct_tab_arch[i].name; i++)
529  if (!(~cpu_flags & fdct_tab_arch[i].cpu_flag))
530  err |= dct_error(&fdct_tab_arch[i], test, test_idct, speed, bits);
531  }
532 #endif /* CONFIG_FDCTDSP */
533  }
534 
535  if (err)
536  printf("Error: %d.\n", err);
537 
538  return !!err;
539 }
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
av_clip
#define av_clip
Definition: common.h:100
printf
__device__ int printf(const char *,...)
mem_internal.h
av_lfg_init
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
ff_ref_dct_init
av_cold void ff_ref_dct_init(void)
Initialize the double precision discrete cosine transform functions fdct & idct.
Definition: dctref.c:41
algo::nonspec
int nonspec
Definition: dct.c:63
dct.c
int64_t
long long int64_t
Definition: coverity.c:34
AANSCALE_BITS
#define AANSCALE_BITS
Definition: dct.c:120
permute
static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
Definition: dct.c:158
test
Definition: idctdsp.c:35
permute_x86
static int permute_x86(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
Definition: dct.c:113
fdct_tab
static const struct algo fdct_tab[]
Definition: dct.c:66
cpu_flag
int cpu_flag
Definition: checkasm.c:435
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_get_cpu_flags
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
Definition: cpu.c:109
cpu_flags
static atomic_int cpu_flags
Definition: cpu.c:56
img_dest1
static uint8_t img_dest1[64]
Definition: dct.c:299
ff_simple_idct_int16_10bit
void ff_simple_idct_int16_10bit(int16_t *block)
ff_j_rev_dct
void ff_j_rev_dct(int16_t data[64])
faandct.h
Floating point AAN DCT.
prores_idct_10
static void prores_idct_10(int16_t *restrict block, const int16_t *restrict qmat)
Special version of ff_simple_idct_int16_10bit() which does dequantization and scales by a factor of 2...
Definition: proresdsp.c:49
ff_simple_idct248_put
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
Definition: simple_idct.c:100
proresdsp.c
help
static void help(void)
Definition: dct.c:457
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
dct.h
init_block
static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
Definition: dct.c:128
LOCAL_ALIGNED
#define LOCAL_ALIGNED(a, t, v,...)
Definition: mem_internal.h:124
main
int main(int argc, char **argv)
Definition: dct.c:473
s
#define s(width, name)
Definition: cbs_vp9.c:198
av_lfg_get
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
Definition: lfg.h:53
ff_xvid_idct
void ff_xvid_idct(int16_t *const in)
Definition: xvididct.c:290
lfg.h
ff_faanidct
void ff_faanidct(int16_t block[64])
Definition: faanidct.c:128
bits
uint8_t bits
Definition: vp3data.h:128
simple_idct.h
idct248_error
static void idct248_error(const char *name, void(*idct248_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block), int speed)
Definition: dct.c:381
xvididct.h
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
algo::cpu_flag
int cpu_flag
Definition: dct.c:62
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
rint
#define rint
Definition: tablegen.h:41
aandcttab.h
ff_faandct
void ff_faandct(int16_t *data)
Definition: faandct.c:115
dct_error
static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
Definition: dct.c:188
double
double
Definition: af_crystalizer.c:132
time.h
abs
#define abs(x)
Definition: cuda_runtime.h:35
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVLFG
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
NB_ITS
#define NB_ITS
Definition: dct.c:122
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
block
static int16_t block[64]
Definition: dct.c:125
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
cpu.h
FF_IDCT_PERM_NONE
@ FF_IDCT_PERM_NONE
Definition: idctdsp.h:28
fdct_tab_arch
static const struct algo fdct_tab_arch[]
Definition: dct.c:116
dct.c
block1
static int16_t block1[64]
Definition: dct.c:126
algo::func
void(* func)(int16_t *block)
Definition: dct.c:60
idct248_ref
static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
Definition: dct.c:301
faanidct.h
M_PI
#define M_PI
Definition: mathematics.h:67
ff_simple_idct_int16_8bit
void ff_simple_idct_int16_8bit(int16_t *block)
NB_ITS_SPEED
#define NB_ITS_SPEED
Definition: dct.c:123
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_jpeg_fdct_islow_8
void ff_jpeg_fdct_islow_8(int16_t *data)
algo
Definition: dct.c:58
internal.h
common.h
dct
static void dct(AudioRNNContext *s, float *out, const float *in)
Definition: af_arnndn.c:1010
fdctdsp.h
optind
static int optind
Definition: getopt.c:37
idctdsp.h
FF_IDCT_PERM_TRANSPOSE
@ FF_IDCT_PERM_TRANSPOSE
Definition: idctdsp.h:31
ff_fdct_ifast
void ff_fdct_ifast(int16_t *data)
Definition: jfdctfst.c:207
getopt.c
img_dest
static uint8_t img_dest[64]
Definition: dct.c:298
idct_tab
static const struct algo idct_tab[]
Definition: dct.c:90
FF_IDCT_PERM_PARTTRANS
@ FF_IDCT_PERM_PARTTRANS
Definition: idctdsp.h:32
ff_simple_idct_int16_12bit
void ff_simple_idct_int16_12bit(int16_t *block)
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
ff_ref_fdct
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
idct_permutation_type
idct_permutation_type
Definition: idctdsp.h:27
dctref.h
idct_tab_arch
static const struct algo idct_tab_arch[]
Definition: dct.c:117
it
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s it
Definition: writing_filters.txt:31
ff_ref_idct
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
algo::perm_type
enum idct_permutation_type perm_type
Definition: dct.c:61
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
getopt
static int getopt(int argc, char *argv[], const char *opts)
Definition: getopt.c:41
algo::name
const char * name
Definition: dct.c:59
dct.c
dct.c
src
#define src
Definition: vp8dsp.c:248
FF_IDCT_PERM_LIBMPEG2
@ FF_IDCT_PERM_LIBMPEG2
Definition: idctdsp.h:29
ff_aanscales
const uint16_t ff_aanscales[64]
Definition: aandcttab.c:26
Generated on Thu Nov 13 2025 19:22:50 for FFmpeg by   doxygen 1.8.17