test/testvidinfo.c

   1
   2 /* Simple program -- figure out what kind of video display we have */
   3
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include "SDL.h"
  10
  11 #define NUM_BLITS       10
  12 #define NUM_UPDATES     500
  13
  14 #define FLAG_MASK       (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \
  15                          SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL  | \
  16                          SDL_RLEACCELOK)
  17
  18 void PrintFlags(Uint32 flags)
  19 {
  20         printf("0x%8.8x", (flags & FLAG_MASK));
  21         if ( flags & SDL_HWSURFACE ) {
  22                 printf(" SDL_HWSURFACE");
  23         } else {
  24                 printf(" SDL_SWSURFACE");
  25         }
  26         if ( flags & SDL_FULLSCREEN ) {
  27                 printf(" | SDL_FULLSCREEN");
  28         }
  29         if ( flags & SDL_DOUBLEBUF ) {
  30                 printf(" | SDL_DOUBLEBUF");
  31         }
  32         if ( flags & SDL_SRCCOLORKEY ) {
  33                 printf(" | SDL_SRCCOLORKEY");
  34         }
  35         if ( flags & SDL_SRCALPHA ) {
  36                 printf(" | SDL_SRCALPHA");
  37         }
  38         if ( flags & SDL_RLEACCEL ) {
  39                 printf(" | SDL_RLEACCEL");
  40         }
  41         if ( flags & SDL_RLEACCELOK ) {
  42                 printf(" | SDL_RLEACCELOK");
  43         }
  44 }
  45
  46 int RunBlitTests(SDL_Surface *screen, SDL_Surface *bmp, int blitcount)
  47 {
  48         int i, j;
  49         int maxx;
  50         int maxy;
  51         SDL_Rect dst;
  52
  53         maxx = (int)screen->w - bmp->w + 1;
  54         maxy = (int)screen->h - bmp->h + 1;
  55         for ( i = 0; i < NUM_UPDATES; ++i ) {
  56                 for ( j = 0; j < blitcount; ++j ) {
  57                         if ( maxx ) {
  58                                 dst.x = rand() % maxx;
  59                         } else {
  60                                 dst.x = 0;
  61                         }
  62                         if ( maxy ) {
  63                                 dst.y = rand() % maxy;
  64                         } else {
  65                                 dst.y = 0;
  66                         }
  67                         dst.w = bmp->w;
  68                         dst.h = bmp->h;
  69                         SDL_BlitSurface(bmp, NULL, screen, &dst);
  70                 }
  71                 SDL_Flip(screen);
  72         }
  73
  74         return i;
  75 }
  76
  77 int RunModeTests(SDL_Surface *screen)
  78 {
  79         Uint32 then, now;
  80         Uint32 frames;
  81         float seconds;
  82         int i;
  83         Uint8 r, g, b;
  84         SDL_Surface *bmp, *bmpcc, *tmp;
  85         SDL_Event event;
  86
  87         while ( SDL_PollEvent(&event) ) {
  88                 if ( event.type == SDL_KEYDOWN )
  89                         return 0;
  90         }
  91
  92         /* First test fills and screen update speed */
  93         printf("Running color fill and fullscreen update test\n");
  94         then = SDL_GetTicks();
  95         frames = 0;
  96         for ( i = 0; i < 256; ++i ) {
  97                 r = i;
  98                 g = 0;
  99                 b = 0;
 100                 SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 101                 SDL_Flip(screen);
 102                 ++frames;
 103         }
 104         for ( i = 0; i < 256; ++i ) {
 105                 r = 0;
 106                 g = i;
 107                 b = 0;
 108                 SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 109                 SDL_Flip(screen);
 110                 ++frames;
 111         }
 112         for ( i = 0; i < 256; ++i ) {
 113                 r = 0;
 114                 g = 0;
 115                 b = i;
 116                 SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
 117                 SDL_Flip(screen);
 118                 ++frames;
 119         }
 120         now = SDL_GetTicks();
 121         seconds = (float)(now - then) / 1000.0f;
 122         if ( seconds > 0.0f ) {
 123                 printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames, seconds, (float)frames / seconds);
 124         } else {
 125                 printf("%d fills and flips in zero seconds!n", frames);
 126         }
 127
 128         /* clear the screen after fill test */
 129         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 130         SDL_Flip(screen);
 131
 132         while ( SDL_PollEvent(&event) ) {
 133                 if ( event.type == SDL_KEYDOWN )
 134                         return 0;
 135         }
 136
 137         /* run the generic blit test */
 138         bmp = SDL_LoadBMP("sample.bmp");
 139         if ( ! bmp ) {
 140                 printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
 141                 return 0;
 142         }
 143         printf("Running freshly loaded blit test: %dx%d at %d bpp, flags: ",
 144                 bmp->w, bmp->h, bmp->format->BitsPerPixel);
 145         PrintFlags(bmp->flags);
 146         printf("\n");
 147         then = SDL_GetTicks();
 148         frames = RunBlitTests(screen, bmp, NUM_BLITS);
 149         now = SDL_GetTicks();
 150         seconds = (float)(now - then) / 1000.0f;
 151         if ( seconds > 0.0f ) {
 152                 printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 153         } else {
 154                 printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 155         }
 156
 157         /* clear the screen after blit test */
 158         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 159         SDL_Flip(screen);
 160
 161         while ( SDL_PollEvent(&event) ) {
 162                 if ( event.type == SDL_KEYDOWN )
 163                         return 0;
 164         }
 165
 166         /* run the colorkeyed blit test */
 167         bmpcc = SDL_LoadBMP("sample.bmp");
 168         if ( ! bmpcc ) {
 169                 printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
 170                 return 0;
 171         }
 172         printf("Running freshly loaded cc blit test: %dx%d at %d bpp, flags: ",
 173                 bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
 174         SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);
 175
 176         PrintFlags(bmpcc->flags);
 177         printf("\n");
 178         then = SDL_GetTicks();
 179         frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 180         now = SDL_GetTicks();
 181         seconds = (float)(now - then) / 1000.0f;
 182         if ( seconds > 0.0f ) {
 183                 printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 184         } else {
 185                 printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 186         }
 187
 188         /* clear the screen after cc blit test */
 189         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 190         SDL_Flip(screen);
 191
 192         while ( SDL_PollEvent(&event) ) {
 193                 if ( event.type == SDL_KEYDOWN )
 194                         return 0;
 195         }
 196
 197         /* run the generic blit test */
 198         tmp = bmp;
 199         bmp = SDL_DisplayFormat(bmp);
 200         SDL_FreeSurface(tmp);
 201         if ( ! bmp ) {
 202                 printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 203                 return 0;
 204         }
 205         printf("Running display format blit test: %dx%d at %d bpp, flags: ",
 206                 bmp->w, bmp->h, bmp->format->BitsPerPixel);
 207         PrintFlags(bmp->flags);
 208         printf("\n");
 209         then = SDL_GetTicks();
 210         frames = RunBlitTests(screen, bmp, NUM_BLITS);
 211         now = SDL_GetTicks();
 212         seconds = (float)(now - then) / 1000.0f;
 213         if ( seconds > 0.0f ) {
 214                 printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 215         } else {
 216                 printf("%d blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 217         }
 218
 219         /* clear the screen after blit test */
 220         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 221         SDL_Flip(screen);
 222
 223         while ( SDL_PollEvent(&event) ) {
 224                 if ( event.type == SDL_KEYDOWN )
 225                         return 0;
 226         }
 227
 228         /* run the colorkeyed blit test */
 229         tmp = bmpcc;
 230         bmpcc = SDL_DisplayFormat(bmpcc);
 231         SDL_FreeSurface(tmp);
 232         if ( ! bmpcc ) {
 233                 printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 234                 return 0;
 235         }
 236         printf("Running display format cc blit test: %dx%d at %d bpp, flags: ",
 237                 bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
 238         PrintFlags(bmpcc->flags);
 239         printf("\n");
 240         then = SDL_GetTicks();
 241         frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 242         now = SDL_GetTicks();
 243         seconds = (float)(now - then) / 1000.0f;
 244         if ( seconds > 0.0f ) {
 245                 printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 246         } else {
 247                 printf("%d cc blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 248         }
 249
 250         /* clear the screen after cc blit test */
 251         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 252         SDL_Flip(screen);
 253
 254         while ( SDL_PollEvent(&event) ) {
 255                 if ( event.type == SDL_KEYDOWN )
 256                         return 0;
 257         }
 258
 259         /* run the alpha blit test only if screen bpp>8 */
 260         if (bmp->format->BitsPerPixel>8)
 261         {
 262                 SDL_FreeSurface(bmp);
 263                 bmp = SDL_LoadBMP("sample.bmp");
 264                 SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
 265                 tmp = bmp;
 266                 bmp = SDL_DisplayFormat(bmp);
 267                 SDL_FreeSurface(tmp);
 268                 if ( ! bmp ) {
 269                         printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 270                         return 0;
 271                 }
 272                 printf("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
 273                         bmp->w, bmp->h, bmp->format->BitsPerPixel);
 274                 PrintFlags(bmp->flags);
 275                 printf("\n");
 276                 then = SDL_GetTicks();
 277                 frames = RunBlitTests(screen, bmp, NUM_BLITS);
 278                 now = SDL_GetTicks();
 279                 seconds = (float)(now - then) / 1000.0f;
 280                 if ( seconds > 0.0f ) {
 281                         printf("%d alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 282                 } else {
 283                         printf("%d alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 284                 }
 285         }
 286
 287         /* clear the screen after alpha blit test */
 288         SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
 289         SDL_Flip(screen);
 290
 291         while ( SDL_PollEvent(&event) ) {
 292                 if ( event.type == SDL_KEYDOWN )
 293                         return 0;
 294         }
 295
 296         /* run the cc+alpha blit test only if screen bpp>8 */
 297         if (bmp->format->BitsPerPixel>8)
 298         {
 299                 SDL_FreeSurface(bmpcc);
 300                 bmpcc = SDL_LoadBMP("sample.bmp");
 301                 SDL_SetAlpha(bmpcc, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
 302                 SDL_SetColorKey(bmpcc, SDL_SRCCOLORKEY | SDL_RLEACCEL, *(Uint8 *)bmpcc->pixels);
 303                 tmp = bmpcc;
 304                 bmpcc = SDL_DisplayFormat(bmpcc);
 305                 SDL_FreeSurface(tmp);
 306                 if ( ! bmpcc ) {
 307                         printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
 308                         return 0;
 309                 }
 310                 printf("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
 311                         bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
 312                 PrintFlags(bmpcc->flags);
 313                 printf("\n");
 314                 then = SDL_GetTicks();
 315                 frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
 316                 now = SDL_GetTicks();
 317                 seconds = (float)(now - then) / 1000.0f;
 318                 if ( seconds > 0.0f ) {
 319                         printf("%d cc+alpha blits / %d updates in %2.2f seconds, %2.2f FPS\n", NUM_BLITS*frames, frames, seconds, (float)frames / seconds);
 320                 } else {
 321                         printf("%d cc+alpha blits / %d updates in zero seconds!\n", NUM_BLITS*frames, frames);
 322                 }
 323         }
 324
 325         SDL_FreeSurface(bmpcc);
 326         SDL_FreeSurface(bmp);
 327
 328         while ( SDL_PollEvent(&event) ) {
 329                 if ( event.type == SDL_KEYDOWN )
 330                         return 0;
 331         }
 332         return 1;
 333 }
 334
 335 void RunVideoTests()
 336 {
 337         static const struct {
 338                 int w, h, bpp;
 339         } mode_list[] = {
 340                 { 640, 480, 8 }, { 640, 480, 16 }, { 640, 480, 32 },
 341                 { 800, 600, 8 }, { 800, 600, 16 }, { 800, 600, 32 },
 342                 { 1024, 768, 8 }, { 1024, 768, 16 }, { 1024, 768, 32 }
 343         };
 344         static const Uint32 flags[] = {
 345                 (SDL_SWSURFACE),
 346                 (SDL_SWSURFACE | SDL_FULLSCREEN),
 347                 (SDL_HWSURFACE | SDL_FULLSCREEN),
 348                 (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF)
 349         };
 350         int i, j;
 351         SDL_Surface *screen;
 352
 353         /* Test out several different video mode combinations */
 354         SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
 355         SDL_ShowCursor(0);
 356         for ( i = 0; i < SDL_TABLESIZE(mode_list); ++i ) {
 357                 for ( j = 0; j < SDL_TABLESIZE(flags); ++j ) {
 358                         printf("===================================\n");
 359                         printf("Setting video mode: %dx%d at %d bpp, flags: ",
 360                                                   mode_list[i].w,
 361                                                   mode_list[i].h,
 362                                                   mode_list[i].bpp);
 363                         PrintFlags(flags[j]);
 364                         printf("\n");
 365                         screen = SDL_SetVideoMode(mode_list[i].w,
 366                                                   mode_list[i].h,
 367                                                   mode_list[i].bpp,
 368                                                   flags[j]);
 369                         if ( ! screen ) {
 370                                 printf("Setting video mode failed: %s\n", SDL_GetError());
 371                                 continue;
 372                         }
 373                         if ( (screen->flags & FLAG_MASK) != flags[j] ) {
 374                                 printf("Flags didn't match: ");
 375                                 PrintFlags(screen->flags);
 376                                 printf("\n");
 377                                 continue;
 378                         }
 379                         if ( ! RunModeTests(screen) ) {
 380                                 return;
 381                         }
 382                 }
 383         }
 384 }
 385
 386 int main(int argc, char *argv[])
 387 {
 388         const SDL_VideoInfo *info;
 389         int i;
 390         SDL_Rect **modes;
 391         char driver[128];
 392
 393         if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) {
 394                 fprintf(stderr,
 395                         "Couldn't initialize SDL: %s\n", SDL_GetError());
 396                 exit(1);
 397         }
 398         if ( SDL_VideoDriverName(driver, sizeof(driver)) ) {
 399                 printf("Video driver: %s\n", driver);
 400         }
 401         info = SDL_GetVideoInfo();
 402         printf(
 403 "Current display: %dx%d, %d bits-per-pixel\n",
 404                 info->current_w, info->current_h, info->vfmt->BitsPerPixel);
 405         if ( info->vfmt->palette == NULL ) {
 406                 printf("        Red Mask = 0x%.8x\n", info->vfmt->Rmask);
 407                 printf("        Green Mask = 0x%.8x\n", info->vfmt->Gmask);
 408                 printf("        Blue Mask = 0x%.8x\n", info->vfmt->Bmask);
 409         }
 410         /* Print available fullscreen video modes */
 411         modes = SDL_ListModes(NULL, SDL_FULLSCREEN);
 412         if ( modes == (SDL_Rect **)0 ) {
 413                 printf("No available fullscreen video modes\n");
 414         } else
 415         if ( modes == (SDL_Rect **)-1 ) {
 416                 printf("No special fullscreen video modes\n");
 417         } else {
 418                 printf("Fullscreen video modes:\n");
 419                 for ( i=0; modes[i]; ++i ) {
 420                         printf("\t%dx%dx%d\n", modes[i]->w, modes[i]->h, info->vfmt->BitsPerPixel);
 421                 }
 422         }
 423         if ( info->wm_available ) {
 424                 printf("A window manager is available\n");
 425         }
 426         if ( info->hw_available ) {
 427                 printf("Hardware surfaces are available (%dK video memory)\n",
 428                         info->video_mem);
 429         }
 430         if ( info->blit_hw ) {
 431                 printf(
 432 "Copy blits between hardware surfaces are accelerated\n");
 433         }
 434         if ( info->blit_hw_CC ) {
 435                 printf(
 436 "Colorkey blits between hardware surfaces are accelerated\n");
 437         }
 438         if ( info->blit_hw_A ) {
 439                 printf(
 440 "Alpha blits between hardware surfaces are accelerated\n");
 441         }
 442         if ( info->blit_sw ) {
 443                 printf(
 444 "Copy blits from software surfaces to hardware surfaces are accelerated\n");
 445         }
 446         if ( info->blit_sw_CC ) {
 447                 printf(
 448 "Colorkey blits from software surfaces to hardware surfaces are accelerated\n");
 449         }
 450         if ( info->blit_sw_A ) {
 451                 printf(
 452 "Alpha blits from software surfaces to hardware surfaces are accelerated\n");
 453         }
 454         if ( info->blit_fill ) {
 455                 printf(
 456 "Color fills on hardware surfaces are accelerated\n");
 457         }
 458
 459         if ( argv[1] && (strcmp(argv[1], "-benchmark") == 0) ) {
 460                 RunVideoTests();
 461         }
 462
 463         SDL_Quit();
 464         return(0);
 465 }