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
PrintFlags(Uint32 flags)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
RunBlitTests(SDL_Surface * screen,SDL_Surface * bmp,int blitcount)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
RunModeTests(SDL_Surface * screen)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
RunVideoTests()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
main(int argc,char * argv[])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 }
466