test/testvidinfo.c - third_party/sdl - Git at Google


 /* Simple program -- figure out what kind of video display we have */

 #include <stdlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include "SDL.h"

 #define NUM_BLITS	10
 #define NUM_UPDATES	500

 #define FLAG_MASK	(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \
                          SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL  | \
                          SDL_RLEACCELOK)

 void PrintFlags(Uint32 flags)
 {
 	printf("0x%8.8x", (flags & FLAG_MASK));
 	if ( flags & SDL_HWSURFACE ) {
 		printf(" SDL_HWSURFACE");
 	} else {
 		printf(" SDL_SWSURFACE");
 	}
 	if ( flags & SDL_FULLSCREEN ) {
 		printf(" | SDL_FULLSCREEN");
 	}
 	if ( flags & SDL_DOUBLEBUF ) {
 		printf(" | SDL_DOUBLEBUF");
 	}
 	if ( flags & SDL_SRCCOLORKEY ) {
 		printf(" | SDL_SRCCOLORKEY");
 	}
 	if ( flags & SDL_SRCALPHA ) {
 		printf(" | SDL_SRCALPHA");
 	}
 	if ( flags & SDL_RLEACCEL ) {
 		printf(" | SDL_RLEACCEL");
 	}
 	if ( flags & SDL_RLEACCELOK ) {
 		printf(" | SDL_RLEACCELOK");
 	}
 }

 int RunBlitTests(SDL_Surface *screen, SDL_Surface *bmp, int blitcount)
 {
 	int i, j;
 	int maxx;
 	int maxy;
 	SDL_Rect dst;

 	maxx = (int)screen->w - bmp->w + 1;
 	maxy = (int)screen->h - bmp->h + 1;
 	for ( i = 0; i < NUM_UPDATES; ++i ) {
 		for ( j = 0; j < blitcount; ++j ) {
 			if ( maxx ) {
 				dst.x = rand() % maxx;
 			} else {
 				dst.x = 0;
 			}
 			if ( maxy ) {
 				dst.y = rand() % maxy;
 			} else {
 				dst.y = 0;
 			}
 			dst.w = bmp->w;
 			dst.h = bmp->h;
 			SDL_BlitSurface(bmp, NULL, screen, &dst);
 		}
 		SDL_Flip(screen);
 	}

 	return i;
 }

 int RunModeTests(SDL_Surface *screen)
 {
 	Uint32 then, now;
 	Uint32 frames;
 	float seconds;
 	int i;
 	Uint8 r, g, b;
 	SDL_Surface *bmp, *bmpcc, *tmp;
 	SDL_Event event;

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

 	/* First test fills and screen update speed */
 	printf("Running color fill and fullscreen update test\n");
 	then = SDL_GetTicks();
 	frames = 0;
 	for ( i = 0; i < 256; ++i ) {
 		r = i;
 		g = 0;
 		b = 0;
 		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 		SDL_Flip(screen);
 		++frames;
 	}
 	for ( i = 0; i < 256; ++i ) {
 		r = 0;
 		g = i;
 		b = 0;
 		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 		SDL_Flip(screen);
 		++frames;
 	}
 	for ( i = 0; i < 256; ++i ) {
 		r = 0;
 		g = 0;
 		b = i;
 		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 		SDL_Flip(screen);
 		++frames;
 	}
 	now = SDL_GetTicks();
 	seconds = (float)(now - then) / 1000.0f;
 	if ( seconds > 0.0f ) {
 		printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds);
 	} else {
 		printf("%d fills and flips in zero seconds!n", frames);
 	}

         /* clear the screen after fill test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the generic blit test */
 	bmp = SDL_LoadBMP("sample.bmp");
 	if ( ! bmp ) {
 		printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
 		return 0;
 	}
 	printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",
 		bmp->w, bmp->h, bmp->format->BitsPerPixel);
 	PrintFlags(bmp->flags);
 	printf("\n");
 	then = SDL_GetTicks();
 	frames = RunBlitTests(screen, bmp, NUM_BLITS);
 	now = SDL_GetTicks();
 	seconds = (float)(now - then) / 1000.0f;
 	if ( seconds > 0.0f ) {
 		printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 	} else {
 		printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 	}

         /* clear the screen after blit test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the colorkeyed blit test */
 	bmpcc = SDL_LoadBMP("sample.bmp");
 	if ( ! bmpcc ) {
 		printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
 		return 0;
 	}
 	printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",
 		bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
         SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);

 	PrintFlags(bmpcc->flags);
 	printf("\n");
 	then = SDL_GetTicks();
 	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 	now = SDL_GetTicks();
 	seconds = (float)(now - then) / 1000.0f;
 	if ( seconds > 0.0f ) {
 		printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 	} else {
 		printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 	}

         /* clear the screen after cc blit test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the generic blit test */
 	tmp = bmp;
 	bmp = SDL_DisplayFormat(bmp);
 	SDL_FreeSurface(tmp);
 	if ( ! bmp ) {
 		printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 		return 0;
 	}
 	printf("Running display format blit test: %dx%d at %d bpp, flags: ",
 		bmp->w, bmp->h, bmp->format->BitsPerPixel);
 	PrintFlags(bmp->flags);
 	printf("\n");
 	then = SDL_GetTicks();
 	frames = RunBlitTests(screen, bmp, NUM_BLITS);
 	now = SDL_GetTicks();
 	seconds = (float)(now - then) / 1000.0f;
 	if ( seconds > 0.0f ) {
 		printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 	} else {
 		printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 	}

         /* clear the screen after blit test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the colorkeyed blit test */
 	tmp = bmpcc;
 	bmpcc = SDL_DisplayFormat(bmpcc);
 	SDL_FreeSurface(tmp);
 	if ( ! bmpcc ) {
 		printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 		return 0;
 	}
 	printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",
 		bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
 	PrintFlags(bmpcc->flags);
 	printf("\n");
 	then = SDL_GetTicks();
 	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 	now = SDL_GetTicks();
 	seconds = (float)(now - then) / 1000.0f;
 	if ( seconds > 0.0f ) {
 		printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 	} else {
 		printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 	}

         /* clear the screen after cc blit test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the alpha blit test only if screen bpp>8 */
         if (bmp->format->BitsPerPixel>8)
         {
 		SDL_FreeSurface(bmp);
                 bmp = SDL_LoadBMP("sample.bmp");
 		SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
 		tmp = bmp;
 		bmp = SDL_DisplayFormat(bmp);
 		SDL_FreeSurface(tmp);
 		if ( ! bmp ) {
 			printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 			return 0;
 		}
 		printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
 			bmp->w, bmp->h, bmp->format->BitsPerPixel);
 		PrintFlags(bmp->flags);
 		printf("\n");
 		then = SDL_GetTicks();
 		frames = RunBlitTests(screen, bmp, NUM_BLITS);
 		now = SDL_GetTicks();
 		seconds = (float)(now - then) / 1000.0f;
 		if ( seconds > 0.0f ) {
 			printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 		} else {
 			printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 		}
 	}

         /* clear the screen after alpha blit test */
         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 	SDL_Flip(screen);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}

         /* run the cc+alpha blit test only if screen bpp>8 */
         if (bmp->format->BitsPerPixel>8)
         {
 		SDL_FreeSurface(bmpcc);
                 bmpcc = SDL_LoadBMP("sample.bmp");
 		SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
                 SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);
 		tmp = bmpcc;
 		bmpcc = SDL_DisplayFormat(bmpcc);
 		SDL_FreeSurface(tmp);
 		if ( ! bmpcc ) {
 			printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 			return 0;
 		}
 		printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
 			bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
 		PrintFlags(bmpcc->flags);
 		printf("\n");
 		then = SDL_GetTicks();
 		frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 		now = SDL_GetTicks();
 		seconds = (float)(now - then) / 1000.0f;
 		if ( seconds > 0.0f ) {
 			printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 		} else {
 			printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 		}
 	}

 	SDL_FreeSurface(bmpcc);
 	SDL_FreeSurface(bmp);

 	while ( SDL_PollEvent(&event) ) {
 		if ( event.type == SDL_KEYDOWN )
 			return 0;
 	}
 	return 1;
 }

 void RunVideoTests()
 {
 	static const struct {
 		int w, h, bpp;
 	} mode_list[] = {
 		{ 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 },
 		{ 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 },
 		{ 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 }
 	};
 	static const Uint32 flags[] = {
 		(SDL_SWSURFACE),
 		(SDL_SWSURFACE | SDL_FULLSCREEN),
 		(SDL_HWSURFACE | SDL_FULLSCREEN),
 		(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF)
 	};
 	int i, j;
 	SDL_Surface *screen;

 	/* Test out several different video mode combinations */
 	SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
 	SDL_ShowCursor(0);
 	for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) {
 		for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) {
 			printf("===================================\n");
 			printf("Setting video mode: %dx%d at %d bpp, flags: ",
 			                          mode_list[i].w,
 			                          mode_list[i].h,
 			                          mode_list[i].bpp);
 			PrintFlags(flags[j]);
 			printf("\n");
 			screen = SDL_SetVideoMode(mode_list[i].w,
 			                          mode_list[i].h,
 			                          mode_list[i].bpp,
 			                          flags[j]);
 			if ( ! screen ) {
 				printf("Setting video mode failed: %s\n", SDL_GetError());
 				continue;
 			}
 			if ( (screen->flags & FLAG_MASK) != flags[j] ) {
 				printf("Flags didn't match: ");
 				PrintFlags(screen->flags);
 				printf("\n");
 				continue;
 			}
 			if ( ! RunModeTests(screen) ) {
 				return;
 			}
 		}
 	}
 }

 int main(int argc, char *argv[])
 {
 	const SDL_VideoInfo *info;
 	int i;
 	SDL_Rect **modes;
 	char driver[128];

 	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
 		fprintf(stderr,
 			"Couldn't initialize SDL: %s\n", SDL_GetError());
 		exit(1);
 	}
 	if ( SDL_VideoDriverName(driver, sizeof(driver)) ) {
 		printf("Video driver: %s\n", driver);
 	}
 	info = SDL_GetVideoInfo();
 	printf(
 "Current display: %dx%d, %d bits-per-pixel\n",
 		info->current_w, info->current_h, info->vfmt->BitsPerPixel);
 	if ( info->vfmt->palette == NULL ) {
 		printf("	Red Mask = 0x%.8x\n", info->vfmt->Rmask);
 		printf("	Green Mask = 0x%.8x\n", info->vfmt->Gmask);
 		printf("	Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
 	}
 	/* Print available fullscreen video modes */
 	modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
 	if ( modes == (SDL_Rect **)0 ) {
 		printf("No available fullscreen video modes\n");
 	} else
 	if ( modes == (SDL_Rect **)-1 ) {
 		printf("No special fullscreen video modes\n");
 	} else {
 		printf("Fullscreen video modes:\n");
 		for ( i=0; modes[i]; ++i ) {
 			printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel);
 		}
 	}
 	if ( info->wm_available ) {
 		printf("A window manager is available\n");
 	}
 	if ( info->hw_available ) {
 		printf("Hardware surfaces are available (%dK video memory)\n",
 			info->video_mem);
 	}
 	if ( info->blit_hw ) {
 		printf(
 "Copy blits between hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_hw_CC ) {
 		printf(
 "Colorkey blits between hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_hw_A ) {
 		printf(
 "Alpha blits between hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_sw ) {
 		printf(
 "Copy blits from software surfaces to hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_sw_CC ) {
 		printf(
 "Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_sw_A ) {
 		printf(
 "Alpha blits from software surfaces to hardware surfaces are accelerated\n");
 	}
 	if ( info->blit_fill ) {
 		printf(
 "Color fills on hardware surfaces are accelerated\n");
 	}

 	if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) {
 		RunVideoTests();
 	}

 	SDL_Quit();
 	return(0);
 }

	/* Simple program -- figure out what kind of video display we have */

	#include <stdlib.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#include "SDL.h"

	#define NUM_BLITS 10
	#define NUM_UPDATES 500

	#define FLAG_MASK (SDL_HWSURFACE \| SDL_FULLSCREEN \| SDL_DOUBLEBUF \| \
	SDL_SRCCOLORKEY \| SDL_SRCALPHA \| SDL_RLEACCEL \| \
	SDL_RLEACCELOK)

	void PrintFlags(Uint32 flags)
	{
	printf("0x%8.8x", (flags & FLAG_MASK));
	if ( flags & SDL_HWSURFACE ) {
	printf(" SDL_HWSURFACE");
	} else {
	printf(" SDL_SWSURFACE");
	}
	if ( flags & SDL_FULLSCREEN ) {
	printf(" \| SDL_FULLSCREEN");
	}
	if ( flags & SDL_DOUBLEBUF ) {
	printf(" \| SDL_DOUBLEBUF");
	}
	if ( flags & SDL_SRCCOLORKEY ) {
	printf(" \| SDL_SRCCOLORKEY");
	}
	if ( flags & SDL_SRCALPHA ) {
	printf(" \| SDL_SRCALPHA");
	}
	if ( flags & SDL_RLEACCEL ) {
	printf(" \| SDL_RLEACCEL");
	}
	if ( flags & SDL_RLEACCELOK ) {
	printf(" \| SDL_RLEACCELOK");
	}
	}

	int RunBlitTests(SDL_Surface screen, SDL_Surface bmp, int blitcount)
	{
	int i, j;
	int maxx;
	int maxy;
	SDL_Rect dst;

	maxx = (int)screen->w - bmp->w + 1;
	maxy = (int)screen->h - bmp->h + 1;
	for ( i = 0; i < NUM_UPDATES; ++i ) {
	for ( j = 0; j < blitcount; ++j ) {
	if ( maxx ) {
	dst.x = rand() % maxx;
	} else {
	dst.x = 0;
	}
	if ( maxy ) {
	dst.y = rand() % maxy;
	} else {
	dst.y = 0;
	}
	dst.w = bmp->w;
	dst.h = bmp->h;
	SDL_BlitSurface(bmp, NULL, screen, &dst);
	}
	SDL_Flip(screen);
	}

	return i;
	}

	int RunModeTests(SDL_Surface *screen)
	{
	Uint32 then, now;
	Uint32 frames;
	float seconds;
	int i;
	Uint8 r, g, b;
	SDL_Surface bmp, bmpcc, *tmp;
	SDL_Event event;

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* First test fills and screen update speed */
	printf("Running color fill and fullscreen update test\n");
	then = SDL_GetTicks();
	frames = 0;
	for ( i = 0; i < 256; ++i ) {
	r = i;
	g = 0;
	b = 0;
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
	SDL_Flip(screen);
	++frames;
	}
	for ( i = 0; i < 256; ++i ) {
	r = 0;
	g = i;
	b = 0;
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
	SDL_Flip(screen);
	++frames;
	}
	for ( i = 0; i < 256; ++i ) {
	r = 0;
	g = 0;
	b = i;
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
	SDL_Flip(screen);
	++frames;
	}
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds);
	} else {
	printf("%d fills and flips in zero seconds!n", frames);
	}

	/* clear the screen after fill test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the generic blit test */
	bmp = SDL_LoadBMP("sample.bmp");
	if ( ! bmp ) {
	printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",
	bmp->w, bmp->h, bmp->format->BitsPerPixel);
	PrintFlags(bmp->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmp, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

	/* clear the screen after blit test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the colorkeyed blit test */
	bmpcc = SDL_LoadBMP("sample.bmp");
	if ( ! bmpcc ) {
	printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",
	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
	SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY \| SDL_RLEACCEL, (Uint8 )bmpcc->pixels);

	PrintFlags(bmpcc->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

	/* clear the screen after cc blit test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the generic blit test */
	tmp = bmp;
	bmp = SDL_DisplayFormat(bmp);
	SDL_FreeSurface(tmp);
	if ( ! bmp ) {
	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running display format blit test: %dx%d at %d bpp, flags: ",
	bmp->w, bmp->h, bmp->format->BitsPerPixel);
	PrintFlags(bmp->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmp, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

	/* clear the screen after blit test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the colorkeyed blit test */
	tmp = bmpcc;
	bmpcc = SDL_DisplayFormat(bmpcc);
	SDL_FreeSurface(tmp);
	if ( ! bmpcc ) {
	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",
	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
	PrintFlags(bmpcc->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

	/* clear the screen after cc blit test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the alpha blit test only if screen bpp>8 */
	if (bmp->format->BitsPerPixel>8)
	{
	SDL_FreeSurface(bmp);
	bmp = SDL_LoadBMP("sample.bmp");
	SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
	tmp = bmp;
	bmp = SDL_DisplayFormat(bmp);
	SDL_FreeSurface(tmp);
	if ( ! bmp ) {
	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
	bmp->w, bmp->h, bmp->format->BitsPerPixel);
	PrintFlags(bmp->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmp, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}
	}

	/* clear the screen after alpha blit test */
	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}

	/* run the cc+alpha blit test only if screen bpp>8 */
	if (bmp->format->BitsPerPixel>8)
	{
	SDL_FreeSurface(bmpcc);
	bmpcc = SDL_LoadBMP("sample.bmp");
	SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
	SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY \| SDL_RLEACCEL, (Uint8 )bmpcc->pixels);
	tmp = bmpcc;
	bmpcc = SDL_DisplayFormat(bmpcc);
	SDL_FreeSurface(tmp);
	if ( ! bmpcc ) {
	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
	return 0;
	}
	printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
	PrintFlags(bmpcc->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
	printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
	printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}
	}

	SDL_FreeSurface(bmpcc);
	SDL_FreeSurface(bmp);

	while ( SDL_PollEvent(&event) ) {
	if ( event.type == SDL_KEYDOWN )
	return 0;
	}
	return 1;
	}

	void RunVideoTests()
	{
	static const struct {
	int w, h, bpp;
	} mode_list[] = {
	{ 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 },
	{ 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 },
	{ 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 }
	};
	static const Uint32 flags[] = {
	(SDL_SWSURFACE),
	(SDL_SWSURFACE \| SDL_FULLSCREEN),
	(SDL_HWSURFACE \| SDL_FULLSCREEN),
	(SDL_HWSURFACE \| SDL_FULLSCREEN \| SDL_DOUBLEBUF)
	};
	int i, j;
	SDL_Surface *screen;

	/* Test out several different video mode combinations */
	SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
	SDL_ShowCursor(0);
	for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) {
	for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) {
	printf("===================================\n");
	printf("Setting video mode: %dx%d at %d bpp, flags: ",
	mode_list[i].w,
	mode_list[i].h,
	mode_list[i].bpp);
	PrintFlags(flags[j]);
	printf("\n");
	screen = SDL_SetVideoMode(mode_list[i].w,
	mode_list[i].h,
	mode_list[i].bpp,
	flags[j]);
	if ( ! screen ) {
	printf("Setting video mode failed: %s\n", SDL_GetError());
	continue;
	}
	if ( (screen->flags & FLAG_MASK) != flags[j] ) {
	printf("Flags didn't match: ");
	PrintFlags(screen->flags);
	printf("\n");
	continue;
	}
	if ( ! RunModeTests(screen) ) {
	return;
	}
	}
	}
	}

	int main(int argc, char *argv[])
	{
	const SDL_VideoInfo *info;
	int i;
	SDL_Rect **modes;
	char driver[128];

	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
	fprintf(stderr,
	"Couldn't initialize SDL: %s\n", SDL_GetError());
	exit(1);
	}
	if ( SDL_VideoDriverName(driver, sizeof(driver)) ) {
	printf("Video driver: %s\n", driver);
	}
	info = SDL_GetVideoInfo();
	printf(
	"Current display: %dx%d, %d bits-per-pixel\n",
	info->current_w, info->current_h, info->vfmt->BitsPerPixel);
	if ( info->vfmt->palette == NULL ) {
	printf(" Red Mask = 0x%.8x\n", info->vfmt->Rmask);
	printf(" Green Mask = 0x%.8x\n", info->vfmt->Gmask);
	printf(" Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
	}
	/* Print available fullscreen video modes */
	modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
	if ( modes == (SDL_Rect **)0 ) {
	printf("No available fullscreen video modes\n");
	} else
	if ( modes == (SDL_Rect **)-1 ) {
	printf("No special fullscreen video modes\n");
	} else {
	printf("Fullscreen video modes:\n");
	for ( i=0; modes[i]; ++i ) {
	printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel);
	}
	}
	if ( info->wm_available ) {
	printf("A window manager is available\n");
	}
	if ( info->hw_available ) {
	printf("Hardware surfaces are available (%dK video memory)\n",
	info->video_mem);
	}
	if ( info->blit_hw ) {
	printf(
	"Copy blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_hw_CC ) {
	printf(
	"Colorkey blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_hw_A ) {
	printf(
	"Alpha blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw ) {
	printf(
	"Copy blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw_CC ) {
	printf(
	"Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw_A ) {
	printf(
	"Alpha blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_fill ) {
	printf(
	"Color fills on hardware surfaces are accelerated\n");
	}

	if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) {
	RunVideoTests();
	}

	SDL_Quit();
	return(0);
	}