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 }