mov: fix operator precedence bug
[libav.git] / libavcodec / dct-test.c
CommitLineData
04d7f601
DB
1/*
2 * (c) 2001 Fabrice Bellard
3ac35bdb 3 * 2007 Marc Hoffman <marc.hoffman@analog.com>
04d7f601 4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
04d7f601
DB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
04d7f601 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
04d7f601
DB
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
04d7f601
DB
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
983e3246 22/**
ba87f080 23 * @file
94f694a4 24 * DCT test (c) 2001 Fabrice Bellard
983e3246
MN
25 * Started from sample code by Juan J. Sierralta P.
26 */
27
de6d9b64
FB
28#include <stdlib.h>
29#include <stdio.h>
30#include <string.h>
31#include <sys/time.h>
32#include <unistd.h>
12807c8d 33#include <math.h>
de6d9b64 34
c6c98d08 35#include "libavutil/cpu.h"
ae32e509 36#include "libavutil/common.h"
294eaa26 37#include "libavutil/lfg.h"
de6d9b64 38
86748dbc 39#include "simple_idct.h"
10ac3618 40#include "aandcttab.h"
65e4c8c9 41#include "faandct.h"
6f08c541 42#include "faanidct.h"
a6493a8f 43#include "x86/idct_xvid.h"
6a813295 44#include "dctref.h"
9e1586fc 45
434df899
MN
46#undef printf
47
9686df2b
DB
48void ff_mmx_idct(DCTELEM *data);
49void ff_mmxext_idct(DCTELEM *data);
9e1586fc 50
3ac35bdb 51// BFIN
9686df2b
DB
52void ff_bfin_idct(DCTELEM *block);
53void ff_bfin_fdct(DCTELEM *block);
3ac35bdb
MH
54
55// ALTIVEC
07333750
MS
56void ff_fdct_altivec(DCTELEM *block);
57//void ff_idct_altivec(DCTELEM *block);?? no routine
3ac35bdb 58
479044ce 59// ARM
0926c009
MR
60void ff_j_rev_dct_arm(DCTELEM *data);
61void ff_simple_idct_arm(DCTELEM *data);
62void ff_simple_idct_armv5te(DCTELEM *data);
479044ce
MR
63void ff_simple_idct_armv6(DCTELEM *data);
64void ff_simple_idct_neon(DCTELEM *data);
3ac35bdb 65
2a839eeb
MR
66void ff_simple_idct_axp(DCTELEM *data);
67
3ac35bdb 68struct algo {
36fa9ef3 69 const char *name;
36fa9ef3 70 void (*func)(DCTELEM *block);
36fa9ef3
MR
71 enum formattag { NO_PERM, MMX_PERM, MMX_SIMPLE_PERM, SCALE_PERM,
72 SSE2_PERM, PARTTRANS_PERM } format;
73 int mm_support;
dbf396d4 74 int nonspec;
3ac35bdb
MH
75};
76
aadd27cd
MN
77static int cpu_flags;
78
4b357756 79static const struct algo fdct_tab[] = {
74965f26 80 { "REF-DBL", ff_ref_fdct, NO_PERM },
856c8e0a 81 { "FAAN", ff_faandct, NO_PERM },
3e2efacd 82 { "IJG-AAN-INT", ff_fdct_ifast, SCALE_PERM },
0a72533e 83 { "IJG-LLM-INT", ff_jpeg_fdct_islow_8, NO_PERM },
3ac35bdb 84
b250f9c6 85#if HAVE_MMX
74965f26
MR
86 { "MMX", ff_fdct_mmx, NO_PERM, AV_CPU_FLAG_MMX },
87 { "MMX2", ff_fdct_mmx2, NO_PERM, AV_CPU_FLAG_MMX2 },
88 { "SSE2", ff_fdct_sse2, NO_PERM, AV_CPU_FLAG_SSE2 },
94254fc0 89#endif
3ac35bdb 90
4b357756 91#if HAVE_ALTIVEC
07333750 92 { "altivecfdct", ff_fdct_altivec, NO_PERM, AV_CPU_FLAG_ALTIVEC },
4b357756
MR
93#endif
94
95#if ARCH_BFIN
74965f26 96 { "BFINfdct", ff_bfin_fdct, NO_PERM },
4b357756
MR
97#endif
98
99 { 0 }
100};
101
102static const struct algo idct_tab[] = {
74965f26
MR
103 { "FAANI", ff_faanidct, NO_PERM },
104 { "REF-DBL", ff_ref_idct, NO_PERM },
c8e1b2fb 105 { "INT", ff_j_rev_dct, MMX_PERM },
e7a972e1 106 { "SIMPLE-C", ff_simple_idct_8, NO_PERM },
4b357756
MR
107
108#if HAVE_MMX
b250f9c6 109#if CONFIG_GPL
74965f26
MR
110 { "LIBMPEG2-MMX", ff_mmx_idct, MMX_PERM, AV_CPU_FLAG_MMX, 1 },
111 { "LIBMPEG2-MMX2", ff_mmxext_idct, MMX_PERM, AV_CPU_FLAG_MMX2, 1 },
b9702de5 112#endif
74965f26
MR
113 { "SIMPLE-MMX", ff_simple_idct_mmx, MMX_SIMPLE_PERM, AV_CPU_FLAG_MMX },
114 { "XVID-MMX", ff_idct_xvid_mmx, NO_PERM, AV_CPU_FLAG_MMX, 1 },
115 { "XVID-MMX2", ff_idct_xvid_mmx2, NO_PERM, AV_CPU_FLAG_MMX2, 1 },
116 { "XVID-SSE2", ff_idct_xvid_sse2, SSE2_PERM, AV_CPU_FLAG_SSE2, 1 },
3ac35bdb
MH
117#endif
118
b250f9c6 119#if ARCH_BFIN
74965f26 120 { "BFINidct", ff_bfin_idct, NO_PERM },
3ac35bdb
MH
121#endif
122
b250f9c6 123#if ARCH_ARM
74965f26
MR
124 { "SIMPLE-ARM", ff_simple_idct_arm, NO_PERM },
125 { "INT-ARM", ff_j_rev_dct_arm, MMX_PERM },
4b357756 126#endif
b250f9c6 127#if HAVE_ARMV5TE
74965f26 128 { "SIMPLE-ARMV5TE", ff_simple_idct_armv5te,NO_PERM },
479044ce 129#endif
b250f9c6 130#if HAVE_ARMV6
74965f26 131 { "SIMPLE-ARMV6", ff_simple_idct_armv6, MMX_PERM },
479044ce 132#endif
b250f9c6 133#if HAVE_NEON
74965f26 134 { "SIMPLE-NEON", ff_simple_idct_neon, PARTTRANS_PERM },
479044ce 135#endif
479044ce 136
2a839eeb 137#if ARCH_ALPHA
74965f26 138 { "SIMPLE-ALPHA", ff_simple_idct_axp, NO_PERM },
2a839eeb
MR
139#endif
140
36fa9ef3 141 { 0 }
3ac35bdb
MH
142};
143
de6d9b64 144#define AANSCALE_BITS 12
de6d9b64 145
504ffed1 146static int64_t gettime(void)
de6d9b64
FB
147{
148 struct timeval tv;
36fa9ef3 149 gettimeofday(&tv, NULL);
0c1a9eda 150 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
de6d9b64
FB
151}
152
153#define NB_ITS 20000
154#define NB_ITS_SPEED 50000
155
9e1586fc
FB
156static short idct_mmx_perm[64];
157
36fa9ef3
MR
158static short idct_simple_mmx_perm[64] = {
159 0x00, 0x08, 0x04, 0x09, 0x01, 0x0C, 0x05, 0x0D,
160 0x10, 0x18, 0x14, 0x19, 0x11, 0x1C, 0x15, 0x1D,
161 0x20, 0x28, 0x24, 0x29, 0x21, 0x2C, 0x25, 0x2D,
162 0x12, 0x1A, 0x16, 0x1B, 0x13, 0x1E, 0x17, 0x1F,
163 0x02, 0x0A, 0x06, 0x0B, 0x03, 0x0E, 0x07, 0x0F,
164 0x30, 0x38, 0x34, 0x39, 0x31, 0x3C, 0x35, 0x3D,
165 0x22, 0x2A, 0x26, 0x2B, 0x23, 0x2E, 0x27, 0x2F,
166 0x32, 0x3A, 0x36, 0x3B, 0x33, 0x3E, 0x37, 0x3F,
86748dbc
MN
167};
168
36fa9ef3 169static const uint8_t idct_sse2_row_perm[8] = { 0, 4, 1, 5, 2, 6, 3, 7 };
ad246860 170
504ffed1 171static void idct_mmx_init(void)
9e1586fc
FB
172{
173 int i;
174
175 /* the mmx/mmxext idct uses a reordered input, so we patch scan tables */
176 for (i = 0; i < 64; i++) {
bb270c08 177 idct_mmx_perm[i] = (i & 0x38) | ((i & 6) >> 1) | ((i & 1) << 2);
9e1586fc
FB
178 }
179}
180
c6727809 181DECLARE_ALIGNED(16, static DCTELEM, block)[64];
36fa9ef3 182DECLARE_ALIGNED(8, static DCTELEM, block1)[64];
9e1586fc 183
aadd27cd
MN
184static inline void mmx_emms(void)
185{
b250f9c6 186#if HAVE_MMX
7160bb71 187 if (cpu_flags & AV_CPU_FLAG_MMX)
be449fca 188 __asm__ volatile ("emms\n\t");
aadd27cd
MN
189#endif
190}
191
ae2e8971
MR
192static void init_block(DCTELEM block[64], int test, int is_idct, AVLFG *prng)
193{
194 int i, j;
195
196 memset(block, 0, 64 * sizeof(*block));
197
198 switch (test) {
199 case 0:
200 for (i = 0; i < 64; i++)
201 block[i] = (av_lfg_get(prng) % 512) - 256;
202 if (is_idct) {
203 ff_ref_fdct(block);
204 for (i = 0; i < 64; i++)
205 block[i] >>= 3;
206 }
207 break;
208 case 1:
209 j = av_lfg_get(prng) % 10 + 1;
210 for (i = 0; i < j; i++)
211 block[av_lfg_get(prng) % 64] = av_lfg_get(prng) % 512 - 256;
212 break;
213 case 2:
214 block[ 0] = av_lfg_get(prng) % 4096 - 2048;
215 block[63] = (block[0] & 1) ^ 1;
216 break;
217 }
218}
219
220static void permute(DCTELEM dst[64], const DCTELEM src[64], int perm)
221{
222 int i;
223
224 if (perm == MMX_PERM) {
225 for (i = 0; i < 64; i++)
226 dst[idct_mmx_perm[i]] = src[i];
227 } else if (perm == MMX_SIMPLE_PERM) {
228 for (i = 0; i < 64; i++)
229 dst[idct_simple_mmx_perm[i]] = src[i];
230 } else if (perm == SSE2_PERM) {
231 for (i = 0; i < 64; i++)
232 dst[(i & 0x38) | idct_sse2_row_perm[i & 7]] = src[i];
233 } else if (perm == PARTTRANS_PERM) {
234 for (i = 0; i < 64; i++)
235 dst[(i & 0x24) | ((i & 3) << 3) | ((i >> 3) & 3)] = src[i];
236 } else {
237 for (i = 0; i < 64; i++)
238 dst[i] = src[i];
239 }
240}
241
dbf396d4 242static int dct_error(const struct algo *dct, int test, int is_idct, int speed)
de6d9b64 243{
74965f26 244 void (*ref)(DCTELEM *block) = is_idct ? ff_ref_idct : ff_ref_fdct;
de6d9b64 245 int it, i, scale;
de6d9b64 246 int err_inf, v;
dbf396d4 247 int64_t err2, ti, ti1, it1, err_sum = 0;
36fa9ef3
MR
248 int64_t sysErr[64], sysErrMax = 0;
249 int maxout = 0;
250 int blockSumErrMax = 0, blockSumErr;
64bde197 251 AVLFG prng;
dbf396d4
MR
252 double omse, ome;
253 int spec_err;
de6d9b64 254
64bde197 255 av_lfg_init(&prng, 1);
de6d9b64
FB
256
257 err_inf = 0;
258 err2 = 0;
36fa9ef3
MR
259 for (i = 0; i < 64; i++)
260 sysErr[i] = 0;
261 for (it = 0; it < NB_ITS; it++) {
ae2e8971
MR
262 init_block(block1, test, is_idct, &prng);
263 permute(block, block1, dct->format);
9e1586fc 264
4f905a65 265 dct->func(block);
aadd27cd 266 mmx_emms();
9e1586fc 267
4f905a65 268 if (dct->format == SCALE_PERM) {
36fa9ef3
MR
269 for (i = 0; i < 64; i++) {
270 scale = 8 * (1 << (AANSCALE_BITS + 11)) / ff_aanscales[i];
271 block[i] = (block[i] * scale) >> AANSCALE_BITS;
86748dbc
MN
272 }
273 }
274
74965f26 275 ref(block1);
de6d9b64 276
36fa9ef3
MR
277 blockSumErr = 0;
278 for (i = 0; i < 64; i++) {
dbf396d4
MR
279 int err = block[i] - block1[i];
280 err_sum += err;
281 v = abs(err);
de6d9b64
FB
282 if (v > err_inf)
283 err_inf = v;
284 err2 += v * v;
bb270c08
DB
285 sysErr[i] += block[i] - block1[i];
286 blockSumErr += v;
36fa9ef3
MR
287 if (abs(block[i]) > maxout)
288 maxout = abs(block[i]);
de6d9b64 289 }
36fa9ef3
MR
290 if (blockSumErrMax < blockSumErr)
291 blockSumErrMax = blockSumErr;
86748dbc 292 }
36fa9ef3
MR
293 for (i = 0; i < 64; i++)
294 sysErrMax = FFMAX(sysErrMax, FFABS(sysErr[i]));
115329f1 295
36fa9ef3
MR
296 for (i = 0; i < 64; i++) {
297 if (i % 8 == 0)
298 printf("\n");
299 printf("%7d ", (int) sysErr[i]);
de6d9b64 300 }
86748dbc 301 printf("\n");
115329f1 302
dbf396d4
MR
303 omse = (double) err2 / NB_ITS / 64;
304 ome = (double) err_sum / NB_ITS / 64;
305
306 spec_err = is_idct && (err_inf > 1 || omse > 0.02 || fabs(ome) > 0.0015);
307
308 printf("%s %s: ppe=%d omse=%0.8f ome=%0.8f syserr=%0.8f maxout=%d blockSumErr=%d\n",
cf2b4f88 309 is_idct ? "IDCT" : "DCT", dct->name, err_inf,
dbf396d4 310 omse, ome, (double) sysErrMax / NB_ITS,
36fa9ef3 311 maxout, blockSumErrMax);
e6ff0648 312
dbf396d4
MR
313 if (spec_err && !dct->nonspec)
314 return 1;
315
7fd2c138 316 if (!speed)
dbf396d4 317 return 0;
7fd2c138 318
de6d9b64 319 /* speed test */
ae2e8971
MR
320 init_block(block, test, is_idct, &prng);
321 permute(block1, block, dct->format);
9e1586fc 322
de6d9b64
FB
323 ti = gettime();
324 it1 = 0;
325 do {
36fa9ef3 326 for (it = 0; it < NB_ITS_SPEED; it++) {
ae2e8971 327 memcpy(block, block1, sizeof(block));
4f905a65 328 dct->func(block);
de6d9b64
FB
329 }
330 it1 += NB_ITS_SPEED;
331 ti1 = gettime() - ti;
332 } while (ti1 < 1000000);
aadd27cd 333 mmx_emms();
de6d9b64 334
cf2b4f88 335 printf("%s %s: %0.1f kdct/s\n", is_idct ? "IDCT" : "DCT", dct->name,
36fa9ef3 336 (double) it1 * 1000.0 / (double) ti1);
dbf396d4
MR
337
338 return 0;
de6d9b64
FB
339}
340
c6727809
MR
341DECLARE_ALIGNED(8, static uint8_t, img_dest)[64];
342DECLARE_ALIGNED(8, static uint8_t, img_dest1)[64];
a46a3ce4 343
504ffed1 344static void idct248_ref(uint8_t *dest, int linesize, int16_t *block)
a46a3ce4
FB
345{
346 static int init;
347 static double c8[8][8];
348 static double c4[4][4];
349 double block1[64], block2[64], block3[64];
350 double s, sum, v;
351 int i, j, k;
352
353 if (!init) {
354 init = 1;
355
36fa9ef3 356 for (i = 0; i < 8; i++) {
a46a3ce4 357 sum = 0;
36fa9ef3
MR
358 for (j = 0; j < 8; j++) {
359 s = (i == 0) ? sqrt(1.0 / 8.0) : sqrt(1.0 / 4.0);
a46a3ce4
FB
360 c8[i][j] = s * cos(M_PI * i * (j + 0.5) / 8.0);
361 sum += c8[i][j] * c8[i][j];
362 }
363 }
115329f1 364
36fa9ef3 365 for (i = 0; i < 4; i++) {
a46a3ce4 366 sum = 0;
36fa9ef3
MR
367 for (j = 0; j < 4; j++) {
368 s = (i == 0) ? sqrt(1.0 / 4.0) : sqrt(1.0 / 2.0);
a46a3ce4
FB
369 c4[i][j] = s * cos(M_PI * i * (j + 0.5) / 4.0);
370 sum += c4[i][j] * c4[i][j];
371 }
372 }
373 }
374
375 /* butterfly */
652f0197 376 s = 0.5 * sqrt(2.0);
36fa9ef3
MR
377 for (i = 0; i < 4; i++) {
378 for (j = 0; j < 8; j++) {
379 block1[8 * (2 * i) + j] =
380 (block[8 * (2 * i) + j] + block[8 * (2 * i + 1) + j]) * s;
381 block1[8 * (2 * i + 1) + j] =
382 (block[8 * (2 * i) + j] - block[8 * (2 * i + 1) + j]) * s;
a46a3ce4
FB
383 }
384 }
385
386 /* idct8 on lines */
36fa9ef3
MR
387 for (i = 0; i < 8; i++) {
388 for (j = 0; j < 8; j++) {
a46a3ce4 389 sum = 0;
36fa9ef3
MR
390 for (k = 0; k < 8; k++)
391 sum += c8[k][j] * block1[8 * i + k];
392 block2[8 * i + j] = sum;
a46a3ce4
FB
393 }
394 }
395
396 /* idct4 */
36fa9ef3
MR
397 for (i = 0; i < 8; i++) {
398 for (j = 0; j < 4; j++) {
a46a3ce4
FB
399 /* top */
400 sum = 0;
36fa9ef3
MR
401 for (k = 0; k < 4; k++)
402 sum += c4[k][j] * block2[8 * (2 * k) + i];
403 block3[8 * (2 * j) + i] = sum;
a46a3ce4
FB
404
405 /* bottom */
406 sum = 0;
36fa9ef3
MR
407 for (k = 0; k < 4; k++)
408 sum += c4[k][j] * block2[8 * (2 * k + 1) + i];
409 block3[8 * (2 * j + 1) + i] = sum;
a46a3ce4
FB
410 }
411 }
412
413 /* clamp and store the result */
36fa9ef3
MR
414 for (i = 0; i < 8; i++) {
415 for (j = 0; j < 8; j++) {
416 v = block3[8 * i + j];
417 if (v < 0) v = 0;
418 else if (v > 255) v = 255;
419 dest[i * linesize + j] = (int) rint(v);
a46a3ce4
FB
420 }
421 }
422}
423
504ffed1 424static void idct248_error(const char *name,
36fa9ef3 425 void (*idct248_put)(uint8_t *dest, int line_size,
7fd2c138
MR
426 int16_t *block),
427 int speed)
a46a3ce4
FB
428{
429 int it, i, it1, ti, ti1, err_max, v;
64bde197 430 AVLFG prng;
294eaa26 431
64bde197 432 av_lfg_init(&prng, 1);
115329f1 433
a46a3ce4
FB
434 /* just one test to see if code is correct (precision is less
435 important here) */
436 err_max = 0;
36fa9ef3 437 for (it = 0; it < NB_ITS; it++) {
652f0197 438 /* XXX: use forward transform to generate values */
36fa9ef3 439 for (i = 0; i < 64; i++)
64bde197 440 block1[i] = av_lfg_get(&prng) % 256 - 128;
652f0197
FB
441 block1[0] += 1024;
442
36fa9ef3
MR
443 for (i = 0; i < 64; i++)
444 block[i] = block1[i];
a46a3ce4 445 idct248_ref(img_dest1, 8, block);
115329f1 446
36fa9ef3
MR
447 for (i = 0; i < 64; i++)
448 block[i] = block1[i];
652f0197 449 idct248_put(img_dest, 8, block);
115329f1 450
36fa9ef3
MR
451 for (i = 0; i < 64; i++) {
452 v = abs((int) img_dest[i] - (int) img_dest1[i]);
652f0197
FB
453 if (v == 255)
454 printf("%d %d\n", img_dest[i], img_dest1[i]);
455 if (v > err_max)
456 err_max = v;
457 }
a46a3ce4 458 }
36fa9ef3 459 printf("%s %s: err_inf=%d\n", 1 ? "IDCT248" : "DCT248", name, err_max);
a46a3ce4 460
7fd2c138
MR
461 if (!speed)
462 return;
463
a46a3ce4
FB
464 ti = gettime();
465 it1 = 0;
466 do {
36fa9ef3
MR
467 for (it = 0; it < NB_ITS_SPEED; it++) {
468 for (i = 0; i < 64; i++)
469 block[i] = block1[i];
a46a3ce4
FB
470 idct248_put(img_dest, 8, block);
471 }
472 it1 += NB_ITS_SPEED;
473 ti1 = gettime() - ti;
474 } while (ti1 < 1000000);
aadd27cd 475 mmx_emms();
a46a3ce4 476
36fa9ef3
MR
477 printf("%s %s: %0.1f kdct/s\n", 1 ? "IDCT248" : "DCT248", name,
478 (double) it1 * 1000.0 / (double) ti1);
a46a3ce4
FB
479}
480
504ffed1 481static void help(void)
9e1586fc 482{
86748dbc
MN
483 printf("dct-test [-i] [<test-number>]\n"
484 "test-number 0 -> test with random matrixes\n"
485 " 1 -> test with random sparse matrixes\n"
486 " 2 -> do 3. test from mpeg4 std\n"
a46a3ce4 487 "-i test IDCT implementations\n"
7fd2c138
MR
488 "-4 test IDCT248 implementations\n"
489 "-t speed test\n");
9e1586fc
FB
490}
491
de6d9b64
FB
492int main(int argc, char **argv)
493{
a46a3ce4 494 int test_idct = 0, test_248_dct = 0;
36fa9ef3
MR
495 int c, i;
496 int test = 1;
7fd2c138 497 int speed = 0;
dbf396d4 498 int err = 0;
36fa9ef3 499
c6c98d08 500 cpu_flags = av_get_cpu_flags();
9e1586fc 501
0de74546 502 ff_ref_dct_init();
9e1586fc 503 idct_mmx_init();
f67a10cd 504
36fa9ef3 505 for (;;) {
7fd2c138 506 c = getopt(argc, argv, "ih4t");
9e1586fc
FB
507 if (c == -1)
508 break;
36fa9ef3 509 switch (c) {
9e1586fc
FB
510 case 'i':
511 test_idct = 1;
512 break;
a46a3ce4
FB
513 case '4':
514 test_248_dct = 1;
515 break;
7fd2c138
MR
516 case 't':
517 speed = 1;
518 break;
36fa9ef3 519 default:
9e1586fc
FB
520 case 'h':
521 help();
c6bdc908 522 return 0;
9e1586fc
FB
523 }
524 }
115329f1 525
36fa9ef3
MR
526 if (optind < argc)
527 test = atoi(argv[optind]);
115329f1 528
f36b3902 529 printf("Libav DCT/IDCT test\n");
9e1586fc 530
a46a3ce4 531 if (test_248_dct) {
7fd2c138 532 idct248_error("SIMPLE-C", ff_simple_idct248_put, speed);
9e1586fc 533 } else {
4b357756 534 const struct algo *algos = test_idct ? idct_tab : fdct_tab;
36fa9ef3 535 for (i = 0; algos[i].name; i++)
4b357756 536 if (!(~cpu_flags & algos[i].mm_support)) {
dbf396d4 537 err |= dct_error(&algos[i], test, test_idct, speed);
36fa9ef3 538 }
9e1586fc 539 }
dbf396d4
MR
540
541 return err;
de6d9b64 542}