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/emms.h"

41 #include "libavutil/internal.h"

42 #include "libavutil/lfg.h"

43 #include "libavutil/mem_internal.h"

44 #include "libavutil/time.h"

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"

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

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

73 static void ff_prores_idct_wrap(int16_t *dst){

74 LOCAL_ALIGNED(16, int16_t, qmat, [64]);

75 int i;

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 }

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 * (int64_t)v;

230 err2 += v * (int64_t)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:100

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

dct.c

int64_t

long long int64_t

Definition: coverity.c:34

AANSCALE_BITS

#define AANSCALE_BITS

Definition: dct.c:114

permute

static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)

Definition: dct.c:152

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

cpu_flag

int cpu_flag

Definition: checkasm.c:390

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

cpu_flags

static atomic_int cpu_flags

Definition: cpu.c:56

img_dest1

static uint8_t img_dest1[64]

Definition: dct.c:295

ff_simple_idct_int16_10bit

void ff_simple_idct_int16_10bit(int16_t *block)

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

help

static void help(void)

Definition: dct.c:454

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

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

emms_c

#define emms_c()

Definition: emms.h:63

main

int main(int argc, char **argv)

Definition: dct.c:470

#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

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

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

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

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

ff_prores_idct_wrap

static void ff_prores_idct_wrap(int16_t *dst)

Definition: dct.c:73

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

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

block

static int16_t block[64]

Definition: dct.c:119

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

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

printf

printf("static const uint8_t my_array[100] = {\n")

dct.c

block1

static int16_t block1[64]

Definition: dct.c:120

algo::func

void(* func)(int16_t *block)

Definition: dct.c:58

idct248_ref

static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)

Definition: dct.c:297

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

#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:56

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_j_rev_dct

void ff_j_rev_dct(int16_t *data)

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

idct_tab

static const struct algo idct_tab[]

Definition: dct.c:86

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

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

Definition: idctdsp.h:27

dctref.h

idct_tab_arch

static const struct algo idct_tab_arch[]

Definition: dct.c:111

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

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:291

algo::name