Annotation of /branches/dev-api-4/xvidcore/examples/xvid_bench.c

Revision 1220 - (view) (download)

1 :	edgomez	1054	/*****************************************************************************
2 :	Isibaar	225	*
3 :	edgomez	1054	* XVID MPEG-4 VIDEO CODEC
4 :			* - Unit tests and benches -
5 :	Isibaar	225	*
6 :	edgomez	1054	* Copyright(C) 2002 Pascal Massimino <skal@planet-d.net>
7 :	Isibaar	225	*
8 :	edgomez	1054	* This program is free software; you can redistribute it and/or modify
9 :			* it under the terms of the GNU General Public License as published by
10 :			* the Free Software Foundation; either version 2 of the License, or
11 :			* (at your option) any later version.
12 :	Isibaar	225	*
13 :	edgomez	1054	* This program is distributed in the hope that it will be useful,
14 :			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15 :			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 :			* GNU General Public License for more details.
17 :	Isibaar	225	*
18 :	edgomez	1054	* You should have received a copy of the GNU General Public License
19 :			* along with this program; if not, write to the Free Software
20 :			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 :			*
22 :	edgomez	1220	* $Id: xvid_bench.c,v 1.9.2.8 2003-11-19 21:27:25 edgomez Exp $
23 :	edgomez	1054	*
24 :			****************************************************************************/
25 :	Isibaar	225
26 :	edgomez	1054	/*****************************************************************************
27 :	Isibaar	225	*
28 :			* 'Reference' output is at the end of file.
29 :			* Don't take the checksums and crc too seriouly, they aren't
30 :	Isibaar	262	* bullet-proof (should plug some .md5 here)...
31 :	Isibaar	225	*
32 :			* compiles with something like:
33 :			* gcc -o xvid_bench xvid_bench.c -I../src/ -lxvidcore -lm
34 :			*
35 :	edgomez	1054	****************************************************************************/
36 :	Isibaar	225
37 :			#include <stdio.h>
38 :			#include <stdlib.h>
39 :	edgomez	1053	#include <string.h> /* for memset */
40 :	Isibaar	225	#include <assert.h>
41 :
42 :	suxen_drol	860	#ifndef WIN32
43 :	edgomez	1053	#include <sys/time.h> /* for gettimeofday */
44 :	suxen_drol	860	#else
45 :			#include <time.h>
46 :			#endif
47 :
48 :
49 :	Isibaar	225	#include "xvid.h"
50 :
51 :	edgomez	851	// inner guts
52 :	Isibaar	225	#include "dct/idct.h"
53 :			#include "dct/fdct.h"
54 :			#include "image/colorspace.h"
55 :			#include "image/interpolate8x8.h"
56 :			#include "utils/mem_transfer.h"
57 :	edgomez	1176	#include "quant/quant.h"
58 :	Isibaar	225	#include "motion/sad.h"
59 :			#include "utils/emms.h"
60 :			#include "utils/timer.h"
61 :			#include "quant/quant_matrix.c"
62 :			#include "bitstream/cbp.h"
63 :
64 :	Isibaar	262	#include <math.h>
65 :	suxen_drol	860
66 :			#ifndef M_PI
67 :			#define M_PI 3.14159265358979323846
68 :			#endif
69 :
70 :	edgomez	1053	const int speed_ref = 100; /* on slow machines, decrease this value */
71 :	Isibaar	225
72 :			/*********************************************************************
73 :			* misc
74 :			*********************************************************************/
75 :
76 :	edgomez	1060	/* returns time in micro-s*/
77 :	Isibaar	225	double gettime_usec()
78 :			{
79 :	suxen_drol	860	#ifndef WIN32
80 :	edgomez	1060	struct timeval tv;
81 :			gettimeofday(&tv, 0);
82 :			return tv.tv_sec*1.0e6 + tv.tv_usec;
83 :	suxen_drol	860	#else
84 :			clock_t clk;
85 :			clk = clock();
86 :			return clk * 1000000 / CLOCKS_PER_SEC;
87 :			#endif
88 :	Isibaar	225	}
89 :
90 :	edgomez	1060	/* returns squared deviates (mean(vv)-mean(v)^2) of a 8x8 block /
91 :	Isibaar	225	double sqr_dev(uint8_t v[8*8])
92 :			{
93 :	edgomez	1060	double sum=0.;
94 :			double sum2=0.;
95 :			int n;
96 :			for (n=0;n<8*8;n++)
97 :			{
98 :			sum += v[n];
99 :			sum2 += v[n]*v[n];
100 :			}
101 :			sum2 /= n;
102 :			sum /= n;
103 :			return sum2-sum*sum;
104 :	Isibaar	225	}
105 :
106 :			/*********************************************************************
107 :			* cpu init
108 :			*********************************************************************/
109 :
110 :			typedef struct {
111 :	edgomez	1060	const char *name;
112 :			unsigned int cpu;
113 :	Isibaar	225	} CPU;
114 :
115 :			CPU cpu_list[] =
116 :			{ { "PLAINC", 0 }
117 :	edgomez	1122	#ifdef ARCH_IS_IA32
118 :	edgomez	1060	, { "MMX ", XVID_CPU_MMX }
119 :			, { "MMXEXT", XVID_CPU_MMXEXT \| XVID_CPU_MMX }
120 :			, { "SSE2 ", XVID_CPU_SSE2 \| XVID_CPU_MMX }
121 :			, { "3DNOW ", XVID_CPU_3DNOW }
122 :			, { "3DNOWE", XVID_CPU_3DNOWEXT }
123 :	edgomez	1122	#endif
124 :	edgomez	1060	//, { "IA64 ", XVID_CPU_IA64 }
125 :	edgomez	851	//, { "TSC ", XVID_CPU_TSC }
126 :	edgomez	1060	, { 0, 0 } };
127 :	Isibaar	225
128 :	edgomez	1060	CPU cpu_short_list[] =
129 :	Isibaar	225	{ { "PLAINC", 0 }
130 :	edgomez	1122	#ifdef ARCH_IS_IA32
131 :	edgomez	1060	, { "MMX ", XVID_CPU_MMX }
132 :	edgomez	851	//, { "MMXEXT", XVID_CPU_MMXEXT \| XVID_CPU_MMX }
133 :	edgomez	1122	#endif
134 :	edgomez	1060	//, { "IA64 ", XVID_CPU_IA64 }
135 :			, { 0, 0 } };
136 :	Isibaar	225
137 :	edgomez	1060	CPU cpu_short_list2[] =
138 :	Isibaar	225	{ { "PLAINC", 0 }
139 :	edgomez	1122	#ifdef ARCH_IS_IA32
140 :	edgomez	1060	, { "MMX ", XVID_CPU_MMX }
141 :			, { "SSE2 ", XVID_CPU_SSE2 \| XVID_CPU_MMX }
142 :	edgomez	1122	#endif
143 :	edgomez	1060	, { 0, 0 } };
144 :	Isibaar	225
145 :
146 :			int init_cpu(CPU *cpu)
147 :			{
148 :	edgomez	1197	xvid_gbl_info_t xinfo;
149 :	Isibaar	225
150 :	edgomez	1197	/* Get the available CPU flags */
151 :			memset(&xinfo, 0, sizeof(xinfo));
152 :			xinfo.version = XVID_VERSION;
153 :			xvid_global(NULL, XVID_GBL_INFO, &xinfo, NULL);
154 :
155 :			/* Are we trying to test a subset of the host CPU features */
156 :			if ((xinfo.cpu_flags & cpu->cpu) == cpu->cpu) {
157 :			int xerr;
158 :			xvid_gbl_init_t xinit;
159 :			memset(&xinit, 0, sizeof(xinit));
160 :			xinit.cpu_flags = cpu->cpu \| XVID_CPU_FORCE;
161 :			xinit.version = XVID_VERSION;
162 :			xerr = xvid_global(NULL, XVID_GBL_INIT, &xinit, NULL);
163 :			if (xerr==XVID_ERR_FAIL) {
164 :			/* libxvidcore failed to init */
165 :			return 0;
166 :			}
167 :			} else {
168 :			/* The host CPU doesn't support some required feature for this test */
169 :			return(0);
170 :	edgomez	1060	}
171 :			return 1;
172 :	Isibaar	225	}
173 :
174 :			/*********************************************************************
175 :			* test DCT
176 :			*********************************************************************/
177 :
178 :			#define ABS(X) ((X)<0 ? -(X) : (X))
179 :
180 :			void test_dct()
181 :			{
182 :	edgomez	1060	const int nb_tests = 300*speed_ref;
183 :			int tst;
184 :			CPU *cpu;
185 :			int i;
186 :	edgomez	1199	DECLARE_ALIGNED_MATRIX(iDst0, 8, 8, short, 16);
187 :			DECLARE_ALIGNED_MATRIX(iDst, 8, 8, short, 16);
188 :			DECLARE_ALIGNED_MATRIX(fDst, 8, 8, short, 16);
189 :	edgomez	1060	double overhead;
190 :	Isibaar	225
191 :	edgomez	1060	printf( "\n ===== test fdct/idct =====\n" );
192 :	Isibaar	225
193 :	edgomez	1060	for(i=0; i<88; ++i) iDst0[i] = (i7-i*i) & 0x7f;
194 :			overhead = gettime_usec();
195 :			for(tst=0; tst<nb_tests; ++tst)
196 :			{
197 :			for(i=0; i<8*8; ++i) fDst[i] = iDst0[i];
198 :			for(i=0; i<8*8; ++i) iDst[i] = fDst[i];
199 :			}
200 :			overhead = gettime_usec() - overhead;
201 :	Isibaar	225
202 :	edgomez	1060	for(cpu = cpu_list; cpu->name!=0; ++cpu)
203 :			{
204 :			double t, PSNR, MSE;
205 :	Isibaar	225
206 :	edgomez	1060	if (!init_cpu(cpu))
207 :			continue;
208 :	Isibaar	225
209 :	edgomez	1060	t = gettime_usec();
210 :			emms();
211 :			for(tst=0; tst<nb_tests; ++tst)
212 :			{
213 :			for(i=0; i<8*8; ++i) fDst[i] = iDst0[i];
214 :			fdct(fDst);
215 :			for(i=0; i<8*8; ++i) iDst[i] = fDst[i];
216 :			idct(iDst);
217 :			}
218 :			emms();
219 :			t = (gettime_usec() - t - overhead) / nb_tests;
220 :			MSE = 0.;
221 :			for(i=0; i<8*8; ++i) {
222 :			double delta = 1.0*(iDst[i] - iDst0[i]);
223 :			MSE += delta*delta;
224 :			}
225 :			PSNR = (MSE==0.) ? 1.e6 : -4.3429448*log( MSE/64. );
226 :			printf( "%s - %.3f usec PSNR=%.3f MSE=%.3f\n",
227 :			cpu->name, t, PSNR, MSE );
228 :			if (ABS(MSE)>=64) printf( "* CRC ERROR! *\n" );
229 :			}
230 :	Isibaar	225	}
231 :
232 :			/*********************************************************************
233 :			* test SAD
234 :			*********************************************************************/
235 :
236 :			void test_sad()
237 :			{
238 :	edgomez	1060	const int nb_tests = 2000*speed_ref;
239 :			int tst;
240 :			CPU *cpu;
241 :			int i;
242 :			uint8_t Cur[1616], Ref1[1616], Ref2[16*16];
243 :	Isibaar	225
244 :	edgomez	1060	printf( "\n ====== test SAD ======\n" );
245 :			for(i=0; i<16*16;++i) {
246 :			Cur[i] = (i/5) ^ 0x05;
247 :			Ref1[i] = (i + 0x0b) & 0xff;
248 :			Ref2[i] = i ^ 0x76;
249 :			}
250 :	Isibaar	225
251 :	edgomez	1060	for(cpu = cpu_list; cpu->name!=0; ++cpu)
252 :			{
253 :			double t;
254 :			uint32_t s;
255 :			if (!init_cpu(cpu))
256 :			continue;
257 :	Isibaar	225
258 :	edgomez	1060	t = gettime_usec();
259 :			emms();
260 :			for(tst=0; tst<nb_tests; ++tst) s = sad8(Cur, Ref1, 16);
261 :			emms();
262 :			t = (gettime_usec() - t) / nb_tests;
263 :			printf( "%s - sad8 %.3f usec sad=%d\n", cpu->name, t, s );
264 :			if (s!=3776) printf( "* CRC ERROR! *\n" );
265 :	Isibaar	225
266 :	edgomez	1060	t = gettime_usec();
267 :			emms();
268 :			for(tst=0; tst<nb_tests; ++tst) s = sad16(Cur, Ref1, 16, -1);
269 :			emms();
270 :			t = (gettime_usec() - t) / nb_tests;
271 :			printf( "%s - sad16 %.3f usec sad=%d\n", cpu->name, t, s );
272 :			if (s!=27214) printf( "* CRC ERROR! *\n" );
273 :	Isibaar	225
274 :	edgomez	1060	t = gettime_usec();
275 :			emms();
276 :			for(tst=0; tst<nb_tests; ++tst) s = sad16bi(Cur, Ref1, Ref2, 16);
277 :			emms();
278 :			t = (gettime_usec() - t) / nb_tests;
279 :			printf( "%s - sad16bi %.3f usec sad=%d\n", cpu->name, t, s );
280 :			if (s!=26274) printf( "* CRC ERROR! *\n" );
281 :	Isibaar	225
282 :	edgomez	1060	t = gettime_usec();
283 :			emms();
284 :			for(tst=0; tst<nb_tests; ++tst) s = dev16(Cur, 16);
285 :			emms();
286 :			t = (gettime_usec() - t) / nb_tests;
287 :			printf( "%s - dev16 %.3f usec sad=%d\n", cpu->name, t, s );
288 :			if (s!=3344) printf( "* CRC ERROR! *\n" );
289 :	Isibaar	225
290 :	edgomez	1060	printf( " --- \n" );
291 :			}
292 :	Isibaar	225	}
293 :
294 :			/*********************************************************************
295 :			* test interpolation
296 :			*********************************************************************/
297 :
298 :			#define ENTER \
299 :	edgomez	1060	for(i=0; i<16*8; ++i) Dst[i] = 0; \
300 :			t = gettime_usec(); \
301 :			emms();
302 :	Isibaar	225
303 :			#define LEAVE \
304 :	edgomez	1060	emms(); \
305 :			t = (gettime_usec() - t) / nb_tests; \
306 :			iCrc = 0; \
307 :			for(i=0; i<16*8; ++i) { iCrc += Dst[i]^i; }
308 :	Isibaar	225
309 :			#define TEST_MB(FUNC, R) \
310 :	edgomez	1060	ENTER \
311 :			for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst, Src0, 16, (R)); \
312 :			LEAVE
313 :	Isibaar	225
314 :			#define TEST_MB2(FUNC) \
315 :	edgomez	1060	ENTER \
316 :			for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst, Src0, 16); \
317 :			LEAVE
318 :	Isibaar	225
319 :
320 :			void test_mb()
321 :			{
322 :	edgomez	1060	const int nb_tests = 2000*speed_ref;
323 :			CPU *cpu;
324 :			const uint8_t Src0[16*9] = {
325 :			/* try to have every possible combinaison of rounding... */
326 :			0, 0, 1, 0, 2, 0, 3, 0, 4 ,0,0,0, 0,0,0,0
327 :			, 0, 1, 1, 1, 2, 1, 3, 1, 3 ,0,0,0, 0,0,0,0
328 :			, 0, 2, 1, 2, 2, 2, 3, 2, 2 ,0,0,0, 0,0,0,0
329 :			, 0, 3, 1, 3, 2, 3, 3, 3, 1 ,0,0,0, 0,0,0,0
330 :			, 1, 3, 0, 2, 1, 0, 2, 3, 4 ,0,0,0, 0,0,0,0
331 :			, 2, 2, 1, 2, 0, 1, 3, 5, 3 ,0,0,0, 0,0,0,0
332 :			, 3, 1, 2, 3, 1, 2, 2, 6, 2 ,0,0,0, 0,0,0,0
333 :			, 1, 0, 1, 3, 0, 3, 1, 6, 1 ,0,0,0, 0,0,0,0
334 :			, 4, 3, 2, 1, 2, 3, 4, 0, 3 ,0,0,0, 0,0,0,0
335 :			};
336 :			uint8_t Dst[16*8] = {0};
337 :	Isibaar	225
338 :	edgomez	1060	printf( "\n === test block motion ===\n" );
339 :	Isibaar	225
340 :	edgomez	1060	for(cpu = cpu_list; cpu->name!=0; ++cpu)
341 :			{
342 :			double t;
343 :			int tst, i, iCrc;
344 :	Isibaar	225
345 :	edgomez	1060	if (!init_cpu(cpu))
346 :			continue;
347 :	Isibaar	225
348 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_h, 0);
349 :			printf( "%s - interp- h-round0 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
350 :			if (iCrc!=8107) printf( "* CRC ERROR! *\n" );
351 :	Isibaar	225
352 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_h, 1);
353 :			printf( "%s - round1 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
354 :			if (iCrc!=8100) printf( "* CRC ERROR! *\n" );
355 :	Isibaar	225
356 :
357 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_v, 0);
358 :			printf( "%s - interp- v-round0 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
359 :			if (iCrc!=8108) printf( "* CRC ERROR! *\n" );
360 :	Isibaar	225
361 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_v, 1);
362 :			printf( "%s - round1 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
363 :			if (iCrc!=8105) printf( "* CRC ERROR! *\n" );
364 :	Isibaar	225
365 :
366 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_hv, 0);
367 :			printf( "%s - interp-hv-round0 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
368 :			if (iCrc!=8112) printf( "* CRC ERROR! *\n" );
369 :	Isibaar	225
370 :	edgomez	1060	TEST_MB(interpolate8x8_halfpel_hv, 1);
371 :			printf( "%s - round1 %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
372 :			if (iCrc!=8103) printf( "* CRC ERROR! *\n" );
373 :	Isibaar	225
374 :	Isibaar	262
375 :	edgomez	1060	/* this is a new function, as of 06.06.2002 */
376 :	Isibaar	262	#if 0
377 :	edgomez	1060	TEST_MB2(interpolate8x8_avrg);
378 :			printf( "%s - interpolate8x8_c %.3f usec iCrc=%d\n", cpu->name, t, iCrc );
379 :			if (iCrc!=8107) printf( "* CRC ERROR! *\n" );
380 :	Isibaar	262	#endif
381 :
382 :	edgomez	1060	printf( " --- \n" );
383 :			}
384 :	Isibaar	225	}
385 :
386 :			/*********************************************************************
387 :			* test transfer
388 :			*********************************************************************/
389 :
390 :			#define INIT_TRANSFER \
391 :	edgomez	1060	for(i=0; i<8*32; ++i) { \
392 :			Src8[i] = i; Src16[i] = i; \
393 :			Dst8[i] = 0; Dst16[i] = 0; \
394 :			Ref1[i] = i^0x27; \
395 :			Ref2[i] = i^0x51; \
396 :			}
397 :	Isibaar	225
398 :			#define TEST_TRANSFER_BEGIN(DST) \
399 :	edgomez	1060	INIT_TRANSFER \
400 :			overhead = -gettime_usec(); \
401 :			for(tst=0; tst<nb_tests; ++tst) { \
402 :			for(i=0; i<8*32; ++i) (DST)[i] = i^0x6a;\
403 :			} \
404 :			overhead += gettime_usec(); \
405 :			t = gettime_usec(); \
406 :			emms(); \
407 :			for(tst=0; tst<nb_tests; ++tst) { \
408 :			for(i=0; i<8*32; ++i) (DST)[i] = i^0x6a;
409 :	Isibaar	225
410 :
411 :			#define TEST_TRANSFER_END(DST) \
412 :	edgomez	1060	} \
413 :			emms(); \
414 :			t = (gettime_usec()-t -overhead) / nb_tests;\
415 :			s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]^i; }
416 :	Isibaar	225
417 :			#define TEST_TRANSFER(FUNC, DST, SRC) \
418 :	edgomez	1060	TEST_TRANSFER_BEGIN(DST); \
419 :			(FUNC)((DST), (SRC), 32); \
420 :			TEST_TRANSFER_END(DST)
421 :	Isibaar	225
422 :
423 :			#define TEST_TRANSFER2_BEGIN(DST, SRC) \
424 :	edgomez	1060	INIT_TRANSFER \
425 :			overhead = -gettime_usec(); \
426 :			for(tst=0; tst<nb_tests; ++tst) { \
427 :			for(i=0; i<8*32; ++i) (DST)[i] = i^0x6a;\
428 :			for(i=0; i<8*32; ++i) (SRC)[i] = i^0x3e;\
429 :			} \
430 :			overhead += gettime_usec(); \
431 :			t = gettime_usec(); \
432 :			emms(); \
433 :			for(tst=0; tst<nb_tests; ++tst) { \
434 :			for(i=0; i<8*32; ++i) (DST)[i] = i^0x6a;\
435 :			for(i=0; i<8*32; ++i) (SRC)[i] = i^0x3e;
436 :	Isibaar	225
437 :			#define TEST_TRANSFER2_END(DST) \
438 :	edgomez	1060	} \
439 :			emms(); \
440 :			t = (gettime_usec()-t -overhead) / nb_tests;\
441 :			s = 0; for(i=0; i<8*32; ++i) { s += (DST)[i]; }
442 :	Isibaar	225
443 :			#define TEST_TRANSFER2(FUNC, DST, SRC, R1) \
444 :	edgomez	1060	TEST_TRANSFER2_BEGIN(DST,SRC); \
445 :			(FUNC)((DST), (SRC), (R1), 32); \
446 :			TEST_TRANSFER2_END(DST)
447 :	Isibaar	225
448 :			#define TEST_TRANSFER3(FUNC, DST, SRC, R1, R2)\
449 :	edgomez	1060	TEST_TRANSFER_BEGIN(DST); \
450 :			(FUNC)((DST), (SRC), (R1), (R2), 32); \
451 :			TEST_TRANSFER_END(DST)
452 :	Isibaar	225
453 :			void test_transfer()
454 :			{
455 :	edgomez	1060	const int nb_tests = 4000*speed_ref;
456 :			int i;
457 :			CPU *cpu;
458 :			uint8_t Src8[832], Dst8[832], Ref1[832], Ref2[832];
459 :			int16_t Src16[832], Dst16[832];
460 :	Isibaar	225
461 :	edgomez	1060	printf( "\n === test transfer ===\n" );
462 :	Isibaar	225
463 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
464 :	edgomez	1060	{
465 :			double t, overhead;
466 :			int tst, s;
467 :	Isibaar	225
468 :	edgomez	1060	if (!init_cpu(cpu))
469 :			continue;
470 :	Isibaar	225
471 :	edgomez	1060	TEST_TRANSFER(transfer_8to16copy, Dst16, Src8);
472 :			printf( "%s - 8to16 %.3f usec crc=%d\n", cpu->name, t, s );
473 :			if (s!=28288) printf( "* CRC ERROR! *\n" );
474 :	Isibaar	225
475 :	edgomez	1060	TEST_TRANSFER(transfer_16to8copy, Dst8, Src16);
476 :			printf( "%s - 16to8 %.3f usec crc=%d\n", cpu->name, t, s );
477 :			if (s!=28288) printf( "* CRC ERROR! *\n" );
478 :	Isibaar	225
479 :	edgomez	1060	TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
480 :			printf( "%s - 8to8 %.3f usec crc=%d\n", cpu->name, t, s );
481 :			if (s!=20352) printf( "* CRC ERROR! *\n" );
482 :	Isibaar	225
483 :	edgomez	1060	TEST_TRANSFER(transfer_16to8add, Dst8, Src16);
484 :			printf( "%s - 16to8add %.3f usec crc=%d\n", cpu->name, t, s );
485 :			if (s!=25536) printf( "* CRC ERROR! *\n" );
486 :	Isibaar	225
487 :	edgomez	1060	TEST_TRANSFER2(transfer_8to16sub, Dst16, Src8, Ref1);
488 :			printf( "%s - 8to16sub %.3f usec crc1=%d ", cpu->name, t, s );
489 :			if (s!=28064) printf( "* CRC ERROR! *\n" );
490 :			s = 0; for(i=0; i<8*32; ++i) { s += (Src8[i]-Ref1[i])&i; }
491 :			printf( "crc2=%d\n", s);
492 :			if (s!=16256) printf( "* CRC ERROR! *\n" );
493 :	edgomez	1220
494 :	edgomez	1060	TEST_TRANSFER3(transfer_8to16sub2, Dst16, Src8, Ref1, Ref2);
495 :			printf( "%s - 8to16sub2 %.3f usec crc=%d\n", cpu->name, t, s );
496 :	edgomez	1220	if (s!=22368) printf( "* CRC ERROR! *\n" );
497 :
498 :	edgomez	1060	printf( " --- \n" );
499 :			}
500 :	Isibaar	225	}
501 :
502 :			/*********************************************************************
503 :			* test quantization
504 :			*********************************************************************/
505 :
506 :	Isibaar	262	#define TEST_QUANT(FUNC, DST, SRC) \
507 :	edgomez	1060	t = gettime_usec(); \
508 :			for(s=0,qm=1; qm<=255; ++qm) { \
509 :			for(i=0; i<8*8; ++i) Quant[i] = qm; \
510 :			set_inter_matrix( Quant ); \
511 :			emms(); \
512 :			for(q=1; q<=max_Q; ++q) { \
513 :			for(tst=0; tst<nb_tests; ++tst) \
514 :			(FUNC)((DST), (SRC), q); \
515 :			for(i=0; i<64; ++i) s+=(DST)[i]^i^qm; \
516 :			} \
517 :			emms(); \
518 :			} \
519 :			t = (gettime_usec()-t-overhead)/nb_tests/qm;\
520 :			s = (s&0xffff)^(s>>16)
521 :	Isibaar	225
522 :	Isibaar	262	#define TEST_QUANT2(FUNC, DST, SRC) \
523 :	edgomez	1060	t = gettime_usec(); \
524 :			for(s=0,qm=1; qm<=255; ++qm) { \
525 :			for(i=0; i<8*8; ++i) Quant[i] = qm; \
526 :			set_intra_matrix( Quant ); \
527 :			emms(); \
528 :			for(q=1; q<=max_Q; ++q) { \
529 :			for(tst=0; tst<nb_tests; ++tst) \
530 :			(FUNC)((DST), (SRC), q, q); \
531 :			for(i=0; i<64; ++i) s+=(DST)[i]^i^qm; \
532 :			} \
533 :			emms(); \
534 :			} \
535 :			t = (gettime_usec()-t-overhead)/nb_tests/qm;\
536 :			s = (s&0xffff)^(s>>16)
537 :	Isibaar	225
538 :			void test_quant()
539 :			{
540 :	edgomez	1060	const int nb_tests = 1*speed_ref;
541 :			const int max_Q = 31;
542 :			int i, qm;
543 :			CPU *cpu;
544 :			int16_t Src[88], Dst[88];
545 :			uint8_t Quant[8*8];
546 :	Isibaar	225
547 :	edgomez	1060	printf( "\n ===== test quant =====\n" );
548 :	Isibaar	225
549 :	edgomez	1060	/* we deliberately enfringe the norm's specified range [-127,127], */
550 :			/* to test the robustness of the iquant module */
551 :			for(i=0; i<64; ++i) {
552 :			Src[i] = 1 + (i-32) * (i&6);
553 :			Dst[i] = 0;
554 :			}
555 :	Isibaar	225
556 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
557 :	edgomez	1060	{
558 :			double t, overhead;
559 :			int tst, q;
560 :			uint32_t s;
561 :	Isibaar	225
562 :	edgomez	1060	if (!init_cpu(cpu))
563 :			continue;
564 :	Isibaar	225
565 :	edgomez	1060	overhead = -gettime_usec();
566 :			for(s=0,qm=1; qm<=255; ++qm) {
567 :			for(i=0; i<8*8; ++i) Quant[i] = qm;
568 :			set_inter_matrix( Quant );
569 :			for(q=1; q<=max_Q; ++q)
570 :			for(i=0; i<64; ++i) s+=Dst[i]^i^qm;
571 :			}
572 :			overhead += gettime_usec();
573 :	Isibaar	225
574 :	Isibaar	262	#if 1
575 :	edgomez	1176	TEST_QUANT2(quant_mpeg_intra, Dst, Src);
576 :			printf( "%s - quant_mpeg_intra %.3f usec crc=%d\n", cpu->name, t, s );
577 :	edgomez	1060	if (s!=29809) printf( "* CRC ERROR! *\n" );
578 :	Isibaar	225
579 :	edgomez	1176	TEST_QUANT(quant_mpeg_inter, Dst, Src);
580 :			printf( "%s - quant_mpeg_inter %.3f usec crc=%d\n", cpu->name, t, s );
581 :	edgomez	1060	if (s!=12574) printf( "* CRC ERROR! *\n" );
582 :	Isibaar	262	#endif
583 :			#if 1
584 :	edgomez	1176	TEST_QUANT2(dequant_mpeg_intra, Dst, Src);
585 :			printf( "%s - dequant_mpeg_intra %.3f usec crc=%d\n", cpu->name, t, s );
586 :	edgomez	1060	if (s!=24052) printf( "* CRC ERROR! *\n" );
587 :	Isibaar	225
588 :	edgomez	1176	TEST_QUANT(dequant_mpeg_inter, Dst, Src);
589 :			printf( "%s - dequant_mpeg_inter %.3f usec crc=%d\n", cpu->name, t, s );
590 :	edgomez	1060	if (s!=63847) printf( "* CRC ERROR! *\n" );
591 :	Isibaar	262	#endif
592 :			#if 1
593 :	edgomez	1176	TEST_QUANT2(quant_h263_intra, Dst, Src);
594 :			printf( "%s - quant_h263_intra %.3f usec crc=%d\n", cpu->name, t, s );
595 :	edgomez	1060	if (s!=25662) printf( "* CRC ERROR! *\n" );
596 :	Isibaar	225
597 :	edgomez	1176	TEST_QUANT(quant_h263_inter, Dst, Src);
598 :			printf( "%s - quant_h263_inter %.3f usec crc=%d\n", cpu->name, t, s );
599 :	edgomez	1060	if (s!=23972) printf( "* CRC ERROR! *\n" );
600 :	Isibaar	262	#endif
601 :			#if 1
602 :	edgomez	1176	TEST_QUANT2(dequant_h263_intra, Dst, Src);
603 :			printf( "%s - dequant_h263_intra %.3f usec crc=%d\n", cpu->name, t, s );
604 :	edgomez	1060	if (s!=49900) printf( "* CRC ERROR! *\n" );
605 :	Isibaar	225
606 :	edgomez	1176	TEST_QUANT(dequant_h263_inter, Dst, Src);
607 :			printf( "%s - dequant_h263_inter %.3f usec crc=%d\n", cpu->name, t, s );
608 :	edgomez	1060	if (s!=48899) printf( "* CRC ERROR! *\n" );
609 :	Isibaar	262	#endif
610 :	edgomez	1060	printf( " --- \n" );
611 :			}
612 :	Isibaar	225	}
613 :
614 :			/*********************************************************************
615 :			* test non-zero AC counting
616 :			*********************************************************************/
617 :
618 :			#define TEST_CBP(FUNC, SRC) \
619 :	edgomez	1060	t = gettime_usec(); \
620 :			emms(); \
621 :			for(tst=0; tst<nb_tests; ++tst) { \
622 :			cbp = (FUNC)((SRC)); \
623 :			} \
624 :			emms(); \
625 :			t = (gettime_usec()-t ) / nb_tests;
626 :	Isibaar	225
627 :			void test_cbp()
628 :			{
629 :	edgomez	1060	const int nb_tests = 10000*speed_ref;
630 :			int i;
631 :			CPU *cpu;
632 :			int16_t Src1[664], Src2[664], Src3[664], Src4[664];
633 :	Isibaar	225
634 :	edgomez	1060	printf( "\n ===== test cbp =====\n" );
635 :	Isibaar	225
636 :	edgomez	1060	for(i=0; i<6*64; ++i) {
637 :			Src1[i] = (ii3/8192)&(i/64)&1; /* 'random' */
638 :			Src2[i] = (i<364); / half-full */
639 :			Src3[i] = ((i+32)>3*64);
640 :			Src4[i] = (i==(364+2) \|\| i==(564+9));
641 :			}
642 :	Isibaar	225
643 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
644 :	edgomez	1060	{
645 :			double t;
646 :			int tst, cbp;
647 :	Isibaar	225
648 :	edgomez	1060	if (!init_cpu(cpu))
649 :			continue;
650 :
651 :			TEST_CBP(calc_cbp, Src1);
652 :			printf( "%s - calc_cbp#1 %.3f usec cbp=0x%x\n", cpu->name, t, cbp );
653 :			if (cbp!=0x15) printf( "* CRC ERROR! *\n" );
654 :			TEST_CBP(calc_cbp, Src2);
655 :			printf( "%s - calc_cbp#2 %.3f usec cbp=0x%x\n", cpu->name, t, cbp );
656 :			if (cbp!=0x38) printf( "* CRC ERROR! *\n" );
657 :			TEST_CBP(calc_cbp, Src3);
658 :			printf( "%s - calc_cbp#3 %.3f usec cbp=0x%x\n", cpu->name, t, cbp );
659 :			if (cbp!=0x0f) printf( "* CRC ERROR! *\n" );
660 :			TEST_CBP(calc_cbp, Src4);
661 :			printf( "%s - calc_cbp#4 %.3f usec cbp=0x%x\n", cpu->name, t, cbp );
662 :			if (cbp!=0x05) printf( "* CRC ERROR! *\n" );
663 :			printf( " --- \n" );
664 :			}
665 :	Isibaar	225	}
666 :
667 :			/*********************************************************************
668 :	Isibaar	262	* fdct/idct IEEE1180 compliance
669 :			*********************************************************************/
670 :
671 :			typedef struct {
672 :	edgomez	1060	long Errors[64];
673 :			long Sqr_Errors[64];
674 :			long Max_Errors[64];
675 :			long Nb;
676 :	Isibaar	262	} STATS_8x8;
677 :
678 :			void init_stats(STATS_8x8 *S)
679 :			{
680 :	edgomez	1060	int i;
681 :			for(i=0; i<64; ++i) {
682 :			S->Errors[i] = 0;
683 :			S->Sqr_Errors[i] = 0;
684 :			S->Max_Errors[i] = 0;
685 :			}
686 :			S->Nb = 0;
687 :	Isibaar	262	}
688 :
689 :			void store_stats(STATS_8x8 *S, short Blk[64], short Ref[64])
690 :			{
691 :	edgomez	1060	int i;
692 :			for(i=0; i<64; ++i)
693 :			{
694 :			short Err = Blk[i] - Ref[i];
695 :			S->Errors[i] += Err;
696 :			S->Sqr_Errors[i] += Err * Err;
697 :			if (Err<0) Err = -Err;
698 :			if (S->Max_Errors[i]<Err)
699 :			S->Max_Errors[i] = Err;
700 :			}
701 :			S->Nb++;
702 :	Isibaar	262	}
703 :
704 :			void print_stats(STATS_8x8 *S)
705 :			{
706 :	edgomez	1060	int i;
707 :			double Norm;
708 :	Isibaar	262
709 :	edgomez	1060	assert(S->Nb>0);
710 :			Norm = 1. / (double)S->Nb;
711 :			printf("\n== Max absolute values of errors ==\n");
712 :			for(i=0; i<64; i++) {
713 :			printf(" %4ld", S->Max_Errors[i]);
714 :			if ((i&7)==7) printf("\n");
715 :			}
716 :	Isibaar	262
717 :	edgomez	1060	printf("\n== Mean square errors ==\n");
718 :			for(i=0; i<64; i++)
719 :			{
720 :			double Err = Norm * (double)S->Sqr_Errors[i];
721 :			printf(" %.3f", Err);
722 :			if ((i&7)==7) printf("\n");
723 :			}
724 :	Isibaar	262
725 :	edgomez	1060	printf("\n== Mean errors ==\n");
726 :			for(i=0; i<64; i++)
727 :			{
728 :			double Err = Norm * (double)S->Errors[i];
729 :			printf(" %.3f", Err);
730 :			if ((i&7)==7) printf("\n");
731 :			}
732 :			printf("\n");
733 :	Isibaar	262	}
734 :
735 :			static const char *CHECK(double v, double l) {
736 :	edgomez	1060	if (fabs(v)<=l) return "ok";
737 :			else return "FAIL!";
738 :	Isibaar	262	}
739 :
740 :			void report_stats(STATS_8x8 S, const double Limits)
741 :			{
742 :	edgomez	1060	int i;
743 :			double Norm, PE, PMSE, OMSE, PME, OME;
744 :	Isibaar	262
745 :	edgomez	1060	assert(S->Nb>0);
746 :			Norm = 1. / (double)S->Nb;
747 :			PE = 0.;
748 :			for(i=0; i<64; i++) {
749 :			if (PE<S->Max_Errors[i])
750 :			PE = S->Max_Errors[i];
751 :			}
752 :	Isibaar	262
753 :	edgomez	1060	PMSE = 0.;
754 :			OMSE = 0.;
755 :			for(i=0; i<64; i++)
756 :			{
757 :			double Err = Norm * (double)S->Sqr_Errors[i];
758 :			OMSE += Err;
759 :			if (PMSE < Err) PMSE = Err;
760 :			}
761 :			OMSE /= 64.;
762 :	Isibaar	262
763 :	edgomez	1060	PME = 0.;
764 :			OME = 0.;
765 :			for(i=0; i<64; i++)
766 :			{
767 :			double Err = Norm * (double)S->Errors[i];
768 :			OME += Err;
769 :			Err = fabs(Err);
770 :			if (PME < Err) PME = Err;
771 :			}
772 :			OME /= 64.;
773 :	Isibaar	262
774 :	edgomez	1060	printf( "Peak error: %4.4f\n", PE );
775 :			printf( "Peak MSE: %4.4f\n", PMSE );
776 :			printf( "Overall MSE: %4.4f\n", OMSE );
777 :			printf( "Peak ME: %4.4f\n", PME );
778 :			printf( "Overall ME: %4.4f\n", OME );
779 :
780 :			if (Limits!=0)
781 :			{
782 :			printf( "[PE<=%.4f %s] ", Limits[0], CHECK(PE, Limits[0]) );
783 :			printf( "\n" );
784 :			printf( "[PMSE<=%.4f %s]", Limits[1], CHECK(PMSE, Limits[1]) );
785 :			printf( "[OMSE<=%.4f %s]", Limits[2], CHECK(OMSE, Limits[2]) );
786 :			printf( "\n" );
787 :			printf( "[PME<=%.4f %s] ", Limits[3], CHECK(PME , Limits[3]) );
788 :			printf( "[OME<=%.4f %s] ", Limits[4], CHECK(OME , Limits[4]) );
789 :			printf( "\n" );
790 :			}
791 :	Isibaar	262	}
792 :
793 :	edgomez	1053	///* ////////////////////////////////////////////////////// */
794 :	Isibaar	262	/* Pseudo-random generator specified by IEEE 1180 */
795 :
796 :			static long ieee_seed = 1;
797 :			static void ieee_reseed(long s) {
798 :	edgomez	1060	ieee_seed = s;
799 :	Isibaar	262	}
800 :			static long ieee_rand(int Min, int Max)
801 :			{
802 :	edgomez	1060	static double z = (double) 0x7fffffff;
803 :	Isibaar	262
804 :	edgomez	1060	long i,j;
805 :			double x;
806 :	Isibaar	262
807 :	edgomez	1060	ieee_seed = (ieee_seed * 1103515245) + 12345;
808 :			i = ieee_seed & 0x7ffffffe;
809 :			x = ((double) i) / z;
810 :			x *= (Max-Min+1);
811 :			j = (long)x;
812 :			j = j + Min;
813 :			assert(j>=Min && j<=Max);
814 :			return (short)j;
815 :	Isibaar	262	}
816 :
817 :			#define CLAMP(x, M) (x) = ((x)<-(M)) ? (-(M)) : ((x)>=(M) ? ((M)-1) : (x))
818 :
819 :			static double Cos[8][8];
820 :			static void init_ref_dct()
821 :			{
822 :	edgomez	1060	int i, j;
823 :			for(i=0; i<8; i++)
824 :			{
825 :			double scale = (i == 0) ? sqrt(0.125) : 0.5;
826 :			for (j=0; j<8; j++)
827 :			Cos[i][j] = scalecos( (M_PI/8.0)i*(j + 0.5) );
828 :			}
829 :	Isibaar	262	}
830 :
831 :			void ref_idct(short *M)
832 :			{
833 :	edgomez	1060	int i, j, k;
834 :			double Tmp[8][8];
835 :	Isibaar	262
836 :	edgomez	1060	for(i=0; i<8; i++) {
837 :			for(j=0; j<8; j++)
838 :			{
839 :			double Sum = 0.0;
840 :			for (k=0; k<8; k++) Sum += Cos[k][j]M[8i+k];
841 :			Tmp[i][j] = Sum;
842 :			}
843 :			}
844 :			for(i=0; i<8; i++) {
845 :			for(j=0; j<8; j++) {
846 :			double Sum = 0.0;
847 :			for (k=0; k<8; k++) Sum += Cos[k][i]*Tmp[k][j];
848 :			M[8*i+j] = (short)floor(Sum + .5);
849 :			}
850 :			}
851 :	Isibaar	262	}
852 :
853 :			void ref_fdct(short *M)
854 :			{
855 :	edgomez	1060	int i, j, k;
856 :			double Tmp[8][8];
857 :	Isibaar	262
858 :	edgomez	1060	for(i=0; i<8; i++) {
859 :			for(j=0; j<8; j++)
860 :			{
861 :			double Sum = 0.0;
862 :			for (k=0; k<8; k++) Sum += Cos[j][k]M[8i+k];
863 :			Tmp[i][j] = Sum;
864 :			}
865 :			}
866 :			for(i=0; i<8; i++) {
867 :			for(j=0; j<8; j++) {
868 :			double Sum = 0.0;
869 :			for (k=0; k<8; k++) Sum += Cos[i][k]*Tmp[k][j];
870 :			M[8*i+j] = (short)floor(Sum + 0.5);
871 :			}
872 :			}
873 :	Isibaar	262	}
874 :
875 :			void test_IEEE1180_compliance(int Min, int Max, int Sign)
876 :			{
877 :	edgomez	1060	static const double ILimits[5] = { 1., 0.06, 0.02, 0.015, 0.0015 };
878 :			int Loops = 10000;
879 :			int i, m, n;
880 :	edgomez	1199	DECLARE_ALIGNED_MATRIX(Blk0, 8, 8, short, 16); /* reference */
881 :			DECLARE_ALIGNED_MATRIX(Blk, 8, 8, short, 16);
882 :			DECLARE_ALIGNED_MATRIX(iBlk, 8, 8, short, 16);
883 :			DECLARE_ALIGNED_MATRIX(Ref_FDCT, 8, 8, short, 16);
884 :			DECLARE_ALIGNED_MATRIX(Ref_IDCT, 8, 8, short, 16);
885 :	Isibaar	262
886 :	edgomez	1060	STATS_8x8 FStats; /* forward dct stats */
887 :			STATS_8x8 IStats; /* inverse dct stats */
888 :	Isibaar	262
889 :	edgomez	1060	CPU *cpu;
890 :	Isibaar	262
891 :	edgomez	1060	init_ref_dct();
892 :	Isibaar	262
893 :	edgomez	1060	for(cpu = cpu_list; cpu->name!=0; ++cpu)
894 :			{
895 :			if (!init_cpu(cpu))
896 :			continue;
897 :	Isibaar	262
898 :	edgomez	1060	printf( "\n===== IEEE test for %s ==== (Min=%d Max=%d Sign=%d Loops=%d)\n",
899 :			cpu->name, Min, Max, Sign, Loops);
900 :	Isibaar	262
901 :	edgomez	1060	init_stats(&IStats);
902 :			init_stats(&FStats);
903 :	Isibaar	262
904 :	edgomez	1060	ieee_reseed(1);
905 :			for(n=0; n<Loops; ++n)
906 :			{
907 :			for(i=0; i<64; ++i)
908 :			Blk0[i] = (short)ieee_rand(Min,Max) * Sign;
909 :	Isibaar	262
910 :	edgomez	1060	/* hmm, I'm not quite sure this is exactly */
911 :			/* the tests described in the norm. check... */
912 :	Isibaar	262
913 :	edgomez	1060	memcpy(Ref_FDCT, Blk0, 64*sizeof(short));
914 :			ref_fdct(Ref_FDCT);
915 :			for(i=0; i<64; i++) CLAMP( Ref_FDCT[i], 2048 );
916 :	Isibaar	262
917 :	edgomez	1060	memcpy(Blk, Blk0, 64*sizeof(short));
918 :			emms(); fdct(Blk); emms();
919 :			for(i=0; i<64; i++) CLAMP( Blk[i], 2048 );
920 :	Isibaar	262
921 :	edgomez	1060	store_stats(&FStats, Blk, Ref_FDCT);
922 :	Isibaar	262
923 :
924 :	edgomez	1060	memcpy(Ref_IDCT, Ref_FDCT, 64*sizeof(short));
925 :			ref_idct(Ref_IDCT);
926 :			for (i=0; i<64; i++) CLAMP( Ref_IDCT[i], 256 );
927 :	Isibaar	262
928 :	edgomez	1060	memcpy(iBlk, Ref_FDCT, 64*sizeof(short));
929 :			emms(); idct(iBlk); emms();
930 :			for(i=0; i<64; i++) CLAMP( iBlk[i], 256 );
931 :	Isibaar	262
932 :	edgomez	1060	store_stats(&IStats, iBlk, Ref_IDCT);
933 :			}
934 :	Isibaar	262
935 :
936 :	edgomez	1060	printf( "\n -- FDCT report --\n" );
937 :	edgomez	851	// print_stats(&FStats);
938 :	edgomez	1060	report_stats(&FStats, 0); /* so far I know, IEEE1180 says nothing for fdct */
939 :	Isibaar	262
940 :	edgomez	1060	for(i=0; i<64; i++) Blk[i] = 0;
941 :			emms(); fdct(Blk); emms();
942 :			for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
943 :			printf( "FDCT(0) == 0 ? %s\n", (m!=0) ? "NOPE!" : "yup." );
944 :	Isibaar	262
945 :	edgomez	1060	printf( "\n -- IDCT report --\n" );
946 :	edgomez	851	// print_stats(&IStats);
947 :	edgomez	1060	report_stats(&IStats, ILimits);
948 :	Isibaar	262
949 :
950 :	edgomez	1060	for(i=0; i<64; i++) Blk[i] = 0;
951 :			emms(); idct(Blk); emms();
952 :			for(m=i=0; i<64; i++) if (Blk[i]!=0) m++;
953 :			printf( "IDCT(0) == 0 ? %s\n", (m!=0) ? "NOPE!" : "yup." );
954 :			}
955 :	Isibaar	262	}
956 :
957 :
958 :			void test_dct_saturation(int Min, int Max)
959 :			{
960 :	edgomez	1060	/* test behaviour on input range fringe */
961 :	Isibaar	262
962 :	edgomez	1060	int i, n, p;
963 :			CPU *cpu;
964 :	edgomez	1053	// const short IDCT_MAX = 2047; /* 12bits input */
965 :	edgomez	851	// const short IDCT_MIN = -2048;
966 :	edgomez	1053	// const short IDCT_OUT = 256; /* 9bits ouput */
967 :	edgomez	1060	const int Partitions = 4;
968 :			const int Loops = 10000 / Partitions;
969 :	Isibaar	262
970 :	edgomez	1060	init_ref_dct();
971 :	Isibaar	262
972 :	edgomez	1060	for(cpu = cpu_list; cpu->name!=0; ++cpu)
973 :			{
974 :			short Blk0[64], Blk[64];
975 :			STATS_8x8 Stats;
976 :	Isibaar	262
977 :	edgomez	1060	if (!init_cpu(cpu))
978 :			continue;
979 :	Isibaar	262
980 :	edgomez	1060	printf( "\n===== IEEE test for %s Min=%d Max=%d =====\n",
981 :			cpu->name, Min, Max );
982 :	Isibaar	262
983 :	edgomez	1060	/* FDCT tests // */
984 :	Isibaar	262
985 :	edgomez	1060	init_stats(&Stats);
986 :	Isibaar	262
987 :	edgomez	1060	/* test each computation channels separately */
988 :			for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Max : 0;
989 :			ref_fdct(Blk0);
990 :			emms(); fdct(Blk); emms();
991 :			store_stats(&Stats, Blk, Blk0);
992 :	Isibaar	262
993 :	edgomez	1060	for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? Min : 0;
994 :			ref_fdct(Blk0);
995 :			emms(); fdct(Blk); emms();
996 :			store_stats(&Stats, Blk, Blk0);
997 :	Isibaar	262
998 :	edgomez	1060	/* randomly saturated inputs */
999 :			for(p=0; p<Partitions; ++p)
1000 :			{
1001 :			for(n=0; n<Loops; ++n)
1002 :			{
1003 :			for(i=0; i<64; ++i)
1004 :			Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? Max : Min;
1005 :			ref_fdct(Blk0);
1006 :			emms(); fdct(Blk); emms();
1007 :			store_stats(&Stats, Blk, Blk0);
1008 :			}
1009 :			}
1010 :			printf( "\n -- FDCT saturation report --\n" );
1011 :			report_stats(&Stats, 0);
1012 :	Isibaar	262
1013 :
1014 :	edgomez	1060	/* IDCT tests // */
1015 :	Isibaar	262	#if 0
1016 :	edgomez	1060	/* no finished yet */
1017 :	Isibaar	262
1018 :	edgomez	1060	init_stats(&Stats);
1019 :	Isibaar	262
1020 :	edgomez	1060	/* test each computation channel separately */
1021 :			for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MAX : 0;
1022 :			ref_idct(Blk0);
1023 :			emms(); idct(Blk); emms();
1024 :			for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1025 :			store_stats(&Stats, Blk, Blk0);
1026 :	Isibaar	262
1027 :	edgomez	1060	for(i=0; i<64; i++) Blk[i] = Blk0[i] = ((i/8)==(i%8)) ? IDCT_MIN : 0;
1028 :			ref_idct(Blk0);
1029 :			emms(); idct(Blk); emms();
1030 :			for(i=0; i<64; i++) { CLAMP(Blk0[i], IDCT_OUT); CLAMP(Blk[i], IDCT_OUT); }
1031 :			store_stats(&Stats, Blk, Blk0);
1032 :	Isibaar	262
1033 :	edgomez	1060	/* randomly saturated inputs */
1034 :			for(p=0; p<Partitions; ++p)
1035 :			{
1036 :			for(n=0; n<Loops; ++n)
1037 :			{
1038 :			for(i=0; i<64; ++i)
1039 :			Blk0[i] = Blk[i] = (ieee_rand(0,Partitions)>=p)? IDCT_MAX : IDCT_MIN;
1040 :			ref_idct(Blk0);
1041 :			emms(); idct(Blk); emms();
1042 :			for(i=0; i<64; i++) { CLAMP(Blk0[i],IDCT_OUT); CLAMP(Blk[i],IDCT_OUT); }
1043 :			store_stats(&Stats, Blk, Blk0);
1044 :			}
1045 :			}
1046 :	Isibaar	262
1047 :	edgomez	1060	printf( "\n -- IDCT saturation report --\n" );
1048 :			print_stats(&Stats);
1049 :			report_stats(&Stats, 0);
1050 :	Isibaar	262	#endif
1051 :	edgomez	1060	}
1052 :	Isibaar	262	}
1053 :
1054 :			/*********************************************************************
1055 :	Isibaar	225	* measure raw decoding speed
1056 :			*********************************************************************/
1057 :
1058 :			void test_dec(const char *name, int width, int height, int with_chksum)
1059 :			{
1060 :	edgomez	1060	FILE *f = 0;
1061 :			void *dechandle = 0;
1062 :			int xerr;
1063 :			xvid_gbl_init_t xinit;
1064 :			xvid_dec_create_t xparam;
1065 :			xvid_dec_frame_t xframe;
1066 :	Isibaar	225	double t = 0.;
1067 :			int nb = 0;
1068 :	edgomez	1060	uint8_t *buf = 0;
1069 :			uint8_t *rgb_out = 0;
1070 :			int buf_size, pos;
1071 :			uint32_t chksum = 0;
1072 :	Isibaar	225
1073 :	edgomez	1060	memset(&xinit, 0, sizeof(xinit));
1074 :	Isibaar	262	xinit.cpu_flags = XVID_CPU_MMX \| XVID_CPU_FORCE;
1075 :	edgomez	1060	xinit.version = XVID_VERSION;
1076 :			xvid_global(NULL, 0, &xinit, NULL);
1077 :	Isibaar	225
1078 :	edgomez	1060	memset(&xparam, 0, sizeof(xparam));
1079 :	Isibaar	225	xparam.width = width;
1080 :			xparam.height = height;
1081 :	edgomez	1060	xparam.version = XVID_VERSION;
1082 :	Isibaar	225	xerr = xvid_decore(NULL, XVID_DEC_CREATE, &xparam, NULL);
1083 :	edgomez	1060	if (xerr==XVID_ERR_FAIL) {
1084 :			printf("can't init decoder (err=%d)\n", xerr);
1085 :			return;
1086 :	Isibaar	225	}
1087 :			dechandle = xparam.handle;
1088 :
1089 :
1090 :			f = fopen(name, "rb");
1091 :	edgomez	1060	if (f==0) {
1092 :			printf( "can't open file '%s'\n", name);
1093 :			return;
1094 :			}
1095 :			fseek(f, 0, SEEK_END);
1096 :			buf_size = ftell(f);
1097 :			fseek(f, 0, SEEK_SET);
1098 :			if (buf_size<=0) {
1099 :			printf("error while stating file\n");
1100 :			goto End;
1101 :			}
1102 :			else printf( "Input size: %d\n", buf_size);
1103 :	Isibaar	225
1104 :	edgomez	1060	buf = malloc(buf_size); /* should be enuf' */
1105 :			rgb_out = calloc(4, widthheight); / <-room for _RGB24 */
1106 :			if (buf==0 \|\| rgb_out==0) {
1107 :			printf( "malloc failed!\n" );
1108 :			goto End;
1109 :			}
1110 :	Isibaar	225
1111 :	edgomez	1060	if (fread(buf, buf_size, 1, f)!=1) {
1112 :			printf( "file-read failed\n" );
1113 :			goto End;
1114 :			}
1115 :	Isibaar	225
1116 :	edgomez	1060	nb = 0;
1117 :			pos = 0;
1118 :			t = -gettime_usec();
1119 :			while(1) {
1120 :			memset(&xframe, 0, sizeof(xframe));
1121 :			xframe.version = XVID_VERSION;
1122 :			xframe.bitstream = buf + pos;
1123 :			xframe.length = buf_size - pos;
1124 :			xframe.output.plane[0] = rgb_out;
1125 :			xframe.output.stride[0] = width;
1126 :			xframe.output.csp = XVID_CSP_BGR;
1127 :			xerr = xvid_decore(dechandle, XVID_DEC_DECODE, &xframe, 0);
1128 :			nb++;
1129 :			pos += xframe.length;
1130 :			if (with_chksum) {
1131 :			int k = width*height;
1132 :			uint32_t ptr = (uint32_t )rgb_out;
1133 :			while(k-->0) chksum += *ptr++;
1134 :			}
1135 :			if (pos==buf_size)
1136 :			break;
1137 :			if (xerr==XVID_ERR_FAIL) {
1138 :			printf("decoding failed for frame #%d (err=%d)!\n", nb, xerr);
1139 :			break;
1140 :			}
1141 :			}
1142 :			t += gettime_usec();
1143 :			if (t>0.)
1144 :			printf( "%d frames decoded in %.3f s -> %.1f FPS\n", nb, t1.e-6f, (float)(nb1.e6f/t) );
1145 :			if (with_chksum)
1146 :			printf("checksum: 0x%.8x\n", chksum);
1147 :	Isibaar	225
1148 :	edgomez	1060	End:
1149 :			if (rgb_out!=0) free(rgb_out);
1150 :			if (buf!=0) free(buf);
1151 :			if (dechandle!=0) {
1152 :			xerr= xvid_decore(dechandle, XVID_DEC_DESTROY, NULL, NULL);
1153 :			if (xerr==XVID_ERR_FAIL)
1154 :			printf("destroy-decoder failed (err=%d)!\n", xerr);
1155 :			}
1156 :			if (f!=0) fclose(f);
1157 :	Isibaar	225	}
1158 :
1159 :			/*********************************************************************
1160 :			* non-regression tests
1161 :			*********************************************************************/
1162 :
1163 :			void test_bugs1()
1164 :			{
1165 :	edgomez	1060	CPU *cpu;
1166 :	Isibaar	225
1167 :	edgomez	1060	printf( "\n ===== (de)quant4_intra saturation bug? =====\n" );
1168 :	Isibaar	225
1169 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
1170 :	edgomez	1060	{
1171 :			int i;
1172 :			int16_t Src[88], Dst[88];
1173 :	Isibaar	225
1174 :	edgomez	1060	if (!init_cpu(cpu))
1175 :			continue;
1176 :	Isibaar	225
1177 :	edgomez	1060	for(i=0; i<64; ++i) Src[i] = i-32;
1178 :			set_intra_matrix( get_default_intra_matrix() );
1179 :	edgomez	1176	dequant_mpeg_intra(Dst, Src, 31, 5);
1180 :			printf( "dequant_mpeg_intra with CPU=%s: ", cpu->name);
1181 :	edgomez	1060	printf( " Out[]= " );
1182 :			for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1183 :			printf( "\n" );
1184 :			}
1185 :	Isibaar	225
1186 :	edgomez	1060	printf( "\n ===== (de)quant4_inter saturation bug? =====\n" );
1187 :	Isibaar	225
1188 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
1189 :	edgomez	1060	{
1190 :			int i;
1191 :			int16_t Src[88], Dst[88];
1192 :	Isibaar	225
1193 :	edgomez	1060	if (!init_cpu(cpu))
1194 :			continue;
1195 :	Isibaar	225
1196 :	edgomez	1060	for(i=0; i<64; ++i) Src[i] = i-32;
1197 :			set_inter_matrix( get_default_inter_matrix() );
1198 :	edgomez	1176	dequant_mpeg_inter(Dst, Src, 31);
1199 :			printf( "dequant_mpeg_inter with CPU=%s: ", cpu->name);
1200 :	edgomez	1060	printf( " Out[]= " );
1201 :			for(i=0; i<64; ++i) printf( "[%d]", Dst[i]);
1202 :			printf( "\n" );
1203 :			}
1204 :	Isibaar	225	}
1205 :
1206 :			void test_dct_precision_diffs()
1207 :			{
1208 :	edgomez	1060	CPU *cpu;
1209 :			short Blk[88], Blk0[88];
1210 :	Isibaar	225
1211 :	edgomez	1060	printf( "\n ===== fdct/idct precision diffs =====\n" );
1212 :	Isibaar	225
1213 :	edgomez	1176	for(cpu = cpu_list; cpu->name!=0; ++cpu)
1214 :	edgomez	1060	{
1215 :			int i;
1216 :	Isibaar	225
1217 :	edgomez	1060	if (!init_cpu(cpu))
1218 :			continue;
1219 :	Isibaar	225
1220 :	edgomez	1060	for(i=0; i<8*8; ++i) {
1221 :			Blk0[i] = (i7-ii) & 0x7f;
1222 :			Blk[i] = Blk0[i];
1223 :			}
1224 :	Isibaar	225
1225 :	edgomez	1060	fdct(Blk);
1226 :			idct(Blk);
1227 :			printf( " fdct+idct diffs with CPU=%s: \n", cpu->name );
1228 :			for(i=0; i<8; ++i) {
1229 :			int j;
1230 :			for(j=0; j<8; ++j) printf( " %d ", Blk[i8+j]-Blk0[i8+j]);
1231 :			printf("\n");
1232 :			}
1233 :			printf("\n");
1234 :			}
1235 :	Isibaar	225	}
1236 :
1237 :	Isibaar	262	void test_quant_bug()
1238 :			{
1239 :	edgomez	1060	const int max_Q = 31;
1240 :			int i, n, qm, q;
1241 :			CPU *cpu;
1242 :			int16_t Src[88], Dst[88];
1243 :			uint8_t Quant[8*8];
1244 :			CPU cpu_bug_list[] = { { "PLAINC", 0 }, { "MMX ", XVID_CPU_MMX }, {0,0} };
1245 :			uint16_t Crcs_Inter[2][32];
1246 :			uint16_t Crcs_Intra[2][32];
1247 :			printf( "\n ===== test MPEG4-quantize bug =====\n" );
1248 :	Isibaar	225
1249 :	edgomez	1060	for(i=0; i<64; ++i) Src[i] = 2048*(i-32)/32;
1250 :	Isibaar	262
1251 :			#if 1
1252 :	edgomez	1060	for(qm=1; qm<=255; ++qm)
1253 :			{
1254 :			for(i=0; i<8*8; ++i) Quant[i] = qm;
1255 :			set_inter_matrix( Quant );
1256 :	Isibaar	262
1257 :	edgomez	1060	for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1258 :			{
1259 :			uint16_t s;
1260 :	Isibaar	262
1261 :	edgomez	1060	if (!init_cpu(cpu))
1262 :			continue;
1263 :	Isibaar	262
1264 :	edgomez	1060	for(q=1; q<=max_Q; ++q) {
1265 :			emms();
1266 :	edgomez	1176	quant_mpeg_inter( Dst, Src, q );
1267 :	edgomez	1060	emms();
1268 :			for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1269 :			Crcs_Inter[n][q] = s;
1270 :			}
1271 :			}
1272 :	Isibaar	262
1273 :	edgomez	1060	for(q=1; q<=max_Q; ++q)
1274 :			for(i=0; i<n-1; ++i)
1275 :			if (Crcs_Inter[i][q]!=Crcs_Inter[i+1][q])
1276 :			printf( "Discrepancy Inter: qm=%d, q=%d -> %d/%d !\n",
1277 :			qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1278 :			}
1279 :	Isibaar	262	#endif
1280 :
1281 :			#if 1
1282 :	edgomez	1060	for(qm=1; qm<=255; ++qm)
1283 :			{
1284 :			for(i=0; i<8*8; ++i) Quant[i] = qm;
1285 :			set_intra_matrix( Quant );
1286 :	Isibaar	262
1287 :	edgomez	1060	for(n=0, cpu = cpu_bug_list; cpu->name!=0; ++cpu, ++n)
1288 :			{
1289 :			uint16_t s;
1290 :	Isibaar	262
1291 :	edgomez	1060	if (!init_cpu(cpu))
1292 :			continue;
1293 :	Isibaar	262
1294 :	edgomez	1060	for(q=1; q<=max_Q; ++q) {
1295 :			emms();
1296 :	edgomez	1176	quant_mpeg_intra( Dst, Src, q, q);
1297 :	edgomez	1060	emms();
1298 :			for(s=0, i=0; i<64; ++i) s+=((uint16_t)Dst[i])^i;
1299 :			Crcs_Intra[n][q] = s;
1300 :			}
1301 :			}
1302 :	Isibaar	262
1303 :	edgomez	1060	for(q=1; q<=max_Q; ++q)
1304 :			for(i=0; i<n-1; ++i)
1305 :			if (Crcs_Intra[i][q]!=Crcs_Intra[i+1][q])
1306 :			printf( "Discrepancy Intra: qm=%d, q=%d -> %d/%d!\n",
1307 :			qm, q, Crcs_Inter[i][q], Crcs_Inter[i+1][q]);
1308 :			}
1309 :	Isibaar	262	#endif
1310 :			}
1311 :
1312 :	Isibaar	225	/*********************************************************************
1313 :			* main
1314 :			*********************************************************************/
1315 :
1316 :			int main(int argc, char *argv[])
1317 :			{
1318 :	edgomez	1060	int what = 0;
1319 :			if (argc>1) what = atoi(argv[1]);
1320 :			if (what==0 \|\| what==1) test_dct();
1321 :			if (what==0 \|\| what==2) test_mb();
1322 :			if (what==0 \|\| what==3) test_sad();
1323 :			if (what==0 \|\| what==4) test_transfer();
1324 :			if (what==0 \|\| what==5) test_quant();
1325 :			if (what==0 \|\| what==6) test_cbp();
1326 :	Isibaar	225
1327 :	edgomez	1060	if (what==7) {
1328 :			test_IEEE1180_compliance(-256, 255, 1);
1329 :			test_IEEE1180_compliance(-256, 255,-1);
1330 :			test_IEEE1180_compliance( -5, 5, 1);
1331 :			test_IEEE1180_compliance( -5, 5,-1);
1332 :			test_IEEE1180_compliance(-300, 300, 1);
1333 :			test_IEEE1180_compliance(-300, 300,-1);
1334 :			}
1335 :			if (what==8) test_dct_saturation(-256, 255);
1336 :	Isibaar	262
1337 :	edgomez	1060	if (what==9) {
1338 :			int width, height;
1339 :			if (argc<5) {
1340 :			printf("usage: %s %d [bitstream] [width] [height]\n", argv[0], what);
1341 :			return 1;
1342 :			}
1343 :			width = atoi(argv[3]);
1344 :			height = atoi(argv[4]);
1345 :			test_dec(argv[2], width, height, (argc>5));
1346 :			}
1347 :	Isibaar	225
1348 :	edgomez	1060	if (what==-1) {
1349 :			test_dct_precision_diffs();
1350 :			test_bugs1();
1351 :			}
1352 :			if (what==-2)
1353 :			test_quant_bug();
1354 :	Isibaar	262
1355 :	edgomez	1060	return 0;
1356 :	Isibaar	225	}
1357 :
1358 :			/*********************************************************************
1359 :	edgomez	1220	* 'Reference' output (except for timing) on an Athlon XP 2200+
1360 :	Isibaar	225	*********************************************************************/
1361 :	Isibaar	262
1362 :	edgomez	1220	/* as of 07/01/2002, there's a problem with MMX mpeg4-quantization */
1363 :	Isibaar	225	/*
1364 :
1365 :	edgomez	1220	===== test fdct/idct =====
1366 :			PLAINC - 1.446 usec PSNR=13.291 MSE=3.000
1367 :			MMX - -0.260 usec PSNR=9.611 MSE=7.000
1368 :			MMXEXT - -0.293 usec PSNR=9.611 MSE=7.000
1369 :			3DNOW - 1.535 usec PSNR=13.291 MSE=3.000
1370 :			3DNOWE - 0.376 usec PSNR=13.291 MSE=3.000
1371 :	Isibaar	225
1372 :	edgomez	1220	=== test block motion ===
1373 :			PLAINC - interp- h-round0 0.126 usec iCrc=8107
1374 :			PLAINC - round1 0.136 usec iCrc=8100
1375 :			PLAINC - interp- v-round0 0.121 usec iCrc=8108
1376 :			PLAINC - round1 0.127 usec iCrc=8105
1377 :			PLAINC - interp-hv-round0 0.192 usec iCrc=8112
1378 :			PLAINC - round1 0.213 usec iCrc=8103
1379 :			---
1380 :			MMX - interp- h-round0 0.048 usec iCrc=8107
1381 :			MMX - round1 0.048 usec iCrc=8100
1382 :			MMX - interp- v-round0 0.046 usec iCrc=8108
1383 :			MMX - round1 0.047 usec iCrc=8105
1384 :			MMX - interp-hv-round0 0.074 usec iCrc=8112
1385 :			MMX - round1 0.074 usec iCrc=8103
1386 :			---
1387 :			MMXEXT - interp- h-round0 0.019 usec iCrc=8107
1388 :			MMXEXT - round1 0.025 usec iCrc=8100
1389 :			MMXEXT - interp- v-round0 0.015 usec iCrc=8108
1390 :			MMXEXT - round1 0.024 usec iCrc=8105
1391 :			MMXEXT - interp-hv-round0 0.039 usec iCrc=8112
1392 :			MMXEXT - round1 0.037 usec iCrc=8103
1393 :			---
1394 :			3DNOW - interp- h-round0 0.019 usec iCrc=8107
1395 :			3DNOW - round1 0.023 usec iCrc=8100
1396 :			3DNOW - interp- v-round0 0.015 usec iCrc=8108
1397 :			3DNOW - round1 0.024 usec iCrc=8105
1398 :			3DNOW - interp-hv-round0 0.037 usec iCrc=8112
1399 :			3DNOW - round1 0.038 usec iCrc=8103
1400 :			---
1401 :			3DNOWE - interp- h-round0 0.022 usec iCrc=8107
1402 :			3DNOWE - round1 0.023 usec iCrc=8100
1403 :			3DNOWE - interp- v-round0 0.016 usec iCrc=8108
1404 :			3DNOWE - round1 0.021 usec iCrc=8105
1405 :			3DNOWE - interp-hv-round0 0.036 usec iCrc=8112
1406 :			3DNOWE - round1 0.036 usec iCrc=8103
1407 :			---
1408 :	Isibaar	225
1409 :	edgomez	1220	====== test SAD ======
1410 :			PLAINC - sad8 0.165 usec sad=3776
1411 :			PLAINC - sad16 0.587 usec sad=27214
1412 :			PLAINC - sad16bi 1.290 usec sad=26274
1413 :			PLAINC - dev16 1.535 usec sad=3344
1414 :			---
1415 :			MMX - sad8 0.036 usec sad=3776
1416 :			MMX - sad16 0.113 usec sad=27214
1417 :			MMX - sad16bi 0.250 usec sad=26274
1418 :			MMX - dev16 0.187 usec sad=3344
1419 :			---
1420 :			MMXEXT - sad8 0.015 usec sad=3776
1421 :			MMXEXT - sad16 0.046 usec sad=27214
1422 :			MMXEXT - sad16bi 0.059 usec sad=26274
1423 :			MMXEXT - dev16 0.088 usec sad=3344
1424 :			---
1425 :			3DNOW - sad8 0.165 usec sad=3776
1426 :			3DNOW - sad16 0.589 usec sad=27214
1427 :			3DNOW - sad16bi 0.119 usec sad=26274
1428 :			3DNOW - dev16 1.541 usec sad=3344
1429 :			---
1430 :			3DNOWE - sad8 0.018 usec sad=3776
1431 :			3DNOWE - sad16 0.039 usec sad=27214
1432 :			3DNOWE - sad16bi 0.051 usec sad=26274
1433 :			3DNOWE - dev16 0.070 usec sad=3344
1434 :			---
1435 :	Isibaar	225
1436 :	edgomez	1220	=== test transfer ===
1437 :			PLAINC - 8to16 0.207 usec crc=28288
1438 :			PLAINC - 16to8 0.357 usec crc=28288
1439 :			PLAINC - 8to8 0.154 usec crc=20352
1440 :			PLAINC - 16to8add 0.391 usec crc=25536
1441 :			PLAINC - 8to16sub 0.562 usec crc1=28064 crc2=16256
1442 :			PLAINC - 8to16sub2 0.519 usec crc=22368
1443 :			---
1444 :			MMX - 8to16 0.048 usec crc=28288
1445 :			MMX - 16to8 0.205 usec crc=28288
1446 :			MMX - 8to8 -0.158 usec crc=20352
1447 :			MMX - 16to8add 0.015 usec crc=25536
1448 :			MMX - 8to16sub 0.203 usec crc1=28064 crc2=16256
1449 :			MMX - 8to16sub2 0.087 usec crc=22368
1450 :			---
1451 :			MMXEXT - 8to16 0.013 usec crc=28288
1452 :			MMXEXT - 16to8 0.011 usec crc=28288
1453 :			MMXEXT - 8to8 -0.023 usec crc=20352
1454 :			MMXEXT - 16to8add 0.023 usec crc=25536
1455 :			MMXEXT - 8to16sub 0.072 usec crc1=28064 crc2=16256
1456 :			MMXEXT - 8to16sub2 0.093 usec crc=22368
1457 :			---
1458 :			3DNOW - 8to16 0.192 usec crc=28288
1459 :			3DNOW - 16to8 0.367 usec crc=28288
1460 :			3DNOW - 8to8 0.132 usec crc=20352
1461 :			3DNOW - 16to8add 0.440 usec crc=25536
1462 :			3DNOW - 8to16sub 0.557 usec crc1=28064 crc2=16256
1463 :			3DNOW - 8to16sub2 0.691 usec crc=22368
1464 :			---
1465 :			3DNOWE - 8to16 0.004 usec crc=28288
1466 :			3DNOWE - 16to8 0.019 usec crc=28288
1467 :			3DNOWE - 8to8 -0.294 usec crc=20352
1468 :			3DNOWE - 16to8add 0.028 usec crc=25536
1469 :			3DNOWE - 8to16sub 0.065 usec crc1=28064 crc2=16256
1470 :			3DNOWE - 8to16sub2 0.027 usec crc=22368
1471 :			---
1472 :	Isibaar	225
1473 :	edgomez	1220	===== test quant =====
1474 :			PLAINC - quant_mpeg_intra 67.757 usec crc=29809
1475 :			PLAINC - quant_mpeg_inter 68.482 usec crc=12574
1476 :			PLAINC - dequant_mpeg_intra 20.764 usec crc=24052
1477 :			PLAINC - dequant_mpeg_inter 24.413 usec crc=63847
1478 :			PLAINC - quant_h263_intra 16.446 usec crc=25662
1479 :			PLAINC - quant_h263_inter 14.499 usec crc=23972
1480 :			PLAINC - dequant_h263_intra 16.419 usec crc=49900
1481 :			PLAINC - dequant_h263_inter 18.679 usec crc=48899
1482 :			---
1483 :			MMX - quant_mpeg_intra 8.299 usec crc=3459
1484 :	Isibaar	262	* CRC ERROR! *
1485 :	edgomez	1220	MMX - quant_mpeg_inter 7.078 usec crc=13247
1486 :	Isibaar	262	* CRC ERROR! *
1487 :	edgomez	1220	MMX - dequant_mpeg_intra 3.455 usec crc=24052
1488 :			MMX - dequant_mpeg_inter 4.483 usec crc=63847
1489 :			MMX - quant_h263_intra 2.597 usec crc=25662
1490 :			MMX - quant_h263_inter 2.151 usec crc=23972
1491 :			MMX - dequant_h263_intra 2.684 usec crc=49900
1492 :			MMX - dequant_h263_inter 2.647 usec crc=48899
1493 :			---
1494 :			MMXEXT - quant_mpeg_intra 3.878 usec crc=29809
1495 :			MMXEXT - quant_mpeg_inter 4.112 usec crc=12574
1496 :			MMXEXT - dequant_mpeg_intra 3.452 usec crc=24052
1497 :			MMXEXT - dequant_mpeg_inter 4.473 usec crc=63847
1498 :			MMXEXT - quant_h263_intra 2.608 usec crc=25662
1499 :			MMXEXT - quant_h263_inter 2.145 usec crc=23972
1500 :			MMXEXT - dequant_h263_intra 2.478 usec crc=49900
1501 :			MMXEXT - dequant_h263_inter 2.450 usec crc=48899
1502 :			---
1503 :			3DNOW - quant_mpeg_intra 66.051 usec crc=29809
1504 :			3DNOW - quant_mpeg_inter 73.494 usec crc=12574
1505 :			3DNOW - dequant_mpeg_intra 20.374 usec crc=24052
1506 :			3DNOW - dequant_mpeg_inter 23.645 usec crc=63847
1507 :			3DNOW - quant_h263_intra 16.292 usec crc=25662
1508 :			3DNOW - quant_h263_inter 14.322 usec crc=23972
1509 :			3DNOW - dequant_h263_intra 16.613 usec crc=49900
1510 :			3DNOW - dequant_h263_inter 18.382 usec crc=48899
1511 :			---
1512 :			3DNOWE - quant_mpeg_intra 66.140 usec crc=29809
1513 :			3DNOWE - quant_mpeg_inter 68.454 usec crc=12574
1514 :			3DNOWE - dequant_mpeg_intra 2.881 usec crc=24052
1515 :			3DNOWE - dequant_mpeg_inter 4.155 usec crc=63847
1516 :			3DNOWE - quant_h263_intra 1.451 usec crc=25662
1517 :			3DNOWE - quant_h263_inter 1.849 usec crc=23972
1518 :			3DNOWE - dequant_h263_intra 2.101 usec crc=49900
1519 :			3DNOWE - dequant_h263_inter 2.109 usec crc=48899
1520 :			---
1521 :	Isibaar	225
1522 :	edgomez	1220	===== test cbp =====
1523 :			PLAINC - calc_cbp#1 0.090 usec cbp=0x15
1524 :			PLAINC - calc_cbp#2 0.086 usec cbp=0x38
1525 :			PLAINC - calc_cbp#3 0.087 usec cbp=0xf
1526 :			PLAINC - calc_cbp#4 0.114 usec cbp=0x5
1527 :			---
1528 :			MMX - calc_cbp#1 0.061 usec cbp=0x15
1529 :			MMX - calc_cbp#2 0.063 usec cbp=0x38
1530 :			MMX - calc_cbp#3 0.061 usec cbp=0xf
1531 :			MMX - calc_cbp#4 0.060 usec cbp=0x5
1532 :			---
1533 :			MMXEXT - calc_cbp#1 0.062 usec cbp=0x15
1534 :			MMXEXT - calc_cbp#2 0.060 usec cbp=0x38
1535 :			MMXEXT - calc_cbp#3 0.062 usec cbp=0xf
1536 :			MMXEXT - calc_cbp#4 0.061 usec cbp=0x5
1537 :			---
1538 :			3DNOW - calc_cbp#1 0.089 usec cbp=0x15
1539 :			3DNOW - calc_cbp#2 0.087 usec cbp=0x38
1540 :			3DNOW - calc_cbp#3 0.087 usec cbp=0xf
1541 :			3DNOW - calc_cbp#4 0.116 usec cbp=0x5
1542 :			---
1543 :			3DNOWE - calc_cbp#1 0.050 usec cbp=0x15
1544 :			3DNOWE - calc_cbp#2 0.051 usec cbp=0x38
1545 :			3DNOWE - calc_cbp#3 0.050 usec cbp=0xf
1546 :			3DNOWE - calc_cbp#4 0.049 usec cbp=0x5
1547 :			---
1548 :	Isibaar	262
1549 :	Isibaar	225	*/

No admin address has been configured	ViewVC Help
Powered by ViewVC 1.0.4