This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
testvidinfo.c
524 lines (485 loc) · 15.7 KB
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)
17
18
19
#if 0
void
20
PrintFlags(Uint32 flags)
21
{
22
printf("0x%8.8x", (flags & FLAG_MASK));
23
if (flags & SDL_HWSURFACE) {
24
printf(" SDL_HWSURFACE");
25
} else {
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");
45
}
46
47
}
48
int
49
RunBlitTests(SDL_Surface * screen, SDL_Surface * bmp, int blitcount)
50
{
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);
73
}
74
SDL_Flip(screen);
75
76
77
}
return i;
78
79
}
80
int
81
RunModeTests(SDL_Surface * screen)
82
{
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);
129
} else {
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);
136
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");
144
if (!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);
159
} else {
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);
167
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");
175
if (!bmpcc) {
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);
183
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);
193
} else {
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);
201
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);
211
if (!bmp) {
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);
226
} else {
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);
234
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);
244
if (!bmpcc) {
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);
259
} else {
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);
267
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 */
278
tmp = bmp;
279
280
bmp = SDL_DisplayFormat(bmp);
SDL_FreeSurface(tmp);
281
if (!bmp) {
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);
308
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);
321
tmp = bmpcc;
322
323
bmpcc = SDL_DisplayFormat(bmpcc);
SDL_FreeSurface(tmp);
324
if (!bmpcc) {
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);
345
346
347
}
}
348
349
SDL_FreeSurface(bmpcc);
SDL_FreeSurface(bmp);
350
351
while (SDL_PollEvent(&event)) {
352
353
354
355
if (event.type == SDL_KEYDOWN)
return 0;
}
return 1;
356
357
}
358
void
359
RunVideoTests()
360
{
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;
}
}
}
413
}
414
#endif
415
416
int
417
main(int argc, char *argv[])
418
{
419
420
421
422
423
424
425
426
427
const SDL_VideoInfo *info;
int i, n;
const char *driver;
const SDL_DisplayMode *mode;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
int nmodes;
/* Print available video drivers */
428
n = SDL_GetNumVideoDrivers();
429
if (n == 0) {
430
printf("No built-in video drivers\n");
431
} else {
432
printf("Built-in video drivers:");
433
434
for (i = 0; i < n; ++i) {
if (i > 0) {
435
printf(",");
436
}
437
printf(" %s", SDL_GetVideoDriver(i));
438
}
439
printf("\n");
440
441
}
442
443
444
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
fprintf(stderr, "Couldn't initialize SDL: %s\n", SDL_GetError());
exit(1);
445
}
446
driver = SDL_GetCurrentVideoDriver();
447
if (driver) {
448
449
450
451
452
453
454
455
printf("Video driver: %s\n", driver);
}
printf("Number of displays: %d\n", SDL_GetNumVideoDisplays());
mode = SDL_GetDesktopDisplayMode();
SDL_PixelFormatEnumToMasks(mode->format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask);
printf("Current display: %dx%d@%dHz, %d bits-per-pixel\n", mode->w,
mode->h, mode->refresh_rate, bpp);
456
if (Rmask || Gmask || Bmask) {
457
458
459
printf(" Red Mask = 0x%.8x\n", Rmask);
printf(" Green Mask = 0x%.8x\n", Gmask);
printf(" Blue Mask = 0x%.8x\n", Bmask);
460
if (Amask)
461
printf(" Alpha Mask = 0x%.8x\n", Amask);
462
463
}
/* Print available fullscreen video modes */
464
nmodes = SDL_GetNumDisplayModes();
465
if (nmodes == 0) {
466
printf("No available fullscreen video modes\n");
467
} else {
468
printf("Fullscreen video modes:\n");
469
for (i = 0; i < nmodes; ++i) {
470
471
472
473
474
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);
475
if (Rmask || Gmask || Bmask) {
476
477
478
printf(" Red Mask = 0x%.8x\n", Rmask);
printf(" Green Mask = 0x%.8x\n", Gmask);
printf(" Blue Mask = 0x%.8x\n", Bmask);
479
if (Amask)
480
printf(" Alpha Mask = 0x%.8x\n", Amask);
481
482
483
}
}
}
484
info = SDL_GetVideoInfo();
485
if (info->wm_available) {
486
printf("A window manager is available\n");
487
488
}
if (info->hw_available) {
489
490
printf("Hardware surfaces are available (%dK video memory)\n",
info->video_mem);
491
492
}
if (info->blit_hw) {
493
printf("Copy blits between hardware surfaces are accelerated\n");
494
495
}
if (info->blit_hw_CC) {
496
printf("Colorkey blits between hardware surfaces are accelerated\n");
497
498
}
if (info->blit_hw_A) {
499
printf("Alpha blits between hardware surfaces are accelerated\n");
500
501
502
503
504
505
506
507
508
509
510
511
512
513
}
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) {
514
printf("Color fills on hardware surfaces are accelerated\n");
515
516
}
#if 0
517
518
if (argv[1] && (strcmp(argv[1], "-benchmark") == 0)) {
RunVideoTests();
519
520
521
}
#endif
522
SDL_Quit();
523
return (0);
524
}