--- trunk/xvidcore/examples/xvid_bench.c	2005/06/14 13:58:21	1620
+++ trunk/xvidcore/examples/xvid_bench.c	2006/10/30 11:21:42	1743
@@ -19,7 +19,7 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- * $Id: xvid_bench.c,v 1.21 2005-06-14 13:58:21 Skal Exp $
+ * $Id: xvid_bench.c,v 1.33 2006-10-30 11:21:42 Skal Exp $
  *
  ****************************************************************************/
 
@@ -112,41 +112,27 @@
 	unsigned int cpu;
 } CPU;
 
-CPU cpu_list[] = 
-{ { "PLAINC", 0 }
+CPU cpu_list[] = {
+	{ "PLAINC ", 0 },
 #ifdef ARCH_IS_IA32
-  , { "MMX   ", XVID_CPU_MMX }
-  , { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
-  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
-  , { "3DNOW ", XVID_CPU_3DNOW }
-  , { "3DNOWE", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT }
+	{ "MMX    ", XVID_CPU_MMX },
+	{ "MMXEXT ", XVID_CPU_MMXEXT | XVID_CPU_MMX },
+	{ "SSE2   ", XVID_CPU_SSE2 | XVID_CPU_MMX },
+	{ "3DNOW  ", XVID_CPU_3DNOW },
+	{ "3DNOWE ", XVID_CPU_3DNOW | XVID_CPU_3DNOWEXT },
 #endif
 #ifdef ARCH_IS_PPC
-  , { "ALTIVEC", XVID_CPU_ALTIVEC }
+	{ "ALTIVEC", XVID_CPU_ALTIVEC },
 #endif
 #ifdef ARCH_IS_X86_64
-  , { "X86_64", XVID_CPU_ASM}
+	{ "X86_64 ", XVID_CPU_ASM},
 #endif
-//, { "IA64  ", XVID_CPU_IA64 }  
-//, { "TSC   ", XVID_CPU_TSC }
-  , { 0, 0 } };
-
-CPU  cpu_short_list[] =
-{ { "PLAINC", 0 }
-#ifdef ARCH_IS_IA32
-  , { "MMX   ", XVID_CPU_MMX }
-//, { "MMXEXT", XVID_CPU_MMXEXT | XVID_CPU_MMX }
-#endif
-//, { "IA64  ", XVID_CPU_IA64 }
-  , { 0, 0 } };
-
-CPU cpu_short_list2[] = 
-{ { "PLAINC", 0 }
-#ifdef ARCH_IS_IA32
-  , { "MMX   ", XVID_CPU_MMX }
-  , { "SSE2  ", XVID_CPU_SSE2 | XVID_CPU_MMX }
+#ifdef ARCH_IS_IA64
+//	{ "IA64   ", XVID_CPU_IA64 },
 #endif
-  , { 0, 0 } };
+//	{ "TSC    ", XVID_CPU_TSC },
+	{ 0, 0 }
+};
 
 
 int init_cpu(CPU *cpu)
@@ -274,6 +260,44 @@
 	return crc;
 }
 
+void byte_swap(uint8_t *mem, int len, int element_size) {
+#ifdef ARCH_IS_BIG_ENDIAN
+	int i;
+
+	if(element_size == 1) {
+		/* No need to swap */
+	} else if(element_size == 2) {
+		uint8_t temp[2];
+		
+		for(i=0; i < (len/2); i++ ) {
+			temp[0] = mem[0];
+			temp[1] = mem[1];
+			mem[0] = temp[1];
+			mem[1] = temp[0];
+
+			mem += 2;
+		}
+	} else if(element_size == 4) {
+		uint8_t temp[4];
+		
+		for(i=0; i < (len/4); i++ ) {
+			temp[0] = mem[0];
+			temp[1] = mem[1];
+			temp[2] = mem[2];
+			temp[3] = mem[3];
+			mem[0] = temp[3];
+			mem[1] = temp[2];
+			mem[2] = temp[1];
+			mem[3] = temp[0];
+
+			mem += 4;
+		}
+	} else {
+		printf("ERROR: byte_swap unsupported element_size(%u)\n", element_size);
+	}
+#endif
+}
+
 /*********************************************************************
  * test DCT
  *********************************************************************/
@@ -494,10 +518,50 @@
 			   (iCrc!=8107)?"| ERROR": "" );
 #endif
 
