test/testwin.c
author Ryan C. Gordon <icculus@icculus.org>
Mon, 18 Feb 2019 00:26:53 -0500
changeset 69 a2c5f6a01a55
parent 0 a6cb692b8939
permissions -rw-r--r--
Fill in a default palette for 8-bit screen surfaces.
     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 }