76 #if CONFIG_MPEG4_DECODER 92 #define AANSCALE_BITS 12 95 #define NB_ITS_SPEED 50000 104 memset(block, 0, 64 *
sizeof(*block));
108 for (i = 0; i < 64; i++)
112 for (i = 0; i < 64; i++)
118 for (i = 0; i < j; i++)
123 block[63] = (block[0] & 1) ^ 1;
140 for (i = 0; i < 64; i++)
141 dst[(i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2)] = src[i];
144 for (i = 0; i < 64; i++)
145 dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
148 for (i = 0; i < 64; i++)
159 int64_t err2, ti, ti1, it1, err_sum = 0;
160 int64_t sysErr[64], sysErrMax = 0;
162 int blockSumErrMax = 0, blockSumErr;
171 for (i = 0; i < 64; i++)
173 for (it = 0; it <
NB_ITS; it++) {
180 if (!strcmp(dct->
name,
"IJG-AAN-INT")) {
181 for (i = 0; i < 64; i++) {
190 for (i = 0; i < 64; i++) {
197 sysErr[i] +=
block[i] - block1[i];
199 if (abs(
block[i]) > maxout)
200 maxout = abs(
block[i]);
202 if (blockSumErrMax < blockSumErr)
203 blockSumErrMax = blockSumErr;
205 for (i = 0; i < 64; i++)
206 sysErrMax =
FFMAX(sysErrMax,
FFABS(sysErr[i]));
208 for (i = 0; i < 64; i++) {
211 printf(
"%7d ", (
int) sysErr[i]);
215 omse = (double) err2 / NB_ITS / 64;
216 ome = (double) err_sum / NB_ITS / 64;
218 spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
220 printf(
"%s %s: ppe=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
221 is_idct ?
"IDCT" :
"DCT", dct->
name, err_inf,
222 omse, ome, (
double) sysErrMax / NB_ITS,
223 maxout, blockSumErrMax);
244 }
while (ti1 < 1000000);
247 printf(
"%s %s: %0.1f kdct/s\n", is_idct ?
"IDCT" :
"DCT", dct->
name,
248 (
double) it1 * 1000.0 / (
double) ti1);
259 static double c8[8][8];
260 static double c4[4][4];
261 double block1[64], block2[64], block3[64];
268 for (i = 0; i < 8; i++) {
270 for (j = 0; j < 8; j++) {
271 s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
272 c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
273 sum += c8[i][j] * c8[i][j];
277 for (i = 0; i < 4; i++) {
279 for (j = 0; j < 4; j++) {
280 s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
281 c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
282 sum += c4[i][j] * c4[i][j];
289 for (i = 0; i < 4; i++) {
290 for (j = 0; j < 8; j++) {
291 block1[8 * (2 * i) + j] =
292 (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
293 block1[8 * (2 * i + 1) + j] =
294 (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
299 for (i = 0; i < 8; i++) {
300 for (j = 0; j < 8; j++) {
302 for (k = 0; k < 8; k++)
303 sum += c8[k][j] * block1[8 * i + k];
304 block2[8 * i + j] = sum;
309 for (i = 0; i < 8; i++) {
310 for (j = 0; j < 4; j++) {
313 for (k = 0; k < 4; k++)
314 sum += c4[k][j] * block2[8 * (2 * k) + i];
315 block3[8 * (2 * j) + i] = sum;
319 for (k = 0; k < 4; k++)
320 sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
321 block3[8 * (2 * j + 1) + i] = sum;
326 for (i = 0; i < 8; i++) {
327 for (j = 0; j < 8; j++) {
328 v = block3[8 * i + j];
330 else if (v > 255) v = 255;
331 dest[i * linesize + j] = (int)
rint(v);
337 void (*idct248_put)(
uint8_t *dest,
int line_size,
341 int it, i, it1, ti, ti1, err_max, v;
349 for (it = 0; it <
NB_ITS; it++) {
351 for (i = 0; i < 64; i++)
355 for (i = 0; i < 64; i++)
359 for (i = 0; i < 64; i++)
363 for (i = 0; i < 64; i++) {
371 printf(
"%s %s: err_inf=%d\n", 1 ?
"IDCT248" :
"DCT248", name, err_max);
380 for (i = 0; i < 64; i++)
386 }
while (ti1 < 1000000);
389 printf(
"%s %s: %0.1f kdct/s\n", 1 ?
"IDCT248" :
"DCT248", name,
390 (
double) it1 * 1000.0 / (
double) ti1);
395 printf(
"dct-test [-i] [<test-number>]\n" 396 "test-number 0 -> test with random matrixes\n" 397 " 1 -> test with random sparse matrixes\n" 398 " 2 -> do 3. test from MPEG-4 std\n" 399 "-i test IDCT implementations\n" 400 "-4 test IDCT248 implementations\n" 408 int main(
int argc,
char **argv)
410 int test_idct = 0, test_248_dct = 0;
419 c =
getopt(argc, argv,
"ih4t");
440 test = atoi(argv[
optind]);
442 printf(
"Libav DCT/IDCT test\n");
450 err |=
dct_error(&idct_tab[i], test, test_idct, speed);
452 for (i = 0; idct_tab_arch[i].
name; i++)
453 if (!(~cpu_flags & idct_tab_arch[i].
cpu_flag))
454 err |=
dct_error(&idct_tab_arch[i], test, test_idct, speed);
459 err |=
dct_error(&fdct_tab[i], test, test_idct, speed);
461 for (i = 0; fdct_tab_arch[i].
name; i++)
462 if (!(~cpu_flags & fdct_tab_arch[i].
cpu_flag))
463 err |=
dct_error(&fdct_tab_arch[i], test, test_idct, speed);
469 printf(
"Error: %d.\n", err);
static const struct algo idct_tab_arch[]
static double rint(double x)
void ff_fdct_ifast(int16_t *data)
static void init_block(int16_t block[64], int test, int is_idct, AVLFG *prng)
#define DECLARE_ALIGNED(n, t, v)
#define FF_ARRAY_ELEMS(a)
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_idct248_put(uint8_t *dest, int line_size, int16_t *block)
const uint16_t ff_aanscales[64]
static void idct248_error(const char *name, void(*idct248_put)(uint8_t *dest, int line_size, int16_t *block), int speed)
static int dct_error(const struct algo *dct, int test, int is_idct, int speed)
static uint8_t img_dest1[64]
void(* func)(int16_t *block)
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)
static const struct algo idct_tab[]
static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
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 void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
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)
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 Nakajima) (I)DCT tables.
common internal and external API header
enum idct_permutation_type perm_type
static av_cold int init(AVCodecParserContext *s)
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]
static const struct algo fdct_tab[]
void ff_simple_idct_8(int16_t *block)