[sdl_omap.git] / test / testvidinfo.c


/* 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);
}
Commit	Line	Data
e14743d1	1
	2	/* Simple program -- figure out what kind of video display we have */
	3
	4	#include <stdlib.h>
	5	#include <stdio.h>
	6	#include <stdlib.h>
	7	#include <string.h>
	8
	9	#include "SDL.h"
	10
	11	#define NUM_BLITS 10
	12	#define NUM_UPDATES 500
	13
	14	#define FLAG_MASK (SDL_HWSURFACE \| SDL_FULLSCREEN \| SDL_DOUBLEBUF \| \
	15	SDL_SRCCOLORKEY \| SDL_SRCALPHA \| SDL_RLEACCEL \| \
	16	SDL_RLEACCELOK)
	17
	18	void PrintFlags(Uint32 flags)
	19	{
	20	printf("0x%8.8x", (flags & FLAG_MASK));
	21	if ( flags & SDL_HWSURFACE ) {
	22	printf(" SDL_HWSURFACE");
	23	} else {
	24	printf(" SDL_SWSURFACE");
	25	}
	26	if ( flags & SDL_FULLSCREEN ) {
	27	printf(" \| SDL_FULLSCREEN");
	28	}
	29	if ( flags & SDL_DOUBLEBUF ) {
	30	printf(" \| SDL_DOUBLEBUF");
	31	}
	32	if ( flags & SDL_SRCCOLORKEY ) {
	33	printf(" \| SDL_SRCCOLORKEY");
	34	}
	35	if ( flags & SDL_SRCALPHA ) {
	36	printf(" \| SDL_SRCALPHA");
	37	}
	38	if ( flags & SDL_RLEACCEL ) {
	39	printf(" \| SDL_RLEACCEL");
	40	}
	41	if ( flags & SDL_RLEACCELOK ) {
	42	printf(" \| SDL_RLEACCELOK");
	43	}
	44	}
	45
	46	int RunBlitTests(SDL_Surface screen, SDL_Surface bmp, int blitcount)
	47	{
	48	int i, j;
	49	int maxx;
	50	int maxy;
	51	SDL_Rect dst;
	52
	53	maxx = (int)screen->w - bmp->w + 1;
	54	maxy = (int)screen->h - bmp->h + 1;
	55	for ( i = 0; i < NUM_UPDATES; ++i ) {
	56	for ( j = 0; j < blitcount; ++j ) {
	57	if ( maxx ) {
	58	dst.x = rand() % maxx;
	59	} else {
	60	dst.x = 0;
	61	}
	62	if ( maxy ) {
	63	dst.y = rand() % maxy;
	64	} else {
65	dst.y = 0;
66	}
67	dst.w = bmp->w;
68	dst.h = bmp->h;
69	SDL_BlitSurface(bmp, NULL, screen, &dst);
70	}
71	SDL_Flip(screen);
72	}
73
74	return i;
75	}
76
77	int RunModeTests(SDL_Surface *screen)
78	{
79	Uint32 then, now;
80	Uint32 frames;
81	float seconds;
82	int i;
83	Uint8 r, g, b;
84	SDL_Surface bmp, bmpcc, *tmp;
85	SDL_Event event;
86
87	while ( SDL_PollEvent(&event) ) {
88	if ( event.type == SDL_KEYDOWN )
89	return 0;
90	}
91
92	/* First test fills and screen update speed */
93	printf("Running color fill and fullscreen update test\n");
94	then = SDL_GetTicks();
95	frames = 0;
96	for ( i = 0; i < 256; ++i ) {
97	r = i;
98	g = 0;
99	b = 0;
100	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
101	SDL_Flip(screen);
102	++frames;
103	}
104	for ( i = 0; i < 256; ++i ) {
105	r = 0;
106	g = i;
107	b = 0;
108	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
109	SDL_Flip(screen);
110	++frames;
111	}
112	for ( i = 0; i < 256; ++i ) {
113	r = 0;
114	g = 0;
115	b = i;
116	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
117	SDL_Flip(screen);
118	++frames;
119	}
120	now = SDL_GetTicks();
121	seconds = (float)(now - then) / 1000.0f;
122	if ( seconds > 0.0f ) {
123	printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds);
124	} else {
125	printf("%d fills and flips in zero seconds!n", frames);
126	}
127
128	/* clear the screen after fill test */
129	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
130	SDL_Flip(screen);
131
132	while ( SDL_PollEvent(&event) ) {
133	if ( event.type == SDL_KEYDOWN )
134	return 0;
135	}
136
137	/* run the generic blit test */
138	bmp = SDL_LoadBMP("sample.bmp");
139	if ( ! bmp ) {
140	printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
141	return 0;
142	}
143	printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",
144	bmp->w, bmp->h, bmp->format->BitsPerPixel);
145	PrintFlags(bmp->flags);
146	printf("\n");
147	then = SDL_GetTicks();
148	frames = RunBlitTests(screen, bmp, NUM_BLITS);
149	now = SDL_GetTicks();
150	seconds = (float)(now - then) / 1000.0f;
151	if ( seconds > 0.0f ) {
152	printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
153	} else {
154	printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
155	}
156
157	/* clear the screen after blit test */
158	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
159	SDL_Flip(screen);
160
161	while ( SDL_PollEvent(&event) ) {
162	if ( event.type == SDL_KEYDOWN )
163	return 0;
164	}
165
166	/* run the colorkeyed blit test */
167	bmpcc = SDL_LoadBMP("sample.bmp");
168	if ( ! bmpcc ) {
169	printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
170	return 0;
171	}
172	printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",
173	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
174	SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY \| SDL_RLEACCEL, (Uint8 )bmpcc->pixels);
175
176	PrintFlags(bmpcc->flags);
177	printf("\n");
178	then = SDL_GetTicks();
179	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
180	now = SDL_GetTicks();
181	seconds = (float)(now - then) / 1000.0f;
182	if ( seconds > 0.0f ) {
183	printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
184	} else {
185	printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
186	}
187
188	/* clear the screen after cc blit test */
189	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
190	SDL_Flip(screen);
191
192	while ( SDL_PollEvent(&event) ) {
193	if ( event.type == SDL_KEYDOWN )
194	return 0;
195	}
196
197	/* run the generic blit test */
198	tmp = bmp;
199	bmp = SDL_DisplayFormat(bmp);
200	SDL_FreeSurface(tmp);
201	if ( ! bmp ) {
202	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
203	return 0;
204	}
205	printf("Running display format blit test: %dx%d at %d bpp, flags: ",
206	bmp->w, bmp->h, bmp->format->BitsPerPixel);
207	PrintFlags(bmp->flags);
208	printf("\n");
209	then = SDL_GetTicks();
210	frames = RunBlitTests(screen, bmp, NUM_BLITS);
211	now = SDL_GetTicks();
212	seconds = (float)(now - then) / 1000.0f;
213	if ( seconds > 0.0f ) {
214	printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
215	} else {
216	printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
217	}
218
219	/* clear the screen after blit test */
220	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
221	SDL_Flip(screen);
222
223	while ( SDL_PollEvent(&event) ) {
224	if ( event.type == SDL_KEYDOWN )
225	return 0;
226	}
227
228	/* run the colorkeyed blit test */
229	tmp = bmpcc;
230	bmpcc = SDL_DisplayFormat(bmpcc);
231	SDL_FreeSurface(tmp);
232	if ( ! bmpcc ) {
233	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
234	return 0;
235	}
236	printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",
237	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
238	PrintFlags(bmpcc->flags);
239	printf("\n");
240	then = SDL_GetTicks();
241	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
242	now = SDL_GetTicks();
243	seconds = (float)(now - then) / 1000.0f;
244	if ( seconds > 0.0f ) {
245	printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
246	} else {
247	printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
248	}
249
250	/* clear the screen after cc blit test */
251	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
252	SDL_Flip(screen);
253
254	while ( SDL_PollEvent(&event) ) {
255	if ( event.type == SDL_KEYDOWN )
256	return 0;
257	}
258
259	/* run the alpha blit test only if screen bpp>8 */
260	if (bmp->format->BitsPerPixel>8)
261	{
262	SDL_FreeSurface(bmp);
263	bmp = SDL_LoadBMP("sample.bmp");
264	SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
265	tmp = bmp;
266	bmp = SDL_DisplayFormat(bmp);
267	SDL_FreeSurface(tmp);
268	if ( ! bmp ) {
269	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
270	return 0;
271	}
272	printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
273	bmp->w, bmp->h, bmp->format->BitsPerPixel);
274	PrintFlags(bmp->flags);
275	printf("\n");
276	then = SDL_GetTicks();
277	frames = RunBlitTests(screen, bmp, NUM_BLITS);
278	now = SDL_GetTicks();
279	seconds = (float)(now - then) / 1000.0f;
280	if ( seconds > 0.0f ) {
281	printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
282	} else {
283	printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
284	}
285	}
286
287	/* clear the screen after alpha blit test */
288	SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
289	SDL_Flip(screen);
290
291	while ( SDL_PollEvent(&event) ) {
292	if ( event.type == SDL_KEYDOWN )
293	return 0;
294	}
295
296	/* run the cc+alpha blit test only if screen bpp>8 */
297	if (bmp->format->BitsPerPixel>8)
298	{
299	SDL_FreeSurface(bmpcc);
300	bmpcc = SDL_LoadBMP("sample.bmp");
301	SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
302	SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY \| SDL_RLEACCEL, (Uint8 )bmpcc->pixels);
303	tmp = bmpcc;
304	bmpcc = SDL_DisplayFormat(bmpcc);
305	SDL_FreeSurface(tmp);
306	if ( ! bmpcc ) {
307	printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
308	return 0;
309	}
310	printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
311	bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
312	PrintFlags(bmpcc->flags);
313	printf("\n");
314	then = SDL_GetTicks();
315	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
316	now = SDL_GetTicks();
317	seconds = (float)(now - then) / 1000.0f;
318	if ( seconds > 0.0f ) {
319	printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
320	} else {
321	printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
322	}
323	}
324
325	SDL_FreeSurface(bmpcc);
326	SDL_FreeSurface(bmp);
327
328	while ( SDL_PollEvent(&event) ) {
329	if ( event.type == SDL_KEYDOWN )
330	return 0;
331	}
332	return 1;
333	}
334
335	void RunVideoTests()
336	{
337	static const struct {
338	int w, h, bpp;
339	} mode_list[] = {
340	{ 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 },
341	{ 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 },
342	{ 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 }
343	};
344	static const Uint32 flags[] = {
345	(SDL_SWSURFACE),
346	(SDL_SWSURFACE \| SDL_FULLSCREEN),
347	(SDL_HWSURFACE \| SDL_FULLSCREEN),
348	(SDL_HWSURFACE \| SDL_FULLSCREEN \| SDL_DOUBLEBUF)
349	};
350	int i, j;
351	SDL_Surface *screen;
352
353	/* Test out several different video mode combinations */
354	SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
355	SDL_ShowCursor(0);
356	for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) {
357	for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) {
358	printf("===================================\n");
359	printf("Setting video mode: %dx%d at %d bpp, flags: ",
360	mode_list[i].w,
361	mode_list[i].h,
362	mode_list[i].bpp);
363	PrintFlags(flags[j]);
364	printf("\n");
365	screen = SDL_SetVideoMode(mode_list[i].w,
366	mode_list[i].h,
367	mode_list[i].bpp,
368	flags[j]);
369	if ( ! screen ) {
370	printf("Setting video mode failed: %s\n", SDL_GetError());
371	continue;
372	}
373	if ( (screen->flags & FLAG_MASK) != flags[j] ) {
374	printf("Flags didn't match: ");
375	PrintFlags(screen->flags);
376	printf("\n");
377	continue;
378	}
379	if ( ! RunModeTests(screen) ) {
380	return;
381	}
382	}
383	}
384	}
385
386	int main(int argc, char *argv[])
387	{
388	const SDL_VideoInfo *info;
389	int i;
390	SDL_Rect **modes;
391	char driver[128];
392
393	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
394	fprintf(stderr,
395	"Couldn't initialize SDL: %s\n", SDL_GetError());
396	exit(1);
397	}
398	if ( SDL_VideoDriverName(driver, sizeof(driver)) ) {
399	printf("Video driver: %s\n", driver);
400	}
401	info = SDL_GetVideoInfo();
402	printf(
403	"Current display: %dx%d, %d bits-per-pixel\n",
404	info->current_w, info->current_h, info->vfmt->BitsPerPixel);
405	if ( info->vfmt->palette == NULL ) {
406	printf(" Red Mask = 0x%.8x\n", info->vfmt->Rmask);
407	printf(" Green Mask = 0x%.8x\n", info->vfmt->Gmask);
408	printf(" Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
409	}
410	/* Print available fullscreen video modes */
411	modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
412	if ( modes == (SDL_Rect **)0 ) {
413	printf("No available fullscreen video modes\n");
414	} else
415	if ( modes == (SDL_Rect **)-1 ) {
416	printf("No special fullscreen video modes\n");
417	} else {
418	printf("Fullscreen video modes:\n");
419	for ( i=0; modes[i]; ++i ) {
420	printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel);
421	}
422	}
423	if ( info->wm_available ) {
424	printf("A window manager is available\n");
425	}
426	if ( info->hw_available ) {
427	printf("Hardware surfaces are available (%dK video memory)\n",
428	info->video_mem);
429	}
430	if ( info->blit_hw ) {
431	printf(
432	"Copy blits between hardware surfaces are accelerated\n");
433	}
434	if ( info->blit_hw_CC ) {
435	printf(
436	"Colorkey blits between hardware surfaces are accelerated\n");
437	}
438	if ( info->blit_hw_A ) {
439	printf(
440	"Alpha blits between hardware surfaces are accelerated\n");
441	}
442	if ( info->blit_sw ) {
443	printf(
444	"Copy blits from software surfaces to hardware surfaces are accelerated\n");
445	}
446	if ( info->blit_sw_CC ) {
447	printf(
448	"Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
449	}
450	if ( info->blit_sw_A ) {
451	printf(
452	"Alpha blits from software surfaces to hardware surfaces are accelerated\n");
453	}
454	if ( info->blit_fill ) {
455	printf(
456	"Color fills on hardware surfaces are accelerated\n");
457	}
458
459	if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) {
460	RunVideoTests();
461	}
462
463	SDL_Quit();
464	return(0);
465	}