| |
| /* 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) |
| |
| #if 0 |
| 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; |
| } |
| } |
| } |
| } |
| #endif |
| |
| int |
| main(int argc, char *argv[]) |
| { |
| const SDL_VideoInfo *info; |
| int i, d, n; |
| const char *driver; |
| SDL_DisplayMode mode; |
| int bpp; |
| Uint32 Rmask, Gmask, Bmask, Amask; |
| int nmodes; |
| |
| /* Print available video drivers */ |
| n = SDL_GetNumVideoDrivers(); |
| if (n == 0) { |
| printf("No built-in video drivers\n"); |
| } else { |
| printf("Built-in video drivers:"); |
| for (i = 0; i < n; ++i) { |
| if (i > 0) { |
| printf(","); |
| } |
| printf(" %s", SDL_GetVideoDriver(i)); |
| } |
| printf("\n"); |
| } |
| |
| if (SDL_Init(SDL_INIT_VIDEO) < 0) { |
| fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError()); |
| exit(1); |
| } |
| driver = SDL_GetCurrentVideoDriver(); |
| if (driver) { |
| printf("Video driver: %s\n", driver); |
| } |
| printf("Number of displays: %d\n", SDL_GetNumVideoDisplays()); |
| for (d = 0; d < SDL_GetNumVideoDisplays(); ++d) { |
| printf("Display %d:\n", d); |
| SDL_SelectVideoDisplay(d); |
| |
| SDL_GetDesktopDisplayMode(&mode); |
| SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, &Bmask, |
| &Amask); |
| printf(" Current mode: %dx%d@%dHz, %d bits-per-pixel\n", mode.w, |
| mode.h, mode.refresh_rate, bpp); |
| if (Rmask || Gmask || Bmask) { |
| printf(" Red Mask = 0x%.8x\n", Rmask); |
| printf(" Green Mask = 0x%.8x\n", Gmask); |
| printf(" Blue Mask = 0x%.8x\n", Bmask); |
| if (Amask) |
| printf(" Alpha Mask = 0x%.8x\n", Amask); |
| } |
| |
| /* Print available fullscreen video modes */ |
| nmodes = SDL_GetNumDisplayModes(); |
| if (nmodes == 0) { |
| printf("No available fullscreen video modes\n"); |
| } else { |
| printf(" Fullscreen video modes:\n"); |
| for (i = 0; i < nmodes; ++i) { |
| SDL_GetDisplayMode(i, &mode); |
| SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, |
| &Gmask, &Bmask, &Amask); |
| printf(" Mode %d: %dx%d@%dHz, %d bits-per-pixel\n", i, |
| mode.w, mode.h, mode.refresh_rate, bpp); |
| if (Rmask || Gmask || Bmask) { |
| printf(" Red Mask = 0x%.8x\n", Rmask); |
| printf(" Green Mask = 0x%.8x\n", Gmask); |
| printf(" Blue Mask = 0x%.8x\n", Bmask); |
| if (Amask) |
| printf(" Alpha Mask = 0x%.8x\n", Amask); |
| } |
| } |
| } |
| } |
| |
| info = SDL_GetVideoInfo(); |
| 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 0 |
| if (argv[1] && (strcmp(argv[1], "-benchmark") == 0)) { |
| RunVideoTests(); |
| } |
| #endif |
| |
| SDL_Quit(); |
| return (0); |
| } |