mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-02-03 11:32:43 +01:00
2db54798d7
I am not replacing the following header files used by the Windows build, as I don't have a Windows build setup to test. Please point the Windows build at the header files inside these clean distribution packages and garbage collect the duplicates: GLew/*.h and SDL/Include_1.2. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5711 8ced0084-cf51-0410-be5f-012b33b47a6e
466 lines
13 KiB
C
466 lines
13 KiB
C
|
|
/* 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);
|
|
}
|