This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
testvidinfo.c
1
2
3
/* Simple program -- figure out what kind of video display we have */
4
#include <stdlib.h>
5
6
#include <stdio.h>
#include <stdlib.h>
7
#include <string.h>
8
9
10
#include "SDL.h"
11
12
13
#define NUM_BLITS 10
#define NUM_UPDATES 500
14
15
16
#define FLAG_MASK (SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF | \
SDL_SRCCOLORKEY | SDL_SRCALPHA | SDL_RLEACCEL | \
SDL_RLEACCELOK)
20
PrintFlags(Uint32 flags)
22
printf("0x%8.8x", (flags & FLAG_MASK));
23
if (flags & SDL_HWSURFACE) {
24
printf(" SDL_HWSURFACE");
26
printf(" SDL_SWSURFACE");
27
28
}
if (flags & SDL_FULLSCREEN) {
29
printf(" | SDL_FULLSCREEN");
30
31
}
if (flags & SDL_DOUBLEBUF) {
32
printf(" | SDL_DOUBLEBUF");
33
34
}
if (flags & SDL_SRCCOLORKEY) {
35
printf(" | SDL_SRCCOLORKEY");
36
37
}
if (flags & SDL_SRCALPHA) {
38
printf(" | SDL_SRCALPHA");
39
40
}
if (flags & SDL_RLEACCEL) {
41
printf(" | SDL_RLEACCEL");
42
43
}
if (flags & SDL_RLEACCELOK) {
44
printf(" | SDL_RLEACCELOK");
49
RunBlitTests(SDL_Surface * screen, SDL_Surface * bmp, int blitcount)
51
52
53
54
55
56
57
58
59
60
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) {
61
dst.x = rand() % maxx;
62
63
64
65
} else {
dst.x = 0;
}
if (maxy) {
66
dst.y = rand() % maxy;
67
68
69
70
71
} else {
dst.y = 0;
}
dst.w = bmp->w;
dst.h = bmp->h;
72
SDL_BlitSurface(bmp, NULL, screen, &dst);
74
SDL_Flip(screen);
75
76
77
}
return i;
81
RunModeTests(SDL_Surface * screen)
83
84
85
86
87
88
89
90
Uint32 then, now;
Uint32 frames;
float seconds;
int i;
Uint8 r, g, b;
SDL_Surface *bmp, *bmpcc, *tmp;
SDL_Event event;
91
while (SDL_PollEvent(&event)) {
92
93
94
95
96
if (event.type == SDL_KEYDOWN)
return 0;
}
/* First test fills and screen update speed */
97
98
printf("Running color fill and fullscreen update test\n");
then = SDL_GetTicks();
99
100
101
102
103
frames = 0;
for (i = 0; i < 256; ++i) {
r = i;
g = 0;
b = 0;
104
105
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
SDL_Flip(screen);
106
107
108
109
110
111
++frames;
}
for (i = 0; i < 256; ++i) {
r = 0;
g = i;
b = 0;
112
113
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
SDL_Flip(screen);
114
115
116
117
118
119
++frames;
}
for (i = 0; i < 256; ++i) {
r = 0;
g = 0;
b = i;
120
121
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, r, g, b));
SDL_Flip(screen);
122
123
++frames;
}
124
now = SDL_GetTicks();
125
126
seconds = (float) (now - then) / 1000.0f;
if (seconds > 0.0f) {
127
128
printf("%d fills and flips in %2.2f seconds, %2.2f FPS\n", frames,
seconds, (float) frames / seconds);
130
printf("%d fills and flips in zero seconds!n", frames);
131
132
133
}
/* clear the screen after fill test */
134
135
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
137
while (SDL_PollEvent(&event)) {
138
139
140
141
142
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the generic blit test */
143
bmp = SDL_LoadBMP("sample.bmp");
145
printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
146
147
return 0;
}
148
149
150
151
152
153
154
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();
155
156
seconds = (float) (now - then) / 1000.0f;
if (seconds > 0.0f) {
157
158
printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n",
NUM_BLITS * frames, frames, seconds, (float) frames / seconds);
160
161
printf("%d blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
162
163
164
}
/* clear the screen after blit test */
165
166
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
168
while (SDL_PollEvent(&event)) {
169
170
171
172
173
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the colorkeyed blit test */
174
bmpcc = SDL_LoadBMP("sample.bmp");
176
printf("Couldn't load sample.bmp: %s\n", SDL_GetError());
177
178
return 0;
}
179
180
181
182
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);
184
185
186
187
188
PrintFlags(bmpcc->flags);
printf("\n");
then = SDL_GetTicks();
frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
now = SDL_GetTicks();
189
190
seconds = (float) (now - then) / 1000.0f;
if (seconds > 0.0f) {
191
192
printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n",
NUM_BLITS * frames, frames, seconds, (float) frames / seconds);
194
195
printf("%d cc blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
196
197
198
}
/* clear the screen after cc blit test */
199
200
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
202
while (SDL_PollEvent(&event)) {
203
204
205
206
207
208
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the generic blit test */
tmp = bmp;
209
210
bmp = SDL_DisplayFormat(bmp);
SDL_FreeSurface(tmp);
212
printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
213
214
return 0;
}
215
216
217
218
219
220
221
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();
222
223
seconds = (float) (now - then) / 1000.0f;
if (seconds > 0.0f) {
224
225
printf("%d blits / %d updates in %2.2f seconds, %2.2f FPS\n",
NUM_BLITS * frames, frames, seconds, (float) frames / seconds);
227
228
printf("%d blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
229
230
231
}
/* clear the screen after blit test */
232
233
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
235
while (SDL_PollEvent(&event)) {
236
237
238
239
240
241
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the colorkeyed blit test */
tmp = bmpcc;
242
243
bmpcc = SDL_DisplayFormat(bmpcc);
SDL_FreeSurface(tmp);
245
printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
246
247
return 0;
}
248
249
250
251
252
253
254
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();
255
256
seconds = (float) (now - then) / 1000.0f;
if (seconds > 0.0f) {
257
258
printf("%d cc blits / %d updates in %2.2f seconds, %2.2f FPS\n",
NUM_BLITS * frames, frames, seconds, (float) frames / seconds);
260
261
printf("%d cc blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
262
263
264
}
/* clear the screen after cc blit test */
265
266
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
268
while (SDL_PollEvent(&event)) {
269
270
271
272
273
274
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the alpha blit test only if screen bpp>8 */
if (bmp->format->BitsPerPixel > 8) {
275
276
277
SDL_FreeSurface(bmp);
bmp = SDL_LoadBMP("sample.bmp");
SDL_SetAlpha(bmp, SDL_SRCALPHA, 85); /* 85 - 33% alpha */
279
280
bmp = SDL_DisplayFormat(bmp);
SDL_FreeSurface(tmp);
282
printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
283
284
285
286
287
return 0;
}
printf
("Running display format alpha blit test: %dx%d at %d bpp, flags: ",
bmp->w, bmp->h, bmp->format->BitsPerPixel);
288
289
290
291
292
PrintFlags(bmp->flags);
printf("\n");
then = SDL_GetTicks();
frames = RunBlitTests(screen, bmp, NUM_BLITS);
now = SDL_GetTicks();
293
294
295
296
297
298
299
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 {
300
301
printf("%d alpha blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
302
303
304
305
}
}
/* clear the screen after alpha blit test */
306
307
SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
SDL_Flip(screen);
309
while (SDL_PollEvent(&event)) {
310
311
312
313
314
315
if (event.type == SDL_KEYDOWN)
return 0;
}
/* run the cc+alpha blit test only if screen bpp>8 */
if (bmp->format->BitsPerPixel > 8) {
316
317
318
319
320
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);
322
323
bmpcc = SDL_DisplayFormat(bmpcc);
SDL_FreeSurface(tmp);
325
printf("Couldn't convert sample.bmp: %s\n", SDL_GetError());
326
327
328
329
330
return 0;
}
printf
("Running display format cc+alpha blit test: %dx%d at %d bpp, flags: ",
bmpcc->w, bmpcc->h, bmpcc->format->BitsPerPixel);
331
332
333
334
335
PrintFlags(bmpcc->flags);
printf("\n");
then = SDL_GetTicks();
frames = RunBlitTests(screen, bmpcc, NUM_BLITS);
now = SDL_GetTicks();
336
337
338
339
340
341
342
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 {
343
344
printf("%d cc+alpha blits / %d updates in zero seconds!\n",
NUM_BLITS * frames, frames);
348
349
SDL_FreeSurface(bmpcc);
SDL_FreeSurface(bmp);
351
while (SDL_PollEvent(&event)) {
352
353
354
355
if (event.type == SDL_KEYDOWN)
return 0;
}
return 1;
359
RunVideoTests()
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
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 */
386
387
388
389
390
391
392
393
394
395
396
397
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]);
398
if (!screen) {
399
printf("Setting video mode failed: %s\n", SDL_GetError());
400
401
402
continue;
}
if ((screen->flags & FLAG_MASK) != flags[j]) {
403
404
405
printf("Flags didn't match: ");
PrintFlags(screen->flags);
printf("\n");
406
407
continue;
}
408
if (!RunModeTests(screen)) {
409
410
411
412
return;
}
}
}
417
main(int argc, char *argv[])
418
{
419
const SDL_VideoInfo *info;
420
int i, d, n;
421
422
423
424
425
426
427
const char *driver;
const SDL_DisplayMode *mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
int nmodes;
/* Print available video drivers */
428
n = SDL_GetNumVideoDrivers();
430
printf("No built-in video drivers\n");
432
printf("Built-in video drivers:");
433
434
for (i = 0; i < n; ++i) {
if (i > 0) {
435
printf(",");
437
printf(" %s", SDL_GetVideoDriver(i));
439
printf("\n");
442
443
444
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
446
driver = SDL_GetCurrentVideoDriver();
448
449
450
printf("Video driver: %s\n", driver);
}
printf("Number of displays: %d\n", SDL_GetNumVideoDisplays());
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
for (d = 0; d < SDL_GetNumVideoDisplays(); ++d) {
printf("Display %d:\n", d);
SDL_SelectVideoDisplay(d);
mode = SDL_GetDesktopDisplayMode();
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) {
mode = SDL_GetDisplayMode(i);
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);
}
491
info = SDL_GetVideoInfo();
492
if (info->wm_available) {
493
printf("A window manager is available\n");
494
495
}
if (info->hw_available) {
496
497
printf("Hardware surfaces are available (%dK video memory)\n",
info->video_mem);
498
499
}
if (info->blit_hw) {
500
printf("Copy blits between hardware surfaces are accelerated\n");
501
502
}
if (info->blit_hw_CC) {
503
printf("Colorkey blits between hardware surfaces are accelerated\n");
504
505
}
if (info->blit_hw_A) {
506
printf("Alpha blits between hardware surfaces are accelerated\n");
507
508
509
510
511
512
513
514
515
516
517
518
519
520
}
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) {
521
printf("Color fills on hardware surfaces are accelerated\n");
524
525
if (argv[1] && (strcmp(argv[1], "-benchmark") == 0)) {
RunVideoTests();
529
SDL_Quit();
531
}