1 

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

     3 

     4 #include <stdlib.h>

     5 #include <stdio.h>

     6 #include <string.h>

     7 

     8 #define BENCHMARK_SDL

     9 

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

    11 

    12 #include "SDL.h"

    13 

    14 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */

    15 static void quit(int rc)

    16 {

    17 	SDL_Quit();

    18 	exit(rc);

    19 }

    20 

    21 void DrawPict(SDL_Surface *screen, char *bmpfile,

    22 					int speedy, int flip, int nofade)

    23 {

    24 	SDL_Surface *picture;

    25 	SDL_Rect dest, update;

    26 	int i, centered;

    27 	int ncolors;

    28 	SDL_Color *colors, *cmap;

    29 

    30 	/* Load the image into a surface */

    31 	if ( bmpfile == NULL ) {

    32 		bmpfile = "sample.bmp";		/* Sample image */

    33 	}

    34 fprintf(stderr, "Loading picture: %s\n", bmpfile);

    35 	picture = SDL_LoadBMP(bmpfile);

    36 	if ( picture == NULL ) {

    37 		fprintf(stderr, "Couldn't load %s: %s\n", bmpfile,

    38 							SDL_GetError());

    39 		return;

    40 	}

    41 

    42 	/* Set the display colors -- on a hicolor display this is a no-op */

    43 	if ( picture->format->palette ) {

    44 		ncolors = picture->format->palette->ncolors;

    45 		colors  = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));

    46 		cmap    = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));

    47 		memcpy(colors, picture->format->palette->colors,

    48 						ncolors*sizeof(SDL_Color));

    49 	} else {

    50 		int       r, g, b;

    51 

    52 		/* Allocate 256 color palette */

    53 		ncolors = 256;

    54 		colors  = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));

    55 		cmap    = (SDL_Color *)malloc(ncolors*sizeof(SDL_Color));

    56 

    57 		/* Set a 3,3,2 color cube */

    58 		for ( r=0; r<8; ++r ) {

    59 			for ( g=0; g<8; ++g ) {

    60 				for ( b=0; b<4; ++b ) {

    61 					i = ((r<<5)|(g<<2)|b);

    62 					colors[i].r = r<<5;

    63 					colors[i].g = g<<5;

    64 					colors[i].b = b<<6;

    65 				}

    66 			}

    67 		}

    68 	}

    69 NOTICE("testwin: setting colors\n");

    70 	if ( ! SDL_SetColors(screen, colors, 0, ncolors) &&

    71 				(screen->format->palette != NULL) ) {

    72 		fprintf(stderr,

    73 "Warning: Couldn't set all of the colors, but SDL will map the image\n"

    74 "         (colormap fading will suffer - try the -warp option)\n"

    75 		);

    76 	}

    77 

    78 	/* Set the screen to black (not really necessary) */

    79 	if ( SDL_LockSurface(screen) == 0 ) {

    80 		Uint32 black;

    81 		Uint8 *pixels;

    82 

    83 		black = SDL_MapRGB(screen->format, 0, 0, 0);

    84 		pixels = (Uint8 *)screen->pixels;

    85 		for ( i=0; i<screen->h; ++i ) {

    86 			memset(pixels, black,

    87 				screen->w*screen->format->BytesPerPixel);

    88 			pixels += screen->pitch;

    89 		}

    90 		SDL_UnlockSurface(screen);

    91 		SDL_UpdateRect(screen, 0, 0, 0, 0);

    92 	}

    93 	

    94 	/* Display the picture */

    95 	if ( speedy ) {

    96 		SDL_Surface *displayfmt;

    97 

    98 fprintf(stderr, "Converting picture\n");

    99 		displayfmt = SDL_DisplayFormat(picture);

   100 		if ( displayfmt == NULL ) {

   101 			fprintf(stderr,

   102 				"Couldn't convert image: %s\n", SDL_GetError());

   103 			goto done;

   104 		}

   105 		SDL_FreeSurface(picture);

   106 		picture = displayfmt;

   107 	}

   108 	printf("(image surface located in %s memory)\n", 

   109 			(picture->flags&SDL_HWSURFACE) ? "video" : "system");

   110 	centered = (screen->w - picture->w)/2;

   111 	if ( centered < 0 ) {

   112 		centered = 0;

   113 	}

   114 	dest.y = (screen->h - picture->h)/2;

   115 	dest.w = picture->w;

   116 	dest.h = picture->h;

   117 NOTICE("testwin: moving image\n");

   118 	for ( i=0; i<=centered; ++i ) {

   119 		dest.x = i;

   120 		update = dest;

   121 		if ( SDL_BlitSurface(picture, NULL, screen, &update) < 0 ) {

   122 			fprintf(stderr, "Blit failed: %s\n", SDL_GetError());

   123 			break;

   124 		}

   125 		if ( flip ) {

   126 			SDL_Flip(screen);

   127 		} else {

   128 			SDL_UpdateRects(screen, 1, &update);

   129 		}

   130 	}

   131 

   132 #ifdef SCREENSHOT

   133 	if ( SDL_SaveBMP(screen, "screen.bmp") < 0 )

   134 		printf("Couldn't save screen: %s\n", SDL_GetError());

   135 #endif

   136 

   137 #ifndef BENCHMARK_SDL

   138 	/* Let it sit there for a while */

   139 	SDL_Delay(5*1000);

   140 #endif

   141 	/* Fade the colormap */

   142 	if ( ! nofade ) {

   143 		int maxstep;

   144 		SDL_Color final;

   145 		SDL_Color palcolors[256];

   146 		struct {

   147 			Sint16 r, g, b;

   148 		} cdist[256];

   149 

   150 NOTICE("testwin: fading out...\n");

   151 		memcpy(cmap, colors, ncolors*sizeof(SDL_Color));

   152 		maxstep = 32-1;

   153 		final.r = 0xFF;

   154 		final.g = 0x00;

   155 		final.b = 0x00;

   156 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));

   157 		for ( i=0; i<ncolors; ++i ) {

   158 			cdist[i].r = final.r-palcolors[i].r;

   159 			cdist[i].g = final.g-palcolors[i].g;

   160 			cdist[i].b = final.b-palcolors[i].b;

   161 		}

   162 		for ( i=0; i<=maxstep/2; ++i ) {	/* halfway fade */

   163 			int c;

   164 			for ( c=0; c<ncolors; ++c ) {

   165 				colors[c].r =

   166 					palcolors[c].r+((cdist[c].r*i))/maxstep;

   167 				colors[c].g =

   168 					palcolors[c].g+((cdist[c].g*i))/maxstep;

   169 				colors[c].b =

   170 					palcolors[c].b+((cdist[c].b*i))/maxstep;

   171 			}

   172 			SDL_SetColors(screen, colors, 0, ncolors);

   173 			SDL_Delay(1);

   174 		}

   175 		final.r = 0x00;

   176 		final.g = 0x00;

   177 		final.b = 0x00;

   178 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));

   179 		for ( i=0; i<ncolors; ++i ) {

   180 			cdist[i].r = final.r-palcolors[i].r;

   181 			cdist[i].g = final.g-palcolors[i].g;

   182 			cdist[i].b = final.b-palcolors[i].b;

   183 		}

   184 		maxstep /= 2;

   185 		for ( i=0; i<=maxstep; ++i ) {		/* finish fade out */

   186 			int c;

   187 			for ( c=0; c<ncolors; ++c ) {

   188 				colors[c].r =

   189 					palcolors[c].r+((cdist[c].r*i))/maxstep;

   190 				colors[c].g =

   191 					palcolors[c].g+((cdist[c].g*i))/maxstep;

   192 				colors[c].b =

   193 					palcolors[c].b+((cdist[c].b*i))/maxstep;

   194 			}

   195 			SDL_SetColors(screen, colors, 0, ncolors);

   196 			SDL_Delay(1);

   197 		}

   198 		for ( i=0; i<ncolors; ++i ) {

   199 			colors[i].r = final.r;

   200 			colors[i].g = final.g;

   201 			colors[i].b = final.b;

   202 		}

   203 		SDL_SetColors(screen, colors, 0, ncolors);

   204 NOTICE("testwin: fading in...\n");

   205 		memcpy(palcolors, colors, ncolors*sizeof(SDL_Color));

   206 		for ( i=0; i<ncolors; ++i ) {

   207 			cdist[i].r = cmap[i].r-palcolors[i].r;

   208 			cdist[i].g = cmap[i].g-palcolors[i].g;

   209 			cdist[i].b = cmap[i].b-palcolors[i].b;

   210 		}

   211 		for ( i=0; i<=maxstep; ++i ) {	/* 32 step fade in */

   212 			int c;

   213 			for ( c=0; c<ncolors; ++c ) {

   214 				colors[c].r =

   215 					palcolors[c].r+((cdist[c].r*i))/maxstep;

   216 				colors[c].g =

   217 					palcolors[c].g+((cdist[c].g*i))/maxstep;

   218 				colors[c].b =

   219 					palcolors[c].b+((cdist[c].b*i))/maxstep;

   220 			}

   221 			SDL_SetColors(screen, colors, 0, ncolors);

   222 			SDL_Delay(1);

   223 		}

   224 NOTICE("testwin: fading over\n");

   225 	}

   226 	

   227 done:

   228 	/* Free the picture and return */

   229 	SDL_FreeSurface(picture);

   230 	free(colors); free(cmap);

   231 	return;

   232 }

   233 

   234 int main(int argc, char *argv[])

   235 {

   236 	SDL_Surface *screen;

   237 	/* Options */

   238 	int speedy, flip, nofade;

   239 	int delay;

   240 	int w, h;

   241 	int desired_bpp;

   242 	Uint32 video_flags;

   243 #ifdef BENCHMARK_SDL

   244 	Uint32 then, now;

   245 #endif

   246 	/* Set default options and check command-line */

   247 	speedy = 0;

   248 	flip = 0;

   249 	nofade = 0;

   250 	delay = 1;

   251 

   252 #ifdef _WIN32_WCE

   253 	w = 240;

   254 	h = 320;

   255 	desired_bpp = 8;

   256 	video_flags = SDL_FULLSCREEN;

   257 #else

   258 	w = 640;

   259 	h = 480;

   260 	desired_bpp = 0;

   261 	video_flags = 0;

   262 #endif

   263 	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {

   264 		fprintf(stderr,

   265 			"Couldn't initialize SDL: %s\n", SDL_GetError());

   266 		return(1);

   267 	}

   268 

   269 	while ( argc > 1 ) {

   270 		if ( strcmp(argv[1], "-speedy") == 0 ) {

   271 			speedy = 1;

   272 			argv += 1;

   273 			argc -= 1;

   274 		} else

   275 		if ( strcmp(argv[1], "-nofade") == 0 ) {

   276 			nofade = 1;

   277 			argv += 1;

   278 			argc -= 1;

   279 		} else

   280 		if ( strcmp(argv[1], "-delay") == 0 ) {

   281 			if ( argv[2] ) {

   282 				delay = atoi(argv[2]);

   283 				argv += 2;

   284 				argc -= 2;

   285 			} else {

   286 				fprintf(stderr,

   287 				"The -delay option requires an argument\n");

   288 				quit(1);

   289 			}

   290 		} else

   291 		if ( strcmp(argv[1], "-width") == 0 ) {

   292 			if ( argv[2] && ((w = atoi(argv[2])) > 0) ) {

   293 				argv += 2;

   294 				argc -= 2;

   295 			} else {

   296 				fprintf(stderr,

   297 				"The -width option requires an argument\n");

   298 				quit(1);

   299 			}

   300 		} else

   301 		if ( strcmp(argv[1], "-height") == 0 ) {

   302 			if ( argv[2] && ((h = atoi(argv[2])) > 0) ) {

   303 				argv += 2;

   304 				argc -= 2;

   305 			} else {

   306 				fprintf(stderr,

   307 				"The -height option requires an argument\n");

   308 				quit(1);

   309 			}

   310 		} else

   311 		if ( strcmp(argv[1], "-bpp") == 0 ) {

   312 			if ( argv[2] ) {

   313 				desired_bpp = atoi(argv[2]);

   314 				argv += 2;

   315 				argc -= 2;

   316 			} else {

   317 				fprintf(stderr,

   318 				"The -bpp option requires an argument\n");

   319 				quit(1);

   320 			}

   321 		} else

   322 		if ( strcmp(argv[1], "-warp") == 0 ) {

   323 			video_flags |= SDL_HWPALETTE;

   324 			argv += 1;

   325 			argc -= 1;

   326 		} else

   327 		if ( strcmp(argv[1], "-hw") == 0 ) {

   328 			video_flags |= SDL_HWSURFACE;

   329 			argv += 1;

   330 			argc -= 1;

   331 		} else

   332 		if ( strcmp(argv[1], "-flip") == 0 ) {

   333 			video_flags |= SDL_DOUBLEBUF;

   334 			argv += 1;

   335 			argc -= 1;

   336 		} else

   337 		if ( strcmp(argv[1], "-fullscreen") == 0 ) {

   338 			video_flags |= SDL_FULLSCREEN;

   339 			argv += 1;

   340 			argc -= 1;

   341 		} else

   342 			break;

   343 	}

   344 

   345 	/* Initialize the display */

   346 	screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags);

   347 	if ( screen == NULL ) {

   348 		fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n",

   349 					w, h, desired_bpp, SDL_GetError());

   350 		quit(1);

   351 	}

   352 	printf("Set%s %dx%dx%d mode\n",

   353 			screen->flags & SDL_FULLSCREEN ? " fullscreen" : "",

   354 			screen->w, screen->h, screen->format->BitsPerPixel);

   355 	printf("(video surface located in %s memory)\n",

   356 			(screen->flags&SDL_HWSURFACE) ? "video" : "system");

   357 	if ( screen->flags & SDL_DOUBLEBUF ) {

   358 		printf("Double-buffering enabled\n");

   359 		flip = 1;

   360 	}

   361 

   362 	/* Set the window manager title bar */

   363 	SDL_WM_SetCaption("SDL test window", "testwin");

   364 

   365 	/* Do all the drawing work */

   366 #ifdef BENCHMARK_SDL

   367 	then = SDL_GetTicks();

   368 	DrawPict(screen, argv[1], speedy, flip, nofade);

   369 	now = SDL_GetTicks();

   370 	printf("Time: %d milliseconds\n", now-then);

   371 #else

   372 	DrawPict(screen, argv[1], speedy, flip, nofade);

   373 #endif

   374 	SDL_Delay(delay*1000);

   375 	SDL_Quit();

   376 	return(0);

   377 }