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