+    /* New functions for field prediction by CK 1.10.2005 */
+#pragma NEW8X4
+		TEST_MB(interpolate8x4_halfpel_h, 0);
+		printf("%s - interpfield-h -round0 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0x9538d6df)?"| ERROR": "" );
+
+		TEST_MB(interpolate8x4_halfpel_h, 1);
+		printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0xde5f1db4)?"| ERROR": "" );
+
+
+		TEST_MB(interpolate8x4_halfpel_v, 0);
+		printf("%s - interpfield- v-round0 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0xea5a69ef)?"| ERROR": "" );
+
+		TEST_MB(interpolate8x4_halfpel_v, 1);
+		printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0x4f10ec0f)?"| ERROR": "" );
+
+
+		TEST_MB(interpolate8x4_halfpel_hv, 0);
+		printf("%s - interpfield-hv-round0 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0xf97ee367)?"| ERROR": "" );
+
+		TEST_MB(interpolate8x4_halfpel_hv, 1);
+		printf("%s -                round1 %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, iCrc,
+			   (iCrc!=0xb6a9f581)?"| ERROR": "" );
+/* End of 8x4 functions */
+
 		printf( " --- \n" );
 	}
 }
 
+#undef ENTER
+#undef LEAVE
+#undef TEST_MB
+#undef TEST_MB2
+
 /*********************************************************************
  * test transfer
  *********************************************************************/
@@ -527,6 +591,7 @@
 }                                         \
 emms();                                   \
 t = (gettime_usec()-t -overhead) / nb_tests;\
+byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
 s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
 
 #define TEST_TRANSFER(FUNC, DST, SRC)         \
@@ -553,6 +618,7 @@
 }                                         \
 emms();                                   \
 t = (gettime_usec()-t -overhead) / nb_tests;\
+byte_swap((uint8_t*)(DST), 8*32*sizeof((DST)[0]), sizeof((DST)[0]));  \
 s = calc_crc((uint8_t*)(DST), 8*32*sizeof((DST)[0]), CRC32_INITIAL)
 
 #define TEST_TRANSFER2(FUNC, DST, SRC, R1)    \
@@ -599,6 +665,14 @@
 				cpu->name, t, s,
 				(s!=0xee7ccbb4)?"| ERROR": "");
 
+    /* New functions for field prediction by CK 1.10.2005 */
+#pragma NEW8X4
+		TEST_TRANSFER(transfer8x4_copy, Dst8, Src8);
+		printf("%s - 8to4      %.3f usec       crc32=0x%08x %s\n",
+			   cpu->name, t, s,
+			   (s!=0xbb9c3db5)?"| ERROR": "");
+/* End of new functions */
+
 		TEST_TRANSFER(transfer8x8_copy, Dst8, Src8);
 		printf("%s - 8to8      %.3f usec       crc32=0x%08x %s\n",
 			   cpu->name, t, s,
@@ -642,7 +716,8 @@
   for(q=1; q<=max_Q; ++q) {                 \
 	for(tst=0; tst<nb_tests; ++tst)         \
 	  (FUNC)((DST), (SRC), q, mpeg_quant_matrices);              \
-	s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
+	byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
+	s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
   }                                         \
   emms();                                   \
 }                                           \
@@ -657,7 +732,8 @@
   for(q=1; q<=max_Q; ++q) {                 \
 	for(tst=0; tst<nb_tests; ++tst)         \
 	  (FUNC)((DST), (SRC), q, q, mpeg_quant_matrices);           \
-	s = calc_crc((uint8_t*)(DST), 64*sizeof(int16_t), s); \
+	byte_swap((uint8_t*)(DST), 64*sizeof((DST)[0]), sizeof((DST)[0]));  \
+	s = calc_crc((uint8_t*)(DST), 64*sizeof((DST)[0]), s); \
   }                                         \
   emms();                                   \
 }                                           \
@@ -877,10 +953,10 @@
  * test non-zero AC counting
  *********************************************************************/
 
-#define TEST_CBP(FUNC, SRC)               \
+#define TEST_CBP(FUNC, SRC, NB)           \
 t = gettime_usec();                       \
 emms();                                   \
