view test/testvidinfo.c @ 1790:828a17e05192

Date: Mon, 8 May 2006 14:19:30 -0700 From: Bob Ippolito Subject: SDL trunk (r2346) and Mac OS X The current state of the trunk doesn't quite compile on Mac OS X, I've attached a series of patches that gets it to compile and kills a few warnings. sdl-trunk-r2346-dlcompat-warnings.diff: The dlcompat thing is just loaded with incorrect type signatures .. some of them have changed since 10.2 and others are just flat wrong. This puts it in sync with the latest headers. People on 10.2 will get the warnings instead of people with new kits.
author Sam Lantinga <slouken@libsdl.org>
date Tue, 09 May 2006 07:26:58 +0000
parents 8d9bb0cf2c2a
children 8b9d79e7eacf c121d94672cb
line wrap: on
line source


/* Simple program -- figure out what kind of video display we have */

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

#include "SDL.h"

#define NUM_BLITS	10
#define NUM_UPDATES	500

#define FLAG_MASK	(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \
                         SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL  | \
                         SDL_RLEACCELOK)

void PrintFlags(Uint32 flags)
{
	printf("0x%8.8x", (flags & FLAG_MASK));
	if ( flags & SDL_HWSURFACE ) {
		printf(" SDL_HWSURFACE");
	} else {
		printf(" SDL_SWSURFACE");
	}
	if ( flags & SDL_FULLSCREEN ) {
		printf(" | SDL_FULLSCREEN");
	}
	if ( flags & SDL_DOUBLEBUF ) {
		printf(" | SDL_DOUBLEBUF");
	}
	if ( flags & SDL_SRCCOLORKEY ) {
		printf(" | SDL_SRCCOLORKEY");
	}
	if ( flags & SDL_SRCALPHA ) {
		printf(" | SDL_SRCALPHA");
	}
	if ( flags & SDL_RLEACCEL ) {
		printf(" | SDL_RLEACCEL");
	}
	if ( flags & SDL_RLEACCELOK ) {
		printf(" | SDL_RLEACCELOK");
	}
}

int RunBlitTests(SDL_Surface *screen, SDL_Surface *bmp, int blitcount)
{
	int i, j;
	int maxx;
	int maxy;
	SDL_Rect dst;

	maxx = (int)screen->w - bmp->w + 1;
	maxy = (int)screen->h - bmp->h + 1;
	for ( i = 0; i < NUM_UPDATES; ++i ) {
		for ( j = 0; j < blitcount; ++j ) {
			if ( maxx ) {
				dst.x = rand() % maxx;
			} else {
				dst.x = 0;
			}
			if ( maxy ) {
				dst.y = rand() % maxy;
			} else {
				dst.y = 0;
			}
			dst.w = bmp->w;
			dst.h = bmp->h;
			SDL_BlitSurface(bmp, NULL, screen, &dst);
		}
		SDL_Flip(screen);
	}

	return i;
}

int RunModeTests(SDL_Surface *screen)
{
	Uint32 then, now;
	Uint32 frames;
	float seconds;
	int i;
	Uint8 r, g, b;
	SDL_Surface *bmp, *bmpcc, *tmp;
	SDL_Event event;

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

	/* First test fills and screen update speed */
	printf("Running color fill and fullscreen update test\n");
	then = SDL_GetTicks();
	frames = 0;
	for ( i = 0; i < 256; ++i ) {
		r = i;
		g = 0;
		b = 0;
		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
		SDL_Flip(screen);
		++frames;
	}
	for ( i = 0; i < 256; ++i ) {
		r = 0;
		g = i;
		b = 0;
		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
		SDL_Flip(screen);
		++frames;
	}
	for ( i = 0; i < 256; ++i ) {
		r = 0;
		g = 0;
		b = i;
		SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
		SDL_Flip(screen);
		++frames;
	}
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
		printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds);
	} else {
		printf("%d fills and flips in zero seconds!n", frames);
	}

        /* clear the screen after fill test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the generic blit test */
	bmp = SDL_LoadBMP("sample.bmp");
	if ( ! bmp ) {
		printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
		return 0;
	}
	printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",
		bmp->w, bmp->h, bmp->format->BitsPerPixel);
	PrintFlags(bmp->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmp, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
		printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
		printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

        /* clear the screen after blit test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the colorkeyed blit test */
	bmpcc = SDL_LoadBMP("sample.bmp");
	if ( ! bmpcc ) {
		printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
		return 0;
	}
	printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",
		bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
        SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);

	PrintFlags(bmpcc->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
		printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
		printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

        /* clear the screen after cc blit test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the generic blit test */
	tmp = bmp;
	bmp = SDL_DisplayFormat(bmp);
	SDL_FreeSurface(tmp);
	if ( ! bmp ) {
		printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
		return 0;
	}
	printf("Running display format blit test: %dx%d at %d bpp, flags: ",
		bmp->w, bmp->h, bmp->format->BitsPerPixel);
	PrintFlags(bmp->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmp, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
		printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
		printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

        /* clear the screen after blit test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the colorkeyed blit test */
	tmp = bmpcc;
	bmpcc = SDL_DisplayFormat(bmpcc);
	SDL_FreeSurface(tmp);
	if ( ! bmpcc ) {
		printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
		return 0;
	}
	printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",
		bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
	PrintFlags(bmpcc->flags);
	printf("\n");
	then = SDL_GetTicks();
	frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
	now = SDL_GetTicks();
	seconds = (float)(now - then) / 1000.0f;
	if ( seconds > 0.0f ) {
		printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
	} else {
		printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
	}

        /* clear the screen after cc blit test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the alpha blit test only if screen bpp>8 */
        if (bmp->format->BitsPerPixel>8)
        {
		SDL_FreeSurface(bmp);
                bmp = SDL_LoadBMP("sample.bmp");
		SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
		tmp = bmp;
		bmp = SDL_DisplayFormat(bmp);
		SDL_FreeSurface(tmp);
		if ( ! bmp ) {
			printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
			return 0;
		}
		printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
			bmp->w, bmp->h, bmp->format->BitsPerPixel);
		PrintFlags(bmp->flags);
		printf("\n");
		then = SDL_GetTicks();
		frames = RunBlitTests(screen, bmp, NUM_BLITS);
		now = SDL_GetTicks();
		seconds = (float)(now - then) / 1000.0f;
		if ( seconds > 0.0f ) {
			printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
		} else {
			printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
		}
	}

        /* clear the screen after alpha blit test */
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
	SDL_Flip(screen);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}

        /* run the cc+alpha blit test only if screen bpp>8 */
        if (bmp->format->BitsPerPixel>8)
        {
		SDL_FreeSurface(bmpcc);
                bmpcc = SDL_LoadBMP("sample.bmp");
		SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
                SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);
		tmp = bmpcc;
		bmpcc = SDL_DisplayFormat(bmpcc);
		SDL_FreeSurface(tmp);
		if ( ! bmpcc ) {
			printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
			return 0;
		}
		printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
			bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
		PrintFlags(bmpcc->flags);
		printf("\n");
		then = SDL_GetTicks();
		frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
		now = SDL_GetTicks();
		seconds = (float)(now - then) / 1000.0f;
		if ( seconds > 0.0f ) {
			printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
		} else {
			printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
		}
	}

	SDL_FreeSurface(bmpcc);
	SDL_FreeSurface(bmp);

	while ( SDL_PollEvent(&event) ) {
		if ( event.type == SDL_KEYDOWN )
			return 0;
	}
	return 1;
}

