Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Added testblitspeed to aid in profiling of SDL's blitters.
- Loading branch information
Showing
3 changed files
with
371 additions
and
1 deletion.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,367 @@ | ||
/* | ||
* Benchmarks surface-to-surface blits in various formats. | ||
* | ||
* Written by Ryan C. Gordon. | ||
*/ | ||
|
||
#include <stdio.h> | ||
#include <stdlib.h> | ||
#include <string.h> | ||
|
||
#include "SDL.h" | ||
|
||
static SDL_Surface *dest = NULL; | ||
static SDL_Surface *src = NULL; | ||
static int testSeconds = 10; | ||
|
||
|
||
static int percent(int val, int total) | ||
{ | ||
return((int) ((((float) val) / ((float) total)) * 100.0f)); | ||
} | ||
|
||
static int randRange(int lo, int hi) | ||
{ | ||
return(lo + (int) (((double) hi)*rand()/(RAND_MAX+1.0))); | ||
} | ||
|
||
static void copy_trunc_str(char *str, size_t strsize, const char *flagstr) | ||
{ | ||
if ( (strlen(str) + strlen(flagstr)) >= (strsize - 1) ) | ||
strcpy(str + (strsize - 5), " ..."); | ||
else | ||
strcat(str, flagstr); | ||
} | ||
|
||
static void __append_sdl_surface_flag(SDL_Surface *_surface, char *str, | ||
size_t strsize, Uint32 flag, | ||
const char *flagstr) | ||
{ | ||
if (_surface->flags & flag) | ||
copy_trunc_str(str, strsize, flagstr); | ||
} /* append_sdl_surface_flag */ | ||
|
||
|
||
#define append_sdl_surface_flag(a, b, c, fl) __append_sdl_surface_flag(a, b, c, fl, " " #fl) | ||
#define print_tf_state(str, val) printf("%s: {%s}\n", str, (val) ? "true" : "false" ) | ||
|
||
static void output_surface_details(const char *name, SDL_Surface *surface) | ||
{ | ||
printf("Details for %s:\n", name); | ||
|
||
if (surface == NULL) | ||
{ | ||
printf("-WARNING- You've got a NULL surface!"); | ||
} | ||
else | ||
{ | ||
char f[256]; | ||
printf(" width : %d\n", surface->w); | ||
printf(" height : %d\n", surface->h); | ||
printf(" depth : %d bits per pixel\n", surface->format->BitsPerPixel); | ||
printf(" pitch : %d\n", (int) surface->pitch); | ||
|
||
printf(" red : 0x%08X mask, %d shift, %d loss\n", | ||
(int) surface->format->Rmask, | ||
(int) surface->format->Rshift, | ||
(int) surface->format->Rloss); | ||
printf(" green : 0x%08X mask, %d shift, %d loss\n", | ||
(int) surface->format->Gmask, | ||
(int) surface->format->Gshift, | ||
(int) surface->format->Gloss); | ||
printf(" blue : 0x%08X mask, %d shift, %d loss\n", | ||
(int) surface->format->Bmask, | ||
(int) surface->format->Bshift, | ||
(int) surface->format->Bloss); | ||
printf(" alpha : 0x%08X mask, %d shift, %d loss\n", | ||
(int) surface->format->Amask, | ||
(int) surface->format->Ashift, | ||
(int) surface->format->Aloss); | ||
|
||
f[0] = '\0'; | ||
|
||
/*append_sdl_surface_flag(surface, f, sizeof (f), SDL_SWSURFACE);*/ | ||
if ((surface->flags & SDL_HWSURFACE) == 0) | ||
copy_trunc_str(f, sizeof (f), " SDL_SWSURFACE"); | ||
|
||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_HWSURFACE); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_ASYNCBLIT); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_ANYFORMAT); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_HWPALETTE); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_DOUBLEBUF); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_FULLSCREEN); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_OPENGL); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_OPENGLBLIT); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_RESIZABLE); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_NOFRAME); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_HWACCEL); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_SRCCOLORKEY); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_RLEACCELOK); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_RLEACCEL); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_SRCALPHA); | ||
append_sdl_surface_flag(surface, f, sizeof (f), SDL_PREALLOC); | ||
|
||
if (f[0] == '\0') | ||
strcpy(f, " (none)"); | ||
|
||
printf(" flags :%s\n", f); | ||
|
||
#if 0 | ||
info = SDL_GetVideoInfo(); | ||
assert(info != NULL); | ||
|
||
print_tf_state("hardware surface available", info->hw_available); | ||
print_tf_state("window manager available", info->wm_available); | ||
print_tf_state("accelerated hardware->hardware blits", info->blit_hw); | ||
print_tf_state("accelerated hardware->hardware colorkey blits", info->blit_hw_CC); | ||
print_tf_state("accelerated hardware->hardware alpha blits", info->blit_hw_A); | ||
print_tf_state("accelerated software->hardware blits", info->blit_sw); | ||
print_tf_state("accelerated software->hardware colorkey blits", info->blit_sw_CC); | ||
print_tf_state("accelerated software->hardware alpha blits", info->blit_sw_A); | ||
print_tf_state("accelerated color fills", info->blit_fill); | ||
|
||
printf("video memory: (%d)\n", info->video_mem); | ||
#endif | ||
} /* else */ | ||
|
||
printf("\n"); | ||
} | ||
|
||
static void output_details(void) | ||
{ | ||
output_surface_details("Source Surface", src); | ||
output_surface_details("Destination Surface", dest); | ||
} | ||
|
||
static Uint32 blit(SDL_Surface *dst, SDL_Surface *src, int x, int y) | ||
{ | ||
Uint32 start = 0; | ||
SDL_Rect srcRect; | ||
SDL_Rect dstRect; | ||
|
||
srcRect.x = 0; | ||
srcRect.y = 0; | ||
dstRect.x = x; | ||
dstRect.y = y; | ||
dstRect.w = srcRect.w = src->w; /* SDL will clip as appropriate. */ | ||
dstRect.h = srcRect.h = src->h; | ||
|
||
start = SDL_GetTicks(); | ||
SDL_BlitSurface(src, &srcRect, dst, &dstRect); | ||
return(SDL_GetTicks() - start); | ||
} | ||
|
||
static void blitCentered(SDL_Surface *dst, SDL_Surface *src) | ||
{ | ||
int x = (dst->w - src->w) / 2; | ||
int y = (dst->h - src->h) / 2; | ||
blit(dst, src, x, y); | ||
} | ||
|
||
static int atoi_hex(const char *str) | ||
{ | ||
if (str == NULL) | ||
return 0; | ||
|
||
if (strlen(str) > 2) | ||
{ | ||
int retval = 0; | ||
if ((str[0] == '0') && (str[1] == 'x')) | ||
sscanf(str + 2, "%X", &retval); | ||
return(retval); | ||
} | ||
|
||
return(atoi(str)); | ||
} | ||
|
||
|
||
static int setup_test(int argc, char **argv) | ||
{ | ||
const char *dumpfile = NULL; | ||
SDL_Surface *bmp = NULL; | ||
Uint32 dstbpp = 32; | ||
Uint32 dstrmask = 0x00FF0000; | ||
Uint32 dstgmask = 0x0000FF00; | ||
Uint32 dstbmask = 0x000000FF; | ||
Uint32 dstamask = 0x00000000; | ||
Uint32 dstflags = 0; | ||
int dstw = 640; | ||
int dsth = 480; | ||
Uint32 srcbpp = 32; | ||
Uint32 srcrmask = 0x00FF0000; | ||
Uint32 srcgmask = 0x0000FF00; | ||
Uint32 srcbmask = 0x000000FF; | ||
Uint32 srcamask = 0x00000000; | ||
Uint32 srcflags = 0; | ||
int srcw = 640; | ||
int srch = 480; | ||
int screenSurface = 0; | ||
int i; | ||
|
||
for (i = 1; i < argc; i++) | ||
{ | ||
const char *arg = argv[i]; | ||
|
||
if (strcmp(arg, "--dstbpp") == 0) | ||
dstbpp = atoi(argv[++i]); | ||
else if (strcmp(arg, "--dstrmask") == 0) | ||
dstrmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--dstgmask") == 0) | ||
dstgmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--dstbmask") == 0) | ||
dstbmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--dstamask") == 0) | ||
dstamask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--dstwidth") == 0) | ||
dstw = atoi(argv[++i]); | ||
else if (strcmp(arg, "--dstheight") == 0) | ||
dsth = atoi(argv[++i]); | ||
else if (strcmp(arg, "--dsthwsurface") == 0) | ||
dstflags |= SDL_HWSURFACE; | ||
else if (strcmp(arg, "--srcbpp") == 0) | ||
srcbpp = atoi(argv[++i]); | ||
else if (strcmp(arg, "--srcrmask") == 0) | ||
srcrmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--srcgmask") == 0) | ||
srcgmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--srcbmask") == 0) | ||
srcbmask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--srcamask") == 0) | ||
srcamask = atoi_hex(argv[++i]); | ||
else if (strcmp(arg, "--srcwidth") == 0) | ||
srcw = atoi(argv[++i]); | ||
else if (strcmp(arg, "--srcheight") == 0) | ||
srch = atoi(argv[++i]); | ||
else if (strcmp(arg, "--srchwsurface") == 0) | ||
srcflags |= SDL_HWSURFACE; | ||
else if (strcmp(arg, "--seconds") == 0) | ||
testSeconds = atoi(argv[++i]); | ||
else if (strcmp(arg, "--screen") == 0) | ||
screenSurface = 1; | ||
else if (strcmp(arg, "--dumpfile") == 0) | ||
dumpfile = argv[++i]; | ||
else | ||
{ | ||
fprintf(stderr, "Unknown commandline option: %s\n", arg); | ||
return(0); | ||
} | ||
} | ||
|
||
if (SDL_Init(SDL_INIT_VIDEO) == -1) | ||
{ | ||
fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError()); | ||
return(0); | ||
} | ||
|
||
bmp = SDL_LoadBMP("sample.bmp"); | ||
if (bmp == NULL) | ||
{ | ||
fprintf(stderr, "SDL_LoadBMP failed: %s\n", SDL_GetError()); | ||
SDL_Quit(); | ||
return(0); | ||
} | ||
|
||
if ((dstflags & SDL_HWSURFACE) == 0) dstflags |= SDL_SWSURFACE; | ||
if ((srcflags & SDL_HWSURFACE) == 0) srcflags |= SDL_SWSURFACE; | ||
|
||
if (screenSurface) | ||
dest = SDL_SetVideoMode(dstw, dsth, dstbpp, dstflags); | ||
else | ||
{ | ||
dest = SDL_CreateRGBSurface(dstflags, dstw, dsth, dstbpp, | ||
dstrmask, dstgmask, dstbmask, dstamask); | ||
} | ||
|
||
if (dest == NULL) | ||
{ | ||
fprintf(stderr, "dest surface creation failed: %s\n", SDL_GetError()); | ||
SDL_Quit(); | ||
return(0); | ||
} | ||
|
||
src = SDL_CreateRGBSurface(srcflags, srcw, srch, srcbpp, | ||
srcrmask, srcgmask, srcbmask, srcamask); | ||
if (src == NULL) | ||
{ | ||
fprintf(stderr, "src surface creation failed: %s\n", SDL_GetError()); | ||
SDL_Quit(); | ||
return(0); | ||
} | ||
|
||
/* set some sane defaults so we can see if the blit code is broken... */ | ||
SDL_FillRect(dest, NULL, SDL_MapRGB(dest->format, 0, 0, 0)); | ||
SDL_FillRect(src, NULL, SDL_MapRGB(src->format, 0, 0, 0)); | ||
|
||
blitCentered(src, bmp); | ||
SDL_FreeSurface(bmp); | ||
|
||
if (dumpfile) | ||
SDL_SaveBMP(src, dumpfile); /* make sure initial convert is sane. */ | ||
|
||
output_details(); | ||
|
||
return(1); | ||
} | ||
|
||
|
||
static void test_blit_speed(void) | ||
{ | ||
Uint32 clearColor = SDL_MapRGB(dest->format, 0, 0, 0); | ||
Uint32 iterations = 0; | ||
Uint32 elasped = 0; | ||
Uint32 end = 0; | ||
Uint32 now = 0; | ||
Uint32 last = 0; | ||
int testms = testSeconds * 1000; | ||
int wmax = (dest->w - src->w); | ||
int hmax = (dest->h - src->h); | ||
int isScreen = (SDL_GetVideoSurface() == dest); | ||
SDL_Event event; | ||
|
||
printf("Testing blit speed for %d seconds...\n", testSeconds); | ||
|
||
now = SDL_GetTicks(); | ||
end = now + testms; | ||
|
||
do | ||
{ | ||
/* pump the event queue occasionally to keep OS happy... */ | ||
if (now - last > 1000) | ||
{ | ||
last = now; | ||
while (SDL_PollEvent(&event)) { /* no-op. */ } | ||
} | ||
|
||
iterations++; | ||
elasped += blit(dest, src, randRange(0, wmax), randRange(0, hmax)); | ||
if (isScreen) | ||
{ | ||
SDL_Flip(dest); /* show it! */ | ||
SDL_FillRect(dest, NULL, clearColor); /* blank it for next time! */ | ||
} | ||
|
||
now = SDL_GetTicks(); | ||
} while (now < end); | ||
|
||
printf("Non-blitting crap accounted for %d percent of this run.\n", | ||
percent(testms - elasped, testms)); | ||
|
||
printf("%d blits took %d ms (%d fps).\n", | ||
(int) iterations, | ||
(int) elasped, | ||
(int) (((float)iterations) / (((float)elasped) / 1000.0f))); | ||
} | ||
|
||
int main(int argc, char **argv) | ||
{ | ||
int initialized = setup_test(argc, argv); | ||
if (initialized) | ||
{ | ||
test_blit_speed(); | ||
SDL_Quit(); | ||
} | ||
return(!initialized); | ||
} | ||
|
||
/* end of testblitspeed.c ... */ | ||
|