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