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