--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/libsdl-trunk/test/testblitspeed.c Fri Jul 31 15:01:17 2009 +0100
@@ -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 ... */
+