diff options
Diffstat (limited to 'distrib/sdl-1.2.15/test/testblitspeed.c')
| -rw-r--r-- | distrib/sdl-1.2.15/test/testblitspeed.c | 420 |
1 files changed, 420 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/test/testblitspeed.c b/distrib/sdl-1.2.15/test/testblitspeed.c new file mode 100644 index 0000000..f5dff6b --- /dev/null +++ b/distrib/sdl-1.2.15/test/testblitspeed.c @@ -0,0 +1,420 @@ +/* + * 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); +} + + +#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_videoinfo_details(void) +{ + const SDL_VideoInfo *info = SDL_GetVideoInfo(); + printf("SDL_GetVideoInfo():\n"); + if (info == NULL) + printf(" (null.)\n"); + else + { + 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); + } + + printf("\n"); +} + +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(" alpha : %d\n", (int) surface->format->alpha); + printf(" colorkey : 0x%X\n", (unsigned int) surface->format->colorkey); + + printf(" red bits : 0x%08X mask, %d shift, %d loss\n", + (int) surface->format->Rmask, + (int) surface->format->Rshift, + (int) surface->format->Rloss); + printf(" green bits : 0x%08X mask, %d shift, %d loss\n", + (int) surface->format->Gmask, + (int) surface->format->Gshift, + (int) surface->format->Gloss); + printf(" blue bits : 0x%08X mask, %d shift, %d loss\n", + (int) surface->format->Bmask, + (int) surface->format->Bshift, + (int) surface->format->Bloss); + printf(" alpha bits : 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); + } + + printf("\n"); +} + +static void output_details(void) +{ + output_videoinfo_details(); + 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; + Uint32 origsrcalphaflags = 0; + Uint32 origdstalphaflags = 0; + Uint32 srcalphaflags = 0; + Uint32 dstalphaflags = 0; + int srcalpha = 255; + int dstalpha = 255; + int screenSurface = 0; + int i = 0; + + 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]; + /* !!! FIXME: set colorkey. */ + else if (0) /* !!! FIXME: we handle some commandlines elsewhere now */ + { + 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); + } + + /* handle alpha settings... */ + srcalphaflags = (src->flags&SDL_SRCALPHA) | (src->flags&SDL_RLEACCEL); + dstalphaflags = (dest->flags&SDL_SRCALPHA) | (dest->flags&SDL_RLEACCEL); + origsrcalphaflags = srcalphaflags; + origdstalphaflags = dstalphaflags; + srcalpha = src->format->alpha; + dstalpha = dest->format->alpha; + for (i = 1; i < argc; i++) + { + const char *arg = argv[i]; + + if (strcmp(arg, "--srcalpha") == 0) + srcalpha = atoi(argv[++i]); + else if (strcmp(arg, "--dstalpha") == 0) + dstalpha = atoi(argv[++i]); + else if (strcmp(arg, "--srcsrcalpha") == 0) + srcalphaflags |= SDL_SRCALPHA; + else if (strcmp(arg, "--srcnosrcalpha") == 0) + srcalphaflags &= ~SDL_SRCALPHA; + else if (strcmp(arg, "--srcrleaccel") == 0) + srcalphaflags |= SDL_RLEACCEL; + else if (strcmp(arg, "--srcnorleaccel") == 0) + srcalphaflags &= ~SDL_RLEACCEL; + else if (strcmp(arg, "--dstsrcalpha") == 0) + dstalphaflags |= SDL_SRCALPHA; + else if (strcmp(arg, "--dstnosrcalpha") == 0) + dstalphaflags &= ~SDL_SRCALPHA; + else if (strcmp(arg, "--dstrleaccel") == 0) + dstalphaflags |= SDL_RLEACCEL; + else if (strcmp(arg, "--dstnorleaccel") == 0) + dstalphaflags &= ~SDL_RLEACCEL; + } + if ((dstalphaflags != origdstalphaflags) || (dstalpha != dest->format->alpha)) + SDL_SetAlpha(dest, dstalphaflags, (Uint8) dstalpha); + if ((srcalphaflags != origsrcalphaflags) || (srcalpha != src->format->alpha)) + SDL_SetAlpha(src, srcalphaflags, (Uint8) srcalpha); + + /* 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 ... */ + |