This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
testblitspeed.c
424 lines (367 loc) · 13.4 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/*
* Benchmarks surface-to-surface blits in various formats.
*
* Written by Ryan C. Gordon.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "SDL.h"
static SDL_Surface *dest = NULL;
static SDL_Surface *src = NULL;
static int testSeconds = 10;
18
19
static int
percent(int val, int total)
20
{
21
return ((int) ((((float) val) / ((float) total)) * 100.0f));
22
23
}
24
25
static int
randRange(int lo, int hi)
26
{
27
return (lo + (int) (((double) hi) * rand() / (RAND_MAX + 1.0)));
28
29
}
30
31
static void
copy_trunc_str(char *str, size_t strsize, const char *flagstr)
32
{
33
if ((strlen(str) + strlen(flagstr)) >= (strsize - 1))
34
35
36
37
38
strcpy(str + (strsize - 5), " ...");
else
strcat(str, flagstr);
}
39
40
41
static void
__append_sdl_surface_flag(SDL_Surface * _surface, char *str,
size_t strsize, Uint32 flag, const char *flagstr)
42
43
44
{
if (_surface->flags & flag)
copy_trunc_str(str, strsize, flagstr);
45
}
46
47
48
49
50
#define append_sdl_surface_flag(a, b, c, fl) __append_sdl_surface_flag(a, b, c, fl, " " #fl)
#define print_tf_state(str, val) printf("%s: {%s}\n", str, (val) ? "true" : "false" )
51
52
static void
output_videoinfo_details(void)
53
54
55
56
57
{
const SDL_VideoInfo *info = SDL_GetVideoInfo();
printf("SDL_GetVideoInfo():\n");
if (info == NULL)
printf(" (null.)\n");
58
else {
59
60
print_tf_state(" hardware surface available", info->hw_available);
print_tf_state(" window manager available", info->wm_available);
61
62
63
64
65
66
67
68
69
70
71
72
print_tf_state(" accelerated hardware->hardware blits",
info->blit_hw);
print_tf_state(" accelerated hardware->hardware colorkey blits",
info->blit_hw_CC);
print_tf_state(" accelerated hardware->hardware alpha blits",
info->blit_hw_A);
print_tf_state(" accelerated software->hardware blits",
info->blit_sw);
print_tf_state(" accelerated software->hardware colorkey blits",
info->blit_sw_CC);
print_tf_state(" accelerated software->hardware alpha blits",
info->blit_sw_A);
73
74
75
76
77
78
79
print_tf_state(" accelerated color fills", info->blit_fill);
printf(" video memory: (%d)\n", info->video_mem);
}
printf("\n");
}
80
81
static void
output_surface_details(const char *name, SDL_Surface * surface)
82
83
84
{
printf("Details for %s:\n", name);
85
if (surface == NULL) {
86
printf("-WARNING- You've got a NULL surface!");
87
} else {
88
char f[256];
89
90
printf(" width : %d\n", surface->w);
printf(" height : %d\n", surface->h);
91
92
printf(" depth : %d bits per pixel\n",
surface->format->BitsPerPixel);
93
94
printf(" pitch : %d\n", (int) surface->pitch);
printf(" alpha : %d\n", (int) surface->format->alpha);
95
96
printf(" colorkey : 0x%X\n",
(unsigned int) surface->format->colorkey);
97
98
printf(" red bits : 0x%08X mask, %d shift, %d loss\n",
99
100
(int) surface->format->Rmask,
(int) surface->format->Rshift, (int) surface->format->Rloss);
101
printf(" green bits : 0x%08X mask, %d shift, %d loss\n",
102
103
(int) surface->format->Gmask,
(int) surface->format->Gshift, (int) surface->format->Gloss);
104
printf(" blue bits : 0x%08X mask, %d shift, %d loss\n",
105
106
(int) surface->format->Bmask,
(int) surface->format->Bshift, (int) surface->format->Bloss);
107
printf(" alpha bits : 0x%08X mask, %d shift, %d loss\n",
108
109
(int) surface->format->Amask,
(int) surface->format->Ashift, (int) surface->format->Aloss);
110
111
112
f[0] = '\0';
113
/*append_sdl_surface_flag(surface, f, sizeof (f), SDL_SWSURFACE); */
114
if ((surface->flags & SDL_HWSURFACE) == 0)
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
copy_trunc_str(f, sizeof(f), " SDL_SWSURFACE");
append_sdl_surface_flag(surface, f, sizeof(f), SDL_HWSURFACE);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_ASYNCBLIT);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_ANYFORMAT);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_HWPALETTE);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_DOUBLEBUF);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_FULLSCREEN);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_OPENGL);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_RESIZABLE);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_NOFRAME);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_HWACCEL);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_SRCCOLORKEY);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_RLEACCELOK);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_RLEACCEL);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_SRCALPHA);
append_sdl_surface_flag(surface, f, sizeof(f), SDL_PREALLOC);
132
133
134
135
if (f[0] == '\0')
strcpy(f, " (none)");
136
137
printf(" flags :%s\n", f);
}
138
139
140
141
printf("\n");
}
142
143
static void
output_details(void)
144
{
145
output_videoinfo_details();
146
147
148
149
output_surface_details("Source Surface", src);
output_surface_details("Destination Surface", dest);
}
150
151
static Uint32
blit(SDL_Surface * dst, SDL_Surface * src, int x, int y)
152
153
154
155
156
157
158
159
160
{
Uint32 start = 0;
SDL_Rect srcRect;
SDL_Rect dstRect;
srcRect.x = 0;
srcRect.y = 0;
dstRect.x = x;
dstRect.y = y;
161
dstRect.w = srcRect.w = src->w; /* SDL will clip as appropriate. */
162
163
164
165
dstRect.h = srcRect.h = src->h;
start = SDL_GetTicks();
SDL_BlitSurface(src, &srcRect, dst, &dstRect);
166
return (SDL_GetTicks() - start);
167
168
}
169
170
static void
blitCentered(SDL_Surface * dst, SDL_Surface * src)
171
172
173
174
175
176
{
int x = (dst->w - src->w) / 2;
int y = (dst->h - src->h) / 2;
blit(dst, src, x, y);
}
177
178
static int
atoi_hex(const char *str)
179
180
181
182
{
if (str == NULL)
return 0;
183
if (strlen(str) > 2) {
184
185
186
int retval = 0;
if ((str[0] == '0') && (str[1] == 'x'))
sscanf(str + 2, "%X", &retval);
187
return (retval);
188
189
}
190
return (atoi(str));
191
192
193
}
194
195
static int
setup_test(int argc, char **argv)
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
{
const char *dumpfile = NULL;
SDL_Surface *bmp = NULL;
Uint32 dstbpp = 32;
Uint32 dstrmask = 0x00FF0000;
Uint32 dstgmask = 0x0000FF00;
Uint32 dstbmask = 0x000000FF;
Uint32 dstamask = 0x00000000;
Uint32 dstflags = 0;
int dstw = 640;
int dsth = 480;
Uint32 srcbpp = 32;
Uint32 srcrmask = 0x00FF0000;
Uint32 srcgmask = 0x0000FF00;
Uint32 srcbmask = 0x000000FF;
Uint32 srcamask = 0x00000000;
Uint32 srcflags = 0;
int srcw = 640;
int srch = 480;
215
216
217
218
219
220
Uint32 origsrcalphaflags = 0;
Uint32 origdstalphaflags = 0;
Uint32 srcalphaflags = 0;
Uint32 dstalphaflags = 0;
int srcalpha = 255;
int dstalpha = 255;
221
int screenSurface = 0;
222
int i = 0;
223
224
for (i = 1; i < argc; i++) {
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
const char *arg = argv[i];
if (strcmp(arg, "--dstbpp") == 0)
dstbpp = atoi(argv[++i]);
else if (strcmp(arg, "--dstrmask") == 0)
dstrmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--dstgmask") == 0)
dstgmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--dstbmask") == 0)
dstbmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--dstamask") == 0)
dstamask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--dstwidth") == 0)
dstw = atoi(argv[++i]);
else if (strcmp(arg, "--dstheight") == 0)
dsth = atoi(argv[++i]);
else if (strcmp(arg, "--dsthwsurface") == 0)
dstflags |= SDL_HWSURFACE;
else if (strcmp(arg, "--srcbpp") == 0)
srcbpp = atoi(argv[++i]);
else if (strcmp(arg, "--srcrmask") == 0)
srcrmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--srcgmask") == 0)
srcgmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--srcbmask") == 0)
srcbmask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--srcamask") == 0)
srcamask = atoi_hex(argv[++i]);
else if (strcmp(arg, "--srcwidth") == 0)
srcw = atoi(argv[++i]);
else if (strcmp(arg, "--srcheight") == 0)
srch = atoi(argv[++i]);
else if (strcmp(arg, "--srchwsurface") == 0)
srcflags |= SDL_HWSURFACE;
else if (strcmp(arg, "--seconds") == 0)
testSeconds = atoi(argv[++i]);
else if (strcmp(arg, "--screen") == 0)
screenSurface = 1;
else if (strcmp(arg, "--dumpfile") == 0)
dumpfile = argv[++i];
265
/* !!! FIXME: set colorkey. */
266
else if (0) { /* !!! FIXME: we handle some commandlines elsewhere now */
267
fprintf(stderr, "Unknown commandline option: %s\n", arg);
268
return (0);
269
270
271
}
}
272
if (SDL_Init(SDL_INIT_VIDEO) == -1) {
273
fprintf(stderr, "SDL_Init failed: %s\n", SDL_GetError());
274
return (0);
275
276
277
}
bmp = SDL_LoadBMP("sample.bmp");
278
if (bmp == NULL) {
279
280
fprintf(stderr, "SDL_LoadBMP failed: %s\n", SDL_GetError());
SDL_Quit();
281
return (0);
282
283
}
284
285
286
287
if ((dstflags & SDL_HWSURFACE) == 0)
dstflags |= SDL_SWSURFACE;
if ((srcflags & SDL_HWSURFACE) == 0)
srcflags |= SDL_SWSURFACE;
288
289
290
if (screenSurface)
dest = SDL_SetVideoMode(dstw, dsth, dstbpp, dstflags);
291
else {
292
293
294
295
dest = SDL_CreateRGBSurface(dstflags, dstw, dsth, dstbpp,
dstrmask, dstgmask, dstbmask, dstamask);
}
296
if (dest == NULL) {
297
298
fprintf(stderr, "dest surface creation failed: %s\n", SDL_GetError());
SDL_Quit();
299
return (0);
300
301
302
303
}
src = SDL_CreateRGBSurface(srcflags, srcw, srch, srcbpp,
srcrmask, srcgmask, srcbmask, srcamask);
304
if (src == NULL) {
305
306
fprintf(stderr, "src surface creation failed: %s\n", SDL_GetError());
SDL_Quit();
307
return (0);
308
309
}
310
/* handle alpha settings... */
311
312
313
srcalphaflags = (src->flags & SDL_SRCALPHA) | (src->flags & SDL_RLEACCEL);
dstalphaflags =
(dest->flags & SDL_SRCALPHA) | (dest->flags & SDL_RLEACCEL);
314
315
316
317
origsrcalphaflags = srcalphaflags;
origdstalphaflags = dstalphaflags;
srcalpha = src->format->alpha;
dstalpha = dest->format->alpha;
318
for (i = 1; i < argc; i++) {
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
const char *arg = argv[i];
if (strcmp(arg, "--srcalpha") == 0)
srcalpha = atoi(argv[++i]);
else if (strcmp(arg, "--dstalpha") == 0)
dstalpha = atoi(argv[++i]);
else if (strcmp(arg, "--srcsrcalpha") == 0)
srcalphaflags |= SDL_SRCALPHA;
else if (strcmp(arg, "--srcnosrcalpha") == 0)
srcalphaflags &= ~SDL_SRCALPHA;
else if (strcmp(arg, "--srcrleaccel") == 0)
srcalphaflags |= SDL_RLEACCEL;
else if (strcmp(arg, "--srcnorleaccel") == 0)
srcalphaflags &= ~SDL_RLEACCEL;
else if (strcmp(arg, "--dstsrcalpha") == 0)
dstalphaflags |= SDL_SRCALPHA;
else if (strcmp(arg, "--dstnosrcalpha") == 0)
dstalphaflags &= ~SDL_SRCALPHA;
else if (strcmp(arg, "--dstrleaccel") == 0)
dstalphaflags |= SDL_RLEACCEL;
else if (strcmp(arg, "--dstnorleaccel") == 0)
dstalphaflags &= ~SDL_RLEACCEL;
}
342
343
if ((dstalphaflags != origdstalphaflags)
|| (dstalpha != dest->format->alpha))
344
SDL_SetAlpha(dest, dstalphaflags, (Uint8) dstalpha);
345
346
if ((srcalphaflags != origsrcalphaflags)
|| (srcalpha != src->format->alpha))
347
348
SDL_SetAlpha(src, srcalphaflags, (Uint8) srcalpha);
349
350
351
352
353
354
355
356
/* set some sane defaults so we can see if the blit code is broken... */
SDL_FillRect(dest, NULL, SDL_MapRGB(dest->format, 0, 0, 0));
SDL_FillRect(src, NULL, SDL_MapRGB(src->format, 0, 0, 0));
blitCentered(src, bmp);
SDL_FreeSurface(bmp);
if (dumpfile)
357
SDL_SaveBMP(src, dumpfile); /* make sure initial convert is sane. */
358
359
360
output_details();
361
return (1);
362
363
364
}
365
366
static void
test_blit_speed(void)
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
{
Uint32 clearColor = SDL_MapRGB(dest->format, 0, 0, 0);
Uint32 iterations = 0;
Uint32 elasped = 0;
Uint32 end = 0;
Uint32 now = 0;
Uint32 last = 0;
int testms = testSeconds * 1000;
int wmax = (dest->w - src->w);
int hmax = (dest->h - src->h);
int isScreen = (SDL_GetVideoSurface() == dest);
SDL_Event event;
printf("Testing blit speed for %d seconds...\n", testSeconds);
now = SDL_GetTicks();
end = now + testms;
385
do {
386
/* pump the event queue occasionally to keep OS happy... */
387
if (now - last > 1000) {
388
last = now;
389
390
while (SDL_PollEvent(&event)) { /* no-op. */
}
391
392
393
394
}
iterations++;
elasped += blit(dest, src, randRange(0, wmax), randRange(0, hmax));
395
396
397
if (isScreen) {
SDL_Flip(dest); /* show it! */
SDL_FillRect(dest, NULL, clearColor); /* blank it for next time! */
398
399
400
}
now = SDL_GetTicks();
401
402
}
while (now < end);
403
404
printf("Non-blitting crap accounted for %d percent of this run.\n",
405
percent(testms - elasped, testms));
406
407
printf("%d blits took %d ms (%d fps).\n",
408
409
410
(int) iterations,
(int) elasped,
(int) (((float) iterations) / (((float) elasped) / 1000.0f)));
411
412
}
413
414
int
main(int argc, char **argv)
415
416
{
int initialized = setup_test(argc, argv);
417
if (initialized) {
418
419
420
test_blit_speed();
SDL_Quit();
}
421
return (!initialized);
422
423
424
}
/* end of testblitspeed.c ... */