distrib/sdl-1.2.15/test/testwin.c - platform/external/qemu - Git at Google


 /* Bring up a window and play with it */

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

 #define BENCHMARK_SDL

 #define NOTICE(X)	printf("%s", X);

 #include "SDL.h"

 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 static void quit(int rc)
 {
 	SDL_Quit();
 	exit(rc);
 }

 void DrawPict(SDL_Surface *screen, char *bmpfile,
 					int speedy, int flip, int nofade)
 {
 	SDL_Surface *picture;
 	SDL_Rect dest, update;
 	int i, centered;
 	int ncolors;
 	SDL_Color *colors, *cmap;

 	/* Load the image into a surface */
 	if ( bmpfile == NULL ) {
 		bmpfile = "sample.bmp";		/* Sample image */
 	}
 fprintf(stderr, "Loading picture: %s\n", bmpfile);
 	picture = SDL_LoadBMP(bmpfile);
 	if ( picture == NULL ) {
 		fprintf(stderr, "Couldn't load %s: %s\n", bmpfile,
 							SDL_GetError());
 		return;
 	}

 	/* Set the display colors -- on a hicolor display this is a no-op */
 	if ( picture->format->palette ) {
 		ncolors = picture->format->palette->ncolors;
 		colors  = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));
 		cmap    = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));
 		memcpy(colors, picture->format->palette->colors,
 						ncolors*sizeof(SDL_Color));
 	} else {
 		int       r, g, b;

 		/* Allocate 256 color palette */
 		ncolors = 256;
 		colors  = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));
 		cmap    = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));

 		/* Set a 3,3,2 color cube */
 		for ( r=0; r<8; ++r ) {
 			for ( g=0; g<8; ++g ) {
 				for ( b=0; b<4; ++b ) {
 					i = ((r<<5)|(g<<2)|b);
 					colors[i].r = r<<5;
 					colors[i].g = g<<5;
 					colors[i].b = b<<6;
 				}
 			}
 		}
 	}
 NOTICE("testwin: setting colors\n");
 	if ( ! SDL_SetColors(screen, colors, 0, ncolors) &&
 				(screen->format->palette != NULL) ) {
 		fprintf(stderr,
 "Warning: Couldn't set all of the colors, but SDL will map the image\n"
 "         (colormap fading will suffer - try the -warp option)\n"
 		);
 	}

 	/* Set the screen to black (not really necessary) */
 	if ( SDL_LockSurface(screen) == 0 ) {
 		Uint32 black;
 		Uint8 *pixels;

 		black = SDL_MapRGB(screen->format, 0, 0, 0);
 		pixels = (Uint8 *)screen->pixels;
 		for ( i=0; i<screen->h; ++i ) {
 			memset(pixels, black,
 				screen->w*screen->format->BytesPerPixel);
 			pixels += screen->pitch;
 		}
 		SDL_UnlockSurface(screen);
 		SDL_UpdateRect(screen, 0, 0, 0, 0);
 	}

 	/* Display the picture */
 	if ( speedy ) {
 		SDL_Surface *displayfmt;

 fprintf(stderr, "Converting picture\n");
 		displayfmt = SDL_DisplayFormat(picture);
 		if ( displayfmt == NULL ) {
 			fprintf(stderr,
 				"Couldn't convert image: %s\n", SDL_GetError());
 			goto done;
 		}
 		SDL_FreeSurface(picture);
 		picture = displayfmt;
 	}
 	printf("(image surface located in %s memory)\n",
 			(picture->flags&SDL_HWSURFACE) ? "video" : "system");
 	centered = (screen->w - picture->w)/2;
 	if ( centered < 0 ) {
 		centered = 0;
 	}
 	dest.y = (screen->h - picture->h)/2;
 	dest.w = picture->w;
 	dest.h = picture->h;
 NOTICE("testwin: moving image\n");
 	for ( i=0; i<=centered; ++i ) {
 		dest.x = i;
 		update = dest;
 		if ( SDL_BlitSurface(picture, NULL, screen, &update) < 0 ) {
 			fprintf(stderr, "Blit failed: %s\n", SDL_GetError());
 			break;
 		}
 		if ( flip ) {
 			SDL_Flip(screen);
 		} else {
 			SDL_UpdateRects(screen, 1, &update);
 		}
 	}

 #ifdef SCREENSHOT
 	if ( SDL_SaveBMP(screen, "screen.bmp") < 0 )
 		printf("Couldn't save screen: %s\n", SDL_GetError());
 #endif

 #ifndef BENCHMARK_SDL
 	/* Let it sit there for a while */
 	SDL_Delay(5*1000);
 #endif
 	/* Fade the colormap */
 	if ( ! nofade ) {
 		int maxstep;
 		SDL_Color final;
 		SDL_Color palcolors[256];
 		struct {
 			Sint16 r, g, b;
 		} cdist[256];

 NOTICE("testwin: fading out...\n");
 		memcpy(cmap, colors, ncolors*sizeof(SDL_Color));
 		maxstep = 32-1;
 		final.r = 0xFF;
 		final.g = 0x00;
 		final.b = 0x00;
 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
 		for ( i=0; i<ncolors; ++i ) {
 			cdist[i].r = final.r-palcolors[i].r;
 			cdist[i].g = final.g-palcolors[i].g;
 			cdist[i].b = final.b-palcolors[i].b;
 		}
 		for ( i=0; i<=maxstep/2; ++i ) {	/* halfway fade */
 			int c;
 			for ( c=0; c<ncolors; ++c ) {
 				colors[c].r =
 					palcolors[c].r+((cdist[c].r*i))/maxstep;
 				colors[c].g =
 					palcolors[c].g+((cdist[c].g*i))/maxstep;
 				colors[c].b =
 					palcolors[c].b+((cdist[c].b*i))/maxstep;
 			}
 			SDL_SetColors(screen, colors, 0, ncolors);
 			SDL_Delay(1);
 		}
 		final.r = 0x00;
 		final.g = 0x00;
 		final.b = 0x00;
 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
 		for ( i=0; i<ncolors; ++i ) {
 			cdist[i].r = final.r-palcolors[i].r;
 			cdist[i].g = final.g-palcolors[i].g;
 			cdist[i].b = final.b-palcolors[i].b;
 		}
 		maxstep /= 2;
 		for ( i=0; i<=maxstep; ++i ) {		/* finish fade out */
 			int c;
 			for ( c=0; c<ncolors; ++c ) {
 				colors[c].r =
 					palcolors[c].r+((cdist[c].r*i))/maxstep;
 				colors[c].g =
 					palcolors[c].g+((cdist[c].g*i))/maxstep;
 				colors[c].b =
 					palcolors[c].b+((cdist[c].b*i))/maxstep;
 			}
 			SDL_SetColors(screen, colors, 0, ncolors);
 			SDL_Delay(1);
 		}
 		for ( i=0; i<ncolors; ++i ) {
 			colors[i].r = final.r;
 			colors[i].g = final.g;
 			colors[i].b = final.b;
 		}
 		SDL_SetColors(screen, colors, 0, ncolors);
 NOTICE("testwin: fading in...\n");
 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
 		for ( i=0; i<ncolors; ++i ) {
 			cdist[i].r = cmap[i].r-palcolors[i].r;
 			cdist[i].g = cmap[i].g-palcolors[i].g;
 			cdist[i].b = cmap[i].b-palcolors[i].b;
 		}
 		for ( i=0; i<=maxstep; ++i ) {	/* 32 step fade in */
 			int c;
 			for ( c=0; c<ncolors; ++c ) {
 				colors[c].r =
 					palcolors[c].r+((cdist[c].r*i))/maxstep;
 				colors[c].g =
 					palcolors[c].g+((cdist[c].g*i))/maxstep;
 				colors[c].b =
 					palcolors[c].b+((cdist[c].b*i))/maxstep;
 			}
 			SDL_SetColors(screen, colors, 0, ncolors);
 			SDL_Delay(1);
 		}
 NOTICE("testwin: fading over\n");
 	}

 done:
 	/* Free the picture and return */
 	SDL_FreeSurface(picture);
 	free(colors); free(cmap);
 	return;
 }

 int main(int argc, char *argv[])
 {
 	SDL_Surface *screen;
 	/* Options */
 	int speedy, flip, nofade;
 	int delay;
 	int w, h;
 	int desired_bpp;
 	Uint32 video_flags;
 #ifdef BENCHMARK_SDL
 	Uint32 then, now;
 #endif
 	/* Set default options and check command-line */
 	speedy = 0;
 	flip = 0;
 	nofade = 0;
 	delay = 1;

 #ifdef _WIN32_WCE
 	w = 240;
 	h = 320;
 	desired_bpp = 8;
 	video_flags = SDL_FULLSCREEN;
 #else
 	w = 640;
 	h = 480;
 	desired_bpp = 0;
 	video_flags = 0;
 #endif
 	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
 		fprintf(stderr,
 			"Couldn't initialize SDL: %s\n", SDL_GetError());
 		return(1);
 	}

 	while ( argc > 1 ) {
 		if ( strcmp(argv[1], "-speedy") == 0 ) {
 			speedy = 1;
 			argv += 1;
 			argc -= 1;
 		} else
 		if ( strcmp(argv[1], "-nofade") == 0 ) {
 			nofade = 1;
 			argv += 1;
 			argc -= 1;
 		} else
 		if ( strcmp(argv[1], "-delay") == 0 ) {
 			if ( argv[2] ) {
 				delay = atoi(argv[2]);
 				argv += 2;
 				argc -= 2;
 			} else {
 				fprintf(stderr,
 				"The -delay option requires an argument\n");
 				quit(1);
 			}
 		} else
 		if ( strcmp(argv[1], "-width") == 0 ) {
 			if ( argv[2] && ((w = atoi(argv[2])) > 0) ) {
 				argv += 2;
 				argc -= 2;
 			} else {
 				fprintf(stderr,
 				"The -width option requires an argument\n");
 				quit(1);
 			}
 		} else
 		if ( strcmp(argv[1], "-height") == 0 ) {
 			if ( argv[2] && ((h = atoi(argv[2])) > 0) ) {
 				argv += 2;
 				argc -= 2;
 			} else {
 				fprintf(stderr,
 				"The -height option requires an argument\n");
 				quit(1);
 			}
 		} else
 		if ( strcmp(argv[1], "-bpp") == 0 ) {
 			if ( argv[2] ) {
 				desired_bpp = atoi(argv[2]);
 				argv += 2;
 				argc -= 2;
 			} else {
 				fprintf(stderr,
 				"The -bpp option requires an argument\n");
 				quit(1);
 			}
 		} else
 		if ( strcmp(argv[1], "-warp") == 0 ) {
 			video_flags |= SDL_HWPALETTE;
 			argv += 1;
 			argc -= 1;
 		} else
 		if ( strcmp(argv[1], "-hw") == 0 ) {
 			video_flags |= SDL_HWSURFACE;
 			argv += 1;
 			argc -= 1;
 		} else
 		if ( strcmp(argv[1], "-flip") == 0 ) {
 			video_flags |= SDL_DOUBLEBUF;
 			argv += 1;
 			argc -= 1;
 		} else
 		if ( strcmp(argv[1], "-fullscreen") == 0 ) {
 			video_flags |= SDL_FULLSCREEN;
 			argv += 1;
 			argc -= 1;
 		} else
 			break;
 	}

 	/* Initialize the display */
 	screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);
 	if ( screen == NULL ) {
 		fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
 					w, h, desired_bpp, SDL_GetError());
 		quit(1);
 	}
 	printf("Set%s %dx%dx%d mode\n",
 			screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",
 			screen->w, screen->h, screen->format->BitsPerPixel);
 	printf("(video surface located in %s memory)\n",
 			(screen->flags&SDL_HWSURFACE) ? "video" : "system");
 	if ( screen->flags & SDL_DOUBLEBUF ) {
 		printf("Double-buffering enabled\n");
 		flip = 1;
 	}

 	/* Set the window manager title bar */
 	SDL_WM_SetCaption("SDL test window", "testwin");

 	/* Do all the drawing work */
 #ifdef BENCHMARK_SDL
 	then = SDL_GetTicks();
 	DrawPict(screen, argv[1], speedy, flip, nofade);
 	now = SDL_GetTicks();
 	printf("Time: %d milliseconds\n", now-then);
 #else
 	DrawPict(screen, argv[1], speedy, flip, nofade);
 #endif
 	SDL_Delay(delay*1000);
 	SDL_Quit();
 	return(0);
 }

	/* Bring up a window and play with it */

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

	#define BENCHMARK_SDL

	#define NOTICE(X) printf("%s", X);

	#include "SDL.h"

	/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
	static void quit(int rc)
	{
	SDL_Quit();
	exit(rc);
	}

	void DrawPict(SDL_Surface screen, char bmpfile,
	int speedy, int flip, int nofade)
	{
	SDL_Surface *picture;
	SDL_Rect dest, update;
	int i, centered;
	int ncolors;
	SDL_Color colors, cmap;

	/* Load the image into a surface */
	if ( bmpfile == NULL ) {
	bmpfile = "sample.bmp"; /* Sample image */
	}
	fprintf(stderr, "Loading picture: %s\n", bmpfile);
	picture = SDL_LoadBMP(bmpfile);
	if ( picture == NULL ) {
	fprintf(stderr, "Couldn't load %s: %s\n", bmpfile,
	SDL_GetError());
	return;
	}

	/* Set the display colors -- on a hicolor display this is a no-op */
	if ( picture->format->palette ) {
	ncolors = picture->format->palette->ncolors;
	colors = (SDL_Color )malloc(ncolorssizeof(SDL_Color));
	cmap = (SDL_Color )malloc(ncolorssizeof(SDL_Color));
	memcpy(colors, picture->format->palette->colors,
	ncolors*sizeof(SDL_Color));
	} else {
	int r, g, b;

	/* Allocate 256 color palette */
	ncolors = 256;
	colors = (SDL_Color )malloc(ncolorssizeof(SDL_Color));
	cmap = (SDL_Color )malloc(ncolorssizeof(SDL_Color));

	/* Set a 3,3,2 color cube */
	for ( r=0; r<8; ++r ) {
	for ( g=0; g<8; ++g ) {
	for ( b=0; b<4; ++b ) {
	i = ((r<<5)\|(g<<2)\|b);
	colors[i].r = r<<5;
	colors[i].g = g<<5;
	colors[i].b = b<<6;
	}
	}
	}
	}
	NOTICE("testwin: setting colors\n");
	if ( ! SDL_SetColors(screen, colors, 0, ncolors) &&
	(screen->format->palette != NULL) ) {
	fprintf(stderr,
	"Warning: Couldn't set all of the colors, but SDL will map the image\n"
	" (colormap fading will suffer - try the -warp option)\n"
	);
	}

	/* Set the screen to black (not really necessary) */
	if ( SDL_LockSurface(screen) == 0 ) {
	Uint32 black;
	Uint8 *pixels;

	black = SDL_MapRGB(screen->format, 0, 0, 0);
	pixels = (Uint8 *)screen->pixels;
	for ( i=0; i<screen->h; ++i ) {
	memset(pixels, black,
	screen->w*screen->format->BytesPerPixel);
	pixels += screen->pitch;
	}
	SDL_UnlockSurface(screen);
	SDL_UpdateRect(screen, 0, 0, 0, 0);
	}

	/* Display the picture */
	if ( speedy ) {
	SDL_Surface *displayfmt;

	fprintf(stderr, "Converting picture\n");
	displayfmt = SDL_DisplayFormat(picture);
	if ( displayfmt == NULL ) {
	fprintf(stderr,
	"Couldn't convert image: %s\n", SDL_GetError());
	goto done;
	}
	SDL_FreeSurface(picture);
	picture = displayfmt;
	}
	printf("(image surface located in %s memory)\n",
	(picture->flags&SDL_HWSURFACE) ? "video" : "system");
	centered = (screen->w - picture->w)/2;
	if ( centered < 0 ) {
	centered = 0;
	}
	dest.y = (screen->h - picture->h)/2;
	dest.w = picture->w;
	dest.h = picture->h;
	NOTICE("testwin: moving image\n");
	for ( i=0; i<=centered; ++i ) {
	dest.x = i;
	update = dest;
	if ( SDL_BlitSurface(picture, NULL, screen, &update) < 0 ) {
	fprintf(stderr, "Blit failed: %s\n", SDL_GetError());
	break;
	}
	if ( flip ) {
	SDL_Flip(screen);
	} else {
	SDL_UpdateRects(screen, 1, &update);
	}
	}

	#ifdef SCREENSHOT
	if ( SDL_SaveBMP(screen, "screen.bmp") < 0 )
	printf("Couldn't save screen: %s\n", SDL_GetError());
	#endif

	#ifndef BENCHMARK_SDL
	/* Let it sit there for a while */
	SDL_Delay(5*1000);
	#endif
	/* Fade the colormap */
	if ( ! nofade ) {
	int maxstep;
	SDL_Color final;
	SDL_Color palcolors[256];
	struct {
	Sint16 r, g, b;
	} cdist[256];

	NOTICE("testwin: fading out...\n");
	memcpy(cmap, colors, ncolors*sizeof(SDL_Color));
	maxstep = 32-1;
	final.r = 0xFF;
	final.g = 0x00;
	final.b = 0x00;
	memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
	for ( i=0; i<ncolors; ++i ) {
	cdist[i].r = final.r-palcolors[i].r;
	cdist[i].g = final.g-palcolors[i].g;
	cdist[i].b = final.b-palcolors[i].b;
	}
	for ( i=0; i<=maxstep/2; ++i ) { /* halfway fade */
	int c;
	for ( c=0; c<ncolors; ++c ) {
	colors[c].r =
	palcolors[c].r+((cdist[c].r*i))/maxstep;
	colors[c].g =
	palcolors[c].g+((cdist[c].g*i))/maxstep;
	colors[c].b =
	palcolors[c].b+((cdist[c].b*i))/maxstep;
	}
	SDL_SetColors(screen, colors, 0, ncolors);
	SDL_Delay(1);
	}
	final.r = 0x00;
	final.g = 0x00;
	final.b = 0x00;
	memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
	for ( i=0; i<ncolors; ++i ) {
	cdist[i].r = final.r-palcolors[i].r;
	cdist[i].g = final.g-palcolors[i].g;
	cdist[i].b = final.b-palcolors[i].b;
	}
	maxstep /= 2;
	for ( i=0; i<=maxstep; ++i ) { /* finish fade out */
	int c;
	for ( c=0; c<ncolors; ++c ) {
	colors[c].r =
	palcolors[c].r+((cdist[c].r*i))/maxstep;
	colors[c].g =
	palcolors[c].g+((cdist[c].g*i))/maxstep;
	colors[c].b =
	palcolors[c].b+((cdist[c].b*i))/maxstep;
	}
	SDL_SetColors(screen, colors, 0, ncolors);
	SDL_Delay(1);
	}
	for ( i=0; i<ncolors; ++i ) {
	colors[i].r = final.r;
	colors[i].g = final.g;
	colors[i].b = final.b;
	}
	SDL_SetColors(screen, colors, 0, ncolors);
	NOTICE("testwin: fading in...\n");
	memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));
	for ( i=0; i<ncolors; ++i ) {
	cdist[i].r = cmap[i].r-palcolors[i].r;
	cdist[i].g = cmap[i].g-palcolors[i].g;
	cdist[i].b = cmap[i].b-palcolors[i].b;
	}
	for ( i=0; i<=maxstep; ++i ) { /* 32 step fade in */
	int c;
	for ( c=0; c<ncolors; ++c ) {
	colors[c].r =
	palcolors[c].r+((cdist[c].r*i))/maxstep;
	colors[c].g =
	palcolors[c].g+((cdist[c].g*i))/maxstep;
	colors[c].b =
	palcolors[c].b+((cdist[c].b*i))/maxstep;
	}
	SDL_SetColors(screen, colors, 0, ncolors);
	SDL_Delay(1);
	}
	NOTICE("testwin: fading over\n");
	}

	done:
	/* Free the picture and return */
	SDL_FreeSurface(picture);
	free(colors); free(cmap);
	return;
	}

	int main(int argc, char *argv[])
	{
	SDL_Surface *screen;
	/* Options */
	int speedy, flip, nofade;
	int delay;
	int w, h;
	int desired_bpp;
	Uint32 video_flags;
	#ifdef BENCHMARK_SDL
	Uint32 then, now;
	#endif
	/* Set default options and check command-line */
	speedy = 0;
	flip = 0;
	nofade = 0;
	delay = 1;

	#ifdef _WIN32_WCE
	w = 240;
	h = 320;
	desired_bpp = 8;
	video_flags = SDL_FULLSCREEN;
	#else
	w = 640;
	h = 480;
	desired_bpp = 0;
	video_flags = 0;
	#endif
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
	fprintf(stderr,
	"Couldn't initialize SDL: %s\n", SDL_GetError());
	return(1);
	}

	while ( argc > 1 ) {
	if ( strcmp(argv[1], "-speedy") == 0 ) {
	speedy = 1;
	argv += 1;
	argc -= 1;
	} else
	if ( strcmp(argv[1], "-nofade") == 0 ) {
	nofade = 1;
	argv += 1;
	argc -= 1;
	} else
	if ( strcmp(argv[1], "-delay") == 0 ) {
	if ( argv[2] ) {
	delay = atoi(argv[2]);
	argv += 2;
	argc -= 2;
	} else {
	fprintf(stderr,
	"The -delay option requires an argument\n");
	quit(1);
	}
	} else
	if ( strcmp(argv[1], "-width") == 0 ) {
	if ( argv[2] && ((w = atoi(argv[2])) > 0) ) {
	argv += 2;
	argc -= 2;
	} else {
	fprintf(stderr,
	"The -width option requires an argument\n");
	quit(1);
	}
	} else
	if ( strcmp(argv[1], "-height") == 0 ) {
	if ( argv[2] && ((h = atoi(argv[2])) > 0) ) {
	argv += 2;
	argc -= 2;
	} else {
	fprintf(stderr,
	"The -height option requires an argument\n");
	quit(1);
	}
	} else
	if ( strcmp(argv[1], "-bpp") == 0 ) {
	if ( argv[2] ) {
	desired_bpp = atoi(argv[2]);
	argv += 2;
	argc -= 2;
	} else {
	fprintf(stderr,
	"The -bpp option requires an argument\n");
	quit(1);
	}
	} else
	if ( strcmp(argv[1], "-warp") == 0 ) {
	video_flags \|= SDL_HWPALETTE;
	argv += 1;
	argc -= 1;
	} else
	if ( strcmp(argv[1], "-hw") == 0 ) {
	video_flags \|= SDL_HWSURFACE;
	argv += 1;
	argc -= 1;
	} else
	if ( strcmp(argv[1], "-flip") == 0 ) {
	video_flags \|= SDL_DOUBLEBUF;
	argv += 1;
	argc -= 1;
	} else
	if ( strcmp(argv[1], "-fullscreen") == 0 ) {
	video_flags \|= SDL_FULLSCREEN;
	argv += 1;
	argc -= 1;
	} else
	break;
	}

	/* Initialize the display */
	screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);
	if ( screen == NULL ) {
	fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",
	w, h, desired_bpp, SDL_GetError());
	quit(1);
	}
	printf("Set%s %dx%dx%d mode\n",
	screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",
	screen->w, screen->h, screen->format->BitsPerPixel);
	printf("(video surface located in %s memory)\n",
	(screen->flags&SDL_HWSURFACE) ? "video" : "system");
	if ( screen->flags & SDL_DOUBLEBUF ) {
	printf("Double-buffering enabled\n");
	flip = 1;
	}

	/* Set the window manager title bar */
	SDL_WM_SetCaption("SDL test window", "testwin");

	/* Do all the drawing work */
	#ifdef BENCHMARK_SDL
	then = SDL_GetTicks();
	DrawPict(screen, argv[1], speedy, flip, nofade);
	now = SDL_GetTicks();
	printf("Time: %d milliseconds\n", now-then);
	#else
	DrawPict(screen, argv[1], speedy, flip, nofade);
	#endif
	SDL_Delay(delay*1000);
	SDL_Quit();
	return(0);
	}