void RunVideoTests()
{
	static const struct {
		int w, h, bpp;
	} mode_list[] = {
		{ 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 },
		{ 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 },
		{ 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 }
	};
	static const Uint32 flags[] = {
		(SDL_SWSURFACE),
		(SDL_SWSURFACE | SDL_FULLSCREEN),
		(SDL_HWSURFACE | SDL_FULLSCREEN),
		(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF)
	};
	int i, j;
	SDL_Surface *screen;

	/* Test out several different video mode combinations */
	SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
	SDL_ShowCursor(0);
	for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) {
		for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) {
			printf("===================================\n");
			printf("Setting video mode: %dx%d at %d bpp, flags: ",
			                          mode_list[i].w,
			                          mode_list[i].h,
			                          mode_list[i].bpp);
			PrintFlags(flags[j]);
			printf("\n");
			screen = SDL_SetVideoMode(mode_list[i].w,
			                          mode_list[i].h,
			                          mode_list[i].bpp,
			                          flags[j]);
			if ( ! screen ) {
				printf("Setting video mode failed: %s\n", SDL_GetError());
				continue;
			}
			if ( (screen->flags & FLAG_MASK) != flags[j] ) {
				printf("Flags didn't match: ");
				PrintFlags(screen->flags);
				printf("\n");
				continue;
			}
			if ( ! RunModeTests(screen) ) {
				return;
			}
		}
	}
}

int main(int argc, char *argv[])
{
	const SDL_VideoInfo *info;
	int i;
	SDL_Rect **modes;
	char driver[128];

	if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
		fprintf(stderr,
			"Couldn't initialize SDL: %s\n", SDL_GetError());
		exit(1);
	}
	if ( SDL_VideoDriverName(driver, sizeof(driver)) ) {
		printf("Video driver: %s\n", driver);
	}
	info = SDL_GetVideoInfo();
	printf(
"Current display: %dx%d, %d bits-per-pixel\n",
		info->current_w, info->current_h, info->vfmt->BitsPerPixel);
	if ( info->vfmt->palette == NULL ) {
		printf("	Red Mask = 0x%.8x\n", info->vfmt->Rmask);
		printf("	Green Mask = 0x%.8x\n", info->vfmt->Gmask);
		printf("	Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
	}
	/* Print available fullscreen video modes */
	modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
	if ( modes == (SDL_Rect **)0 ) {
		printf("No available fullscreen video modes\n");
	} else
	if ( modes == (SDL_Rect **)-1 ) {
		printf("No special fullscreen video modes\n");
	} else {
		printf("Fullscreen video modes:\n");
		for ( i=0; modes[i]; ++i ) {
			printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel);
		}
	}
	if ( info->wm_available ) {
		printf("A window manager is available\n");
	}
	if ( info->hw_available ) {
		printf("Hardware surfaces are available (%dK video memory)\n",
			info->video_mem);
	}
	if ( info->blit_hw ) {
		printf(
"Copy blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_hw_CC ) {
		printf(
"Colorkey blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_hw_A ) {
		printf(
"Alpha blits between hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw ) {
		printf(
"Copy blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw_CC ) {
		printf(
"Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_sw_A ) {
		printf(
"Alpha blits from software surfaces to hardware surfaces are accelerated\n");
	}
	if ( info->blit_fill ) {
		printf(
"Color fills on hardware surfaces are accelerated\n");
	}

	if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) {
		RunVideoTests();
	}

	SDL_Quit();
	return(0);
}