-for(tst=0; tst<nb_tests; ++tst) {         \
+for(tst=0; tst<NB; ++tst) {         \
   cbp = (FUNC)((SRC));                    \
 }                                         \
 emms();                                   \
@@ -889,12 +965,13 @@
 void test_cbp()
 {
 	const int nb_tests = 10000*speed_ref;
-	int i;
+	int i, n, m;
 	CPU *cpu;
 	DECLARE_ALIGNED_MATRIX(Src1, 6, 64, int16_t, 16);
 	DECLARE_ALIGNED_MATRIX(Src2, 6, 64, int16_t, 16);
 	DECLARE_ALIGNED_MATRIX(Src3, 6, 64, int16_t, 16);
 	DECLARE_ALIGNED_MATRIX(Src4, 6, 64, int16_t, 16);
+  DECLARE_ALIGNED_MATRIX(Src5, 6, 64, int16_t, 16);
 
 	printf( "\n =====  test cbp =====\n" );
 
@@ -903,6 +980,7 @@
 		Src2[i] = (i<3*64);               /* half-full */
 		Src3[i] = ((i+32)>3*64);
 		Src4[i] = (i==(3*64+2) || i==(5*64+9));
+    Src5[i] = ieee_rand(0,1) ? -1 : 1;  /* +/- test */
 	}
 
 	for(cpu = cpu_list; cpu->name!=0; ++cpu)
@@ -913,20 +991,53 @@
 		if (!init_cpu(cpu))
 			continue;
 
-		TEST_CBP(calc_cbp, Src1);
+		TEST_CBP(calc_cbp, Src1, nb_tests);
 		printf("%s -   calc_cbp#1 %.3f usec       cbp=0x%02x %s\n",
 			   cpu->name, t, cbp, (cbp!=0x15)?"| ERROR": "");
-		TEST_CBP(calc_cbp, Src2);
+		TEST_CBP(calc_cbp, Src2, nb_tests);
 		printf("%s -   calc_cbp#2 %.3f usec       cbp=0x%02x %s\n",
 			   cpu->name, t, cbp, (cbp!=0x38)?"| ERROR": "");
-		TEST_CBP(calc_cbp, Src3);
+		TEST_CBP(calc_cbp, Src3, nb_tests);
 		printf("%s -   calc_cbp#3 %.3f usec       cbp=0x%02x %s\n",
 			   cpu->name, t, cbp, (cbp!=0x0f)?"| ERROR": "" );
-		TEST_CBP(calc_cbp, Src4);
+		TEST_CBP(calc_cbp, Src4, nb_tests);
 		printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
 			   cpu->name, t, cbp, (cbp!=0x05)?"| ERROR": "" );
+		TEST_CBP(calc_cbp, Src5, nb_tests);
+		printf("%s -   calc_cbp#4 %.3f usec       cbp=0x%02x %s\n",
+			   cpu->name, t, cbp, (cbp!=0x3f)?"| ERROR": "" );
 		printf( " --- \n" );
 	}
