aboutsummaryrefslogtreecommitdiffstats
path: root/distrib/sdl-1.2.15/test/testvidinfo.c
diff options
context:
space:
mode:
Diffstat (limited to 'distrib/sdl-1.2.15/test/testvidinfo.c')
-rw-r--r--distrib/sdl-1.2.15/test/testvidinfo.c465
1 files changed, 465 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/test/testvidinfo.c b/distrib/sdl-1.2.15/test/testvidinfo.c
new file mode 100644
index 0000000..bbafeb8
--- /dev/null
+++ b/distrib/sdl-1.2.15/test/testvidinfo.c
@@ -0,0 +1,465 @@
+
+/* 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);
+}
generated by cgit v1.1 at 2024-12-22 11:55:00 +0000