92 #if CONFIG_MPEG4_DECODER
110 #define AANSCALE_BITS 12
113 #define NB_ITS_SPEED 50000
122 memset(block, 0, 64 *
sizeof(*block));
126 for (i = 0; i < 64; i++)
127 block[i] = (
av_lfg_get(prng) % (2*vals)) -vals;
130 for (i = 0; i < 64; i++)
136 for (i = 0; i < j; i++) {
138 block[idx] =
av_lfg_get(prng) % (2*vals) -vals;
142 block[ 0] =
av_lfg_get(prng) % (16*vals) - (8*vals);
143 block[63] = (block[0] & 1) ^ 1;
160 for (i = 0; i < 64; i++)
161 dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
164 for (i = 0; i < 64; i++)
165 dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
168 for (i = 0; i < 64; i++)
169 dst[(i>>3) | ((i<<3)&0x38)] = src[i];
172 for (i = 0; i < 64; i++)
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;
187 int blockSumErrMax = 0, blockSumErr;
189 const int vals=1<<bits;
197 for (i = 0; i < 64; i++)
198 err2_matrix[i] = sysErr[i] = 0;
199 for (it = 0; it <
NB_ITS; it++) {
206 if (!strcmp(dct->
name,
"IJG-AAN-INT")) {
207 for (i = 0; i < 64; i++) {
214 if (!strcmp(dct->
name,
"PR-SSE2"))
215 for (i = 0; i < 64; i++)
219 for (i = 0; i < 64; i++) {
225 err2_matrix[i] += v * v;
227 sysErr[i] +=
block[i] - block1[i];
229 if (abs(
block[i]) > maxout)
230 maxout = abs(
block[i]);
232 if (blockSumErrMax < blockSumErr)
233 blockSumErrMax = blockSumErr;
235 for (i = 0; i < 64; i++) {
236 sysErrMax =
FFMAX(sysErrMax,
FFABS(sysErr[i]));
237 err2_max =
FFMAX(err2_max ,
FFABS(err2_matrix[i]));
240 for (i = 0; i < 64; i++) {
243 printf(
"%7d ", (
int) sysErr[i]);
247 omse = (double) err2 / NB_ITS / 64;
248 ome = (double) err_sum / NB_ITS / 64;
250 spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
252 spec_err = is_idct && ((double) err2_max / NB_ITS > 0.06 || (
double) sysErrMax / NB_ITS > 0.015);
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);
259 if (spec_err && !dct->
nonspec) {
282 }
while (ti1 < 1000000);
284 printf(
"%s %s: %0.1f kdct/s\n", is_idct ?
"IDCT" :
"DCT", dct->
name,
285 (
double) it1 * 1000.0 / (
double) ti1);
296 static double c8[8][8];
297 static double c4[4][4];
298 double block1[64], block2[64], block3[64];
305 for (i = 0; i < 8; i++) {
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];
314 for (i = 0; i < 4; i++) {
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];
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;
336 for (i = 0; i < 8; i++) {
337 for (j = 0; j < 8; j++) {
339 for (k = 0; k < 8; k++)
340 sum += c8[k][j] * block1[8 * i + k];
341 block2[8 * i + j] = sum;
346 for (i = 0; i < 8; i++) {
347 for (j = 0; j < 4; j++) {
350 for (k = 0; k < 4; k++)
351 sum += c4[k][j] * block2[8 * (2 * k) + i];
352 block3[8 * (2 * j) + i] = sum;
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;
363 for (i = 0; i < 8; i++) {
364 for (j = 0; j < 8; j++) {
365 v = block3[8 * i + j];
367 else if (v > 255) v = 255;
368 dest[i * linesize + j] = (
int)
rint(v);
374 void (*idct248_put)(
uint8_t *dest,
379 int it, i, it1, ti, ti1, err_max, v;
387 for (it = 0; it <
NB_ITS; it++) {
389 for (i = 0; i < 64; i++)
393 for (i = 0; i < 64; i++)
397 for (i = 0; i < 64; i++)
401 for (i = 0; i < 64; i++) {
428 printf(
"%s %s: err_inf=%d\n", 1 ?
"IDCT248" :
"DCT248", name, err_max);
437 for (i = 0; i < 64; i++)
444 }
while (ti1 < 1000000);
446 printf(
"%s %s: %0.1f kdct/s\n", 1 ?
"IDCT248" :
"DCT248", name,
447 (
double) it1 * 1000.0 / (
double) ti1);
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"
466 int main(
int argc,
char **argv)
468 int test_idct = 0, test_248_dct = 0;
478 c =
getopt(argc, argv,
"ih4t");
499 test = atoi(argv[
optind]);
500 if(optind+1 < argc) bits= atoi(argv[optind+1]);
502 printf(
"ffmpeg DCT/IDCT test\n");
510 err |=
dct_error(&idct_tab[i], test, test_idct, speed, bits);
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);
519 err |=
dct_error(&fdct_tab[i], test, test_idct, speed, bits);
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);
529 printf(
"Error: %d.\n", err);
static const struct algo idct_tab_arch[]
void ff_fdct_ifast(int16_t *data)
static av_cold int init(AVCodecContext *avctx)
void ff_simple_idct_int16_8bit(int16_t *block)
static void ff_prores_idct_wrap(int16_t *dst)
static atomic_int cpu_flags
av_cold void ff_ref_dct_init(void)
Initialize the double precision discrete cosine transform functions fdct & idct.
void ff_faanidct(int16_t block[64])
static int permute_x86(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
void ff_simple_idct_int16_12bit(int16_t *block)
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
const uint16_t ff_aanscales[64]
void ff_prores_idct(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...
static void idct248_error(const char *name, void(*idct248_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block), int speed)
static uint8_t img_dest1[64]
common internal API header
int main(int argc, char **argv)
static void permute(int16_t dst[64], const int16_t src[64], enum idct_permutation_type perm_type)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng, int vals)
static const struct algo idct_tab[]
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
static int dct_error(const struct algo *dct, int test, int is_idct, int speed, const int bits)
#define FF_ARRAY_ELEMS(a)
void ff_jpeg_fdct_islow_8(int16_t *data)
void ff_j_rev_dct(int16_t *data)
void ff_faandct(int16_t *data)
static void test(const char *pattern, const char *host)
static int getopt(int argc, char *argv[], char *opts)
static unsigned int av_lfg_get(AVLFG *c)
Get the next random unsigned 32-bit number using an ALFG.
static const struct algo fdct_tab_arch[]
void ff_ref_fdct(short *block)
Transform 8x8 block of data with a double precision forward DCT This is a reference implementation...
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
int av_get_cpu_flags(void)
Return the flags which specify extensions supported by the CPU.
void ff_xvid_idct(int16_t *const in)
void ff_simple_idct_int16_10bit(int16_t *block)
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
static uint8_t img_dest[64]
AAN (Arai, Agui and Nakajima) (I)DCT tables.
static void idct248_ref(uint8_t *dest, ptrdiff_t linesize, int16_t *block)
common internal and external API header
static int ref[MAX_W *MAX_W]
#define LOCAL_ALIGNED(a, t, v,...)
void ff_simple_idct248_put(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
enum idct_permutation_type perm_type
void ff_ref_idct(short *block)
Transform 8x8 block of data with a double precision inverse DCT This is a reference implementation...
static int16_t block1[64]
void(* func)(int16_t *block)
static const struct algo fdct_tab[]