FFmpeg: libavcodec/tests/dct.c Source File

FFmpeg

[フレーム]

dct.c

Go to the documentation of this file.

1 /*

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 */

22 /**

23 * @file

25 * Started from sample code by Juan J. Sierralta P.

26 */

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>

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"

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

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 };

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 };

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;

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

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:438

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

#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

Definition: af_crystalizer.c:132

time.h

abs

#define abs(x)

Definition: cuda_runtime.h:35

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

#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

Definition: idctdsp.h:27

dctref.h

idct_tab_arch

static const struct algo idct_tab_arch[]

Definition: dct.c:117

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