Home | History | Annotate | Download | only in test 
      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 }
    466