distrib/sdl-1.2.15/test/testblitspeed.c - platform/external/qemu - Git at Google

 /*
  * 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 ... */
	/*
	* 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 ... */