+
+	for(cpu = cpu_list; cpu->name!=0; ++cpu)  /* bench suggested by Carlo (carlo dot bramix at libero dot it) */
+	{
+		double t;
+		int tst, cbp, err;
+
+		if (!init_cpu(cpu))
+			continue;
+
+    err = 0;
+    for(n=0; n<6; ++n)
+    {
+      for(m=0; m<64; ++m)
+      {
+        for(i=0; i<6*64; ++i)
+          Src1[i] = (i== (m + n*64));
+
+        TEST_CBP(calc_cbp, Src1, 1);
+        if (cbp!= (((m!=0)<<(5-n))))
+        {
+          printf( "%s -   calc_cbp#5: ERROR at pos %d / %d!\n", cpu->name, n, m);
+          err = 1;
+          break;
+        }
+      }
+    }
+    if (!err)
+      printf( " %s -    calc_cbp#5 : OK\n", cpu->name );
+
+	}
 }
 
 /*********************************************************************
@@ -1389,8 +1500,8 @@
 		xframe.bitstream = buf + pos;
 		xframe.length = buf_size - pos;
 		xframe.output.plane[0] = (uint8_t*)(((size_t)yuv_out + 15) & ~15);
-		xframe.output.plane[1] = xframe.output.plane[0] + bps*height;
-		xframe.output.plane[2] = xframe.output.plane[1] + bps/2;
+		xframe.output.plane[1] = (uint8_t*)xframe.output.plane[0] + bps*height;
+		xframe.output.plane[2] = (uint8_t*)xframe.output.plane[1] + bps/2;
 		xframe.output.stride[0] = bps;
 		xframe.output.stride[1] = bps;
 		xframe.output.stride[2] = bps;
@@ -1408,10 +1519,10 @@
 		nb++;
 
     for(y=0; y<height/2; ++y) {
-		  chksum = calc_crc(xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
-			chksum = calc_crc(xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
-			chksum = calc_crc(xframe.output.plane[1] + y*bps, width/2, chksum);
-			chksum = calc_crc(xframe.output.plane[2] + y*bps, width/2, chksum);
+		  chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+0)*bps, width, chksum);
+			chksum = calc_crc((uint8_t*)xframe.output.plane[0] + (2*y+1)*bps, width, chksum);
+			chksum = calc_crc((uint8_t*)xframe.output.plane[1] + y*bps, width/2, chksum);
+			chksum = calc_crc((uint8_t*)xframe.output.plane[2] + y*bps, width/2, chksum);
 		}
 		if (pos==buf_size)
 			break;
@@ -1594,6 +1705,145 @@
 	}
 #endif
 }
+
+/*********************************************************************
+ * test some YUV func
+ *********************************************************************/
+  
+#define ENTER \
+for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0;   \
+t = gettime_usec();                   \
+emms();
+
+#define LEAVE \
+emms();                             \
+t = (gettime_usec() - t) / nb_tests;  \
+	iCrc = calc_crc((uint8_t*)Dst0, sizeof(Dst0), CRC32_INITIAL)
+
+#define TEST_YUYV(FUNC, S)                \
+ENTER                               \
+for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], S*WIDTH, Src0[0], Src0[1], Src0[2], WIDTH, WIDTH/2, WIDTH, HEIGHT, 0); \
+LEAVE
+
+#define WIDTH 128
+#define HEIGHT 32
+void test_yuv()
+{
+	const int nb_tests = 200*speed_ref;
+	CPU *cpu;
+	uint8_t Src0[3][WIDTH*HEIGHT];
+	uint8_t Dst0[4][WIDTH*HEIGHT];
+	int i, j;
+	double t;
+	int tst, iCrc;
+
+	colorspace_init();
+	ieee_reseed(1);
+	for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
+	for(i=0; i<(int)sizeof(Dst0); ++i) Dst0[0][i] = 0x5a;
+
+	printf( "\n ===  test YUV ===\n" );
+
+	init_cpu(&cpu_list[0]);
+	TEST_YUYV(yv12_to_yuyv_c, 4);
+	printf(" yv12_to_yuyv_c %.3f usec       crc32=0x%08x %s\n",
+		   t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
+	TEST_YUYV(yv12_to_uyvy_c, 4);
+	printf(" yv12_to_uyvy_c %.3f usec       crc32=0x%08x %s\n",
+		   t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
+
+#ifdef ARCH_IS_IA32
+	init_cpu(&cpu_list[1]);
+	TEST_YUYV(yv12_to_yuyv_mmx, 4);
+	printf(" yv12_to_yuyv_mmx %.3f usec       crc32=0x%08x %s\n",
+		t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
+
+	TEST_YUYV(yv12_to_uyvy_mmx, 4);
+	printf(" yv12_to_uyvy_mmx %.3f usec       crc32=0x%08x %s\n",
+		t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
+#endif
+
+#ifdef ARCH_IS_PPC
+	init_cpu(&cpu_list[1]);
+	TEST_YUYV(yv12_to_yuyv_altivec_c, 4);
+	printf(" yv12_to_yuyv_altivec_c %.3f usec       crc32=0x%08x %s\n",
+		t, iCrc, (iCrc!=0xeb1a0b0a)?"| ERROR": "" );
+
+	TEST_YUYV(yv12_to_uyvy_altivec_c, 4);
+	printf(" yv12_to_uyvy_altivec_c %.3f usec       crc32=0x%08x %s\n",
+		t, iCrc, (iCrc!=0x6e82f55b)?"| ERROR": "" );
+#endif
+	printf( " --- \n" );
+}
+
+#define TEST_YV2(FUNC, WITH_UV, WITH_FLIP)        \
+ENTER                               \
+for(tst=0; tst<nb_tests; ++tst) (FUNC)(Dst0[0], Dst0[1], Dst0[2], WIDTH, WIDTH, \
+	Src0[0], (WITH_UV) ? Src0[1] : 0, (WITH_UV) ? Src0[2] : 0,  WIDTH, WIDTH, \
+	WIDTH-2, HEIGHT-2, WITH_FLIP); \
+LEAVE
+
+#define PRINT_NxN(DATA,W,H,STR)   {   \
+	int i,j; \
+	for(j=0; j<(H); ++j) { \
+		for(i=0; i<(W); ++i) printf( "0x%.2x ", (DATA)[i+j*(STR)] );\
+		printf("\n"); \
+	} \
+	printf("---\n"); \
+}
+
+static const int yv12_CRCs[2][2] = { 
+	{0x5cab7cf0,0xdab46541} 
+,       {0xe8bae865,0x1faf77b7}
+};
+
+void test_yuv2()
+{
+	const int nb_tests = 800*speed_ref;
+	CPU *cpu;
+	uint8_t Src0[3][WIDTH*HEIGHT];
+	uint8_t Dst0[3][WIDTH*HEIGHT];
+	int with_uv, with_flip;
+	int i, j;
+	double t;
+	int tst, iCrc;
+
+	colorspace_init();
+	ieee_reseed(1);
+	for(i=0; i<(int)sizeof(Src0); ++i) Src0[0][i] = ieee_rand(0,255);
+
+	printf( "\n ===  test YV2 ===\n" );
+        for(with_flip=0; with_flip<=1; ++with_flip) {
+        	for(with_uv=0; with_uv<=1; ++with_uv) {
+			init_cpu(&cpu_list[0]);
+			TEST_YV2(yv12_to_yv12_c, with_uv, with_flip);
+			printf(" yv12_to_yv12_c   %.3f usec      \tcrc32=0x%08x %s\n",
+				t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
+			/* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
+
+#ifdef ARCH_IS_IA32
+			init_cpu(&cpu_list[1]);
+			TEST_YV2(yv12_to_yv12_mmx, with_uv, with_flip);
+			printf(" yv12_to_yv12_mmx %.3f usec     \tcrc32=0x%08x %s\n",
+				t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
+			/* if (!with_uv) PRINT_NxN(Dst0[1], WIDTH/2, HEIGHT/2, WIDTH ); */
+
+			TEST_YV2(yv12_to_yv12_xmm, with_uv, with_flip);
+			printf(" yv12_to_yv12_xmm %.3f usec     \tcrc32=0x%08x %s\n",
+				t, iCrc, (iCrc!=yv12_CRCs[with_flip][with_uv])?"| ERROR": "" );
+#endif
+		}
+
+		printf( " --- \n" );
+	}
+	printf( " ===== \n" );
+}
+
+#undef WIDTH
+#undef HEIGHT
+#undef ENTER
+#undef LEAVE
+
 /*********************************************************************/
 
 static uint32_t __inline log2bin_v1(uint32_t value)
@@ -1716,6 +1966,137 @@
 }
 
 /*********************************************************************
+ * test compiler
+ *********************************************************************/
+
+void test_compiler() {
+  int nb_err = 0;
+  int32_t v;
+  if (sizeof(uint16_t)<2) {
+    printf( "ERROR: sizeof(uint16_t)<2 !!\n" );
+    nb_err++;
+  }
+  if (sizeof(int16_t)<2) {
+    printf( "ERROR: sizeof(int16_t)<2 !!\n" );
+    nb_err++;
+  }
+  if (sizeof(uint8_t)!=1) {
+    printf( "ERROR: sizeof(uint8_t)!=1 !!\n" );
+    nb_err++;
+  }
+  if (sizeof(int8_t)!=1) {
+    printf( "ERROR: sizeof(int8_t)!=1 !!\n" );
+    nb_err++;
+  }
+  if (sizeof(uint32_t)<4) {
+    printf( "ERROR: sizeof(uint32_t)<4 !!\n" );
+    nb_err++;
+  }
+  if (sizeof(int32_t)<4) {
+    printf( "ERROR: sizeof(int32_t)<4 !!\n" );
+    nb_err++;
+  }
+         /* yes, i know, this test is silly. But better be safe than sorry. :) */
+  for(v=1000; v>=0; v--) {
+    if ( (v>>2) != v/4)
+      nb_err++;
+  }
+  for(v=-1000; v!=-1; v++) {
+    if ( (v>>2) != (v/4)-!!(v%4))
+      nb_err++;
+  }
+  if (nb_err!=0) {
+    printf( "ERROR! please post your platform/compiler specs to xvid-devel@xvid.org !\n" );
+  }
+}
+/*********************************************************************
+ * test SSIM functions
+ *********************************************************************/
+
+typedef int (*lumfunc)(uint8_t* ptr, int stride);
+typedef void (*csfunc)(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
+
+extern int lum_8x8_c(uint8_t* ptr, int stride);
+extern int lum_8x8_mmx(uint8_t* ptr, int stride);
+extern int lum_2x8_c(uint8_t* ptr, int stride);
+extern void consim_c(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
+extern void consim_mmx(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
+extern void consim_sse2(uint8_t* ptro, uint8_t* ptrc, int stride, int lumo, int lumc, int* pdevo, int* pdevc, int* pcorr);
+
+void test_SSIM()
+{
+	const int nb_tests = 3000*speed_ref;
+	int tst;
+	CPU *cpu;
+	int i;
+	int devs[3];
+	long lumo, lumc;
+	DECLARE_ALIGNED_MATRIX(Ref1, 16, 16, uint8_t, 16);
+	DECLARE_ALIGNED_MATRIX(Ref2, 16, 16, uint8_t, 16);
+	lumfunc lum8x8;
+	lumfunc lum2x8;
+	csfunc  csim;
+
+	ieee_reseed(1);
+	printf( "\n ======  test SSIM ======\n" );
+	for(i=0; i<16*16;++i) {
+		long v1, v2;
+		v1 = ieee_rand(-256, 511);
+		v2 = ieee_rand(-256, 511);
+		Ref1[i] = (v1<0) ? 0 : (v1>255) ? 255 : v1;
+		Ref2[i] = (v2<0) ? 0 : (v2>255) ? 255 : v2;
+	}
+	lumc = ieee_rand(0, 255);
+	lumo = ieee_rand(0, 255);
+
+	for(cpu = cpu_list; cpu->name!=0; ++cpu)
+	{
+		double t;
+		int m;
+		if (!init_cpu(cpu))
+			continue;
+		lum8x8 = lum_8x8_c;
+		lum2x8 = lum_2x8_c;
+		csim   = consim_c;
+		if (cpu->cpu & XVID_CPU_MMX){
+			lum8x8 = lum_8x8_mmx;
+			csim = consim_mmx;
+		}
+		if (cpu->cpu & XVID_CPU_MMX){
+			csim = consim_sse2;
+		}
+
+		t = gettime_usec();
+		emms();
+		for(tst=0; tst<nb_tests; ++tst) m = lum8x8(Ref1, 16);
+		emms();
+		t = (gettime_usec() - t) / nb_tests;
+		printf("%s - ssim-lum8x8    %.3f usec       m=%d %s\n",
+			   cpu->name, t, m,
+			   (m!=8230)?"| ERROR": "" );
+
+		t = gettime_usec();
+		emms();
+		for(tst=0; tst<nb_tests; ++tst) m = lum2x8(Ref1+8, 16);
+		emms();
+		t = (gettime_usec() - t) / nb_tests;
+		printf("%s - ssim-lum2x8    %.3f usec       m=%d %s\n",
+			   cpu->name, t, m,
+			   (m!=681)?"| ERROR": "" );
+
+		t = gettime_usec();
+		emms();
+		for(tst=0; tst<nb_tests; ++tst) csim(Ref1, Ref2, 16, lumo, lumc, devs+0, devs+1, devs+2);
+		emms();
+		t = (gettime_usec() - t) / nb_tests;
+		printf("%s - ssim-consim    %.3f usec       devs=[0x%x 0x%x 0x%x] %s\n",
+			   cpu->name, t, devs[0], devs[1], devs[2],
+			   (devs[0]!=0x1bdf0f || devs[1]!=0x137258 ||  devs[2]!=0xcdb13)?"| ERROR": "" );
+		printf( " --- \n" );
+	}
+}
+
+/*********************************************************************
  * main
  *********************************************************************/
 
@@ -1783,6 +2164,10 @@
 	if (what==0 || what==10) test_sse();
 	if (what==0 || what==11) test_log2bin();
 	if (what==0 || what==12) test_gcd();
+	if (what==0 || what==13) test_compiler();
+	if (what==0 || what==14) test_yuv();
+	if (what==0 || what==15) test_SSIM();
+	if (what==0 || what==16) test_yuv2();
 
 
 	if (what==7) {