|
1 |
|
2 /* Bring up a window and play with it */ |
|
3 |
|
4 #include <stdlib.h> |
|
5 #include <stdio.h> |
|
6 #include <string.h> |
|
7 |
|
8 #define BENCHMARK_SDL |
|
9 |
|
10 #define NOTICE(X) printf("%s", X); |
|
11 |
|
12 #define WINDOW_WIDTH 640 |
|
13 #define WINDOW_HEIGHT 480 |
|
14 |
|
15 #include "SDL.h" |
|
16 |
|
17 SDL_Surface *screen, *pic; |
|
18 SDL_Overlay *overlay; |
|
19 int scale; |
|
20 int monochrome; |
|
21 int luminance; |
|
22 int w, h; |
|
23 |
|
24 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */ |
|
25 static void quit(int rc) |
|
26 { |
|
27 SDL_Quit(); |
|
28 exit(rc); |
|
29 } |
|
30 |
|
31 /* NOTE: These RGB conversion functions are not intended for speed, |
|
32 only as examples. |
|
33 */ |
|
34 |
|
35 void RGBtoYUV(Uint8 *rgb, int *yuv, int monochrome, int luminance) |
|
36 { |
|
37 if (monochrome) |
|
38 { |
|
39 #if 1 /* these are the two formulas that I found on the FourCC site... */ |
|
40 yuv[0] = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2]; |
|
41 yuv[1] = 128; |
|
42 yuv[2] = 128; |
|
43 #else |
|
44 yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16; |
|
45 yuv[1] = 128; |
|
46 yuv[2] = 128; |
|
47 #endif |
|
48 } |
|
49 else |
|
50 { |
|
51 #if 1 /* these are the two formulas that I found on the FourCC site... */ |
|
52 yuv[0] = 0.299*rgb[0] + 0.587*rgb[1] + 0.114*rgb[2]; |
|
53 yuv[1] = (rgb[2]-yuv[0])*0.565 + 128; |
|
54 yuv[2] = (rgb[0]-yuv[0])*0.713 + 128; |
|
55 #else |
|
56 yuv[0] = (0.257 * rgb[0]) + (0.504 * rgb[1]) + (0.098 * rgb[2]) + 16; |
|
57 yuv[1] = 128 - (0.148 * rgb[0]) - (0.291 * rgb[1]) + (0.439 * rgb[2]); |
|
58 yuv[2] = 128 + (0.439 * rgb[0]) - (0.368 * rgb[1]) - (0.071 * rgb[2]); |
|
59 #endif |
|
60 } |
|
61 |
|
62 if (luminance!=100) |
|
63 { |
|
64 yuv[0]=yuv[0]*luminance/100; |
|
65 if (yuv[0]>255) |
|
66 yuv[0]=255; |
|
67 } |
|
68 |
|
69 /* clamp values...if you need to, we don't seem to have a need */ |
|
70 /* |
|
71 for(i=0;i<3;i++) |
|
72 { |
|
73 if(yuv[i]<0) |
|
74 yuv[i]=0; |
|
75 if(yuv[i]>255) |
|
76 yuv[i]=255; |
|
77 } |
|
78 */ |
|
79 } |
|
80 |
|
81 void ConvertRGBtoYV12(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance) |
|
82 { |
|
83 int x,y; |
|
84 int yuv[3]; |
|
85 Uint8 *p,*op[3]; |
|
86 |
|
87 SDL_LockSurface(s); |
|
88 SDL_LockYUVOverlay(o); |
|
89 |
|
90 /* Black initialization */ |
|
91 /* |
|
92 memset(o->pixels[0],0,o->pitches[0]*o->h); |
|
93 memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2)); |
|
94 memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2)); |
|
95 */ |
|
96 |
|
97 /* Convert */ |
|
98 for(y=0; y<s->h && y<o->h; y++) |
|
99 { |
|
100 p=((Uint8 *) s->pixels)+s->pitch*y; |
|
101 op[0]=o->pixels[0]+o->pitches[0]*y; |
|
102 op[1]=o->pixels[1]+o->pitches[1]*(y/2); |
|
103 op[2]=o->pixels[2]+o->pitches[2]*(y/2); |
|
104 for(x=0; x<s->w && x<o->w; x++) |
|
105 { |
|
106 RGBtoYUV(p, yuv, monochrome, luminance); |
|
107 *(op[0]++)=yuv[0]; |
|
108 if(x%2==0 && y%2==0) |
|
109 { |
|
110 *(op[1]++)=yuv[2]; |
|
111 *(op[2]++)=yuv[1]; |
|
112 } |
|
113 p+=s->format->BytesPerPixel; |
|
114 } |
|
115 } |
|
116 |
|
117 SDL_UnlockYUVOverlay(o); |
|
118 SDL_UnlockSurface(s); |
|
119 } |
|
120 |
|
121 void ConvertRGBtoIYUV(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance) |
|
122 { |
|
123 int x,y; |
|
124 int yuv[3]; |
|
125 Uint8 *p,*op[3]; |
|
126 |
|
127 SDL_LockSurface(s); |
|
128 SDL_LockYUVOverlay(o); |
|
129 |
|
130 /* Black initialization */ |
|
131 /* |
|
132 memset(o->pixels[0],0,o->pitches[0]*o->h); |
|
133 memset(o->pixels[1],128,o->pitches[1]*((o->h+1)/2)); |
|
134 memset(o->pixels[2],128,o->pitches[2]*((o->h+1)/2)); |
|
135 */ |
|
136 |
|
137 /* Convert */ |
|
138 for(y=0; y<s->h && y<o->h; y++) |
|
139 { |
|
140 p=((Uint8 *) s->pixels)+s->pitch*y; |
|
141 op[0]=o->pixels[0]+o->pitches[0]*y; |
|
142 op[1]=o->pixels[1]+o->pitches[1]*(y/2); |
|
143 op[2]=o->pixels[2]+o->pitches[2]*(y/2); |
|
144 for(x=0; x<s->w && x<o->w; x++) |
|
145 { |
|
146 RGBtoYUV(p,yuv, monochrome, luminance); |
|
147 *(op[0]++)=yuv[0]; |
|
148 if(x%2==0 && y%2==0) |
|
149 { |
|
150 *(op[1]++)=yuv[1]; |
|
151 *(op[2]++)=yuv[2]; |
|
152 } |
|
153 p+=s->format->BytesPerPixel; |
|
154 } |
|
155 } |
|
156 |
|
157 SDL_UnlockYUVOverlay(o); |
|
158 SDL_UnlockSurface(s); |
|
159 } |
|
160 |
|
161 void ConvertRGBtoUYVY(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance) |
|
162 { |
|
163 int x,y; |
|
164 int yuv[3]; |
|
165 Uint8 *p,*op; |
|
166 |
|
167 SDL_LockSurface(s); |
|
168 SDL_LockYUVOverlay(o); |
|
169 |
|
170 for(y=0; y<s->h && y<o->h; y++) |
|
171 { |
|
172 p=((Uint8 *) s->pixels)+s->pitch*y; |
|
173 op=o->pixels[0]+o->pitches[0]*y; |
|
174 for(x=0; x<s->w && x<o->w; x++) |
|
175 { |
|
176 RGBtoYUV(p, yuv, monochrome, luminance); |
|
177 if(x%2==0) |
|
178 { |
|
179 *(op++)=yuv[1]; |
|
180 *(op++)=yuv[0]; |
|
181 *(op++)=yuv[2]; |
|
182 } |
|
183 else |
|
184 *(op++)=yuv[0]; |
|
185 |
|
186 p+=s->format->BytesPerPixel; |
|
187 } |
|
188 } |
|
189 |
|
190 SDL_UnlockYUVOverlay(o); |
|
191 SDL_UnlockSurface(s); |
|
192 } |
|
193 |
|
194 void ConvertRGBtoYVYU(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance) |
|
195 { |
|
196 int x,y; |
|
197 int yuv[3]; |
|
198 Uint8 *p,*op; |
|
199 |
|
200 SDL_LockSurface(s); |
|
201 SDL_LockYUVOverlay(o); |
|
202 |
|
203 for(y=0; y<s->h && y<o->h; y++) |
|
204 { |
|
205 p=((Uint8 *) s->pixels)+s->pitch*y; |
|
206 op=o->pixels[0]+o->pitches[0]*y; |
|
207 for(x=0; x<s->w && x<o->w; x++) |
|
208 { |
|
209 RGBtoYUV(p,yuv, monochrome, luminance); |
|
210 if(x%2==0) |
|
211 { |
|
212 *(op++)=yuv[0]; |
|
213 *(op++)=yuv[2]; |
|
214 op[1]=yuv[1]; |
|
215 } |
|
216 else |
|
217 { |
|
218 *op=yuv[0]; |
|
219 op+=2; |
|
220 } |
|
221 |
|
222 p+=s->format->BytesPerPixel; |
|
223 } |
|
224 } |
|
225 |
|
226 SDL_UnlockYUVOverlay(o); |
|
227 SDL_UnlockSurface(s); |
|
228 } |
|
229 |
|
230 void ConvertRGBtoYUY2(SDL_Surface *s, SDL_Overlay *o, int monochrome, int luminance) |
|
231 { |
|
232 int x,y; |
|
233 int yuv[3]; |
|
234 Uint8 *p,*op; |
|
235 |
|
236 SDL_LockSurface(s); |
|
237 SDL_LockYUVOverlay(o); |
|
238 |
|
239 for(y=0; y<s->h && y<o->h; y++) |
|
240 { |
|
241 p=((Uint8 *) s->pixels)+s->pitch*y; |
|
242 op=o->pixels[0]+o->pitches[0]*y; |
|
243 for(x=0; x<s->w && x<o->w; x++) |
|
244 { |
|
245 RGBtoYUV(p,yuv, monochrome, luminance); |
|
246 if(x%2==0) |
|
247 { |
|
248 *(op++)=yuv[0]; |
|
249 *(op++)=yuv[1]; |
|
250 op[1]=yuv[2]; |
|
251 } |
|
252 else |
|
253 { |
|
254 *op=yuv[0]; |
|
255 op+=2; |
|
256 } |
|
257 |
|
258 p+=s->format->BytesPerPixel; |
|
259 } |
|
260 } |
|
261 |
|
262 SDL_UnlockYUVOverlay(o); |
|
263 SDL_UnlockSurface(s); |
|
264 } |
|
265 |
|
266 void Draw() |
|
267 { |
|
268 SDL_Rect rect; |
|
269 int i; |
|
270 int disp; |
|
271 |
|
272 if(!scale) |
|
273 { |
|
274 rect.w=overlay->w; |
|
275 rect.h=overlay->h; |
|
276 for(i=0; i<h-rect.h && i<w-rect.w; i++) |
|
277 { |
|
278 rect.x=i; |
|
279 rect.y=i; |
|
280 SDL_DisplayYUVOverlay(overlay,&rect); |
|
281 } |
|
282 } |
|
283 else |
|
284 { |
|
285 rect.w=overlay->w/2; |
|
286 rect.h=overlay->h/2; |
|
287 rect.x=(w-rect.w)/2; |
|
288 rect.y=(h-rect.h)/2; |
|
289 disp=rect.y-1; |
|
290 for(i=0; i<disp; i++) |
|
291 { |
|
292 rect.w+=2; |
|
293 rect.h+=2; |
|
294 rect.x--; |
|
295 rect.y--; |
|
296 SDL_DisplayYUVOverlay(overlay,&rect); |
|
297 } |
|
298 } |
|
299 printf("Displayed %d times.\n",i); |
|
300 } |
|
301 |
|
302 static void PrintUsage(char *argv0) |
|
303 { |
|
304 fprintf(stderr, "Usage: %s [arg] [arg] [arg] ...\n", argv0); |
|
305 fprintf(stderr, "Where 'arg' is one of:\n"); |
|
306 fprintf(stderr, " -delay <seconds>\n"); |
|
307 fprintf(stderr, " -width <pixels>\n"); |
|
308 fprintf(stderr, " -height <pixels>\n"); |
|
309 fprintf(stderr, " -bpp <bits>\n"); |
|
310 fprintf(stderr, " -format <fmt> (one of the: YV12, IYUV, YUY2, UYVY, YVYU)\n"); |
|
311 fprintf(stderr, " -hw\n"); |
|
312 fprintf(stderr, " -flip\n"); |
|
313 fprintf(stderr, " -scale (test scaling features, from 50%% upto window size)\n"); |
|
314 fprintf(stderr, " -mono (use monochromatic RGB2YUV conversion)\n"); |
|
315 fprintf(stderr, " -lum <perc> (use luminance correction during RGB2YUV conversion,\n"); |
|
316 fprintf(stderr, " from 0%% to unlimited, normal is 100%%)\n"); |
|
317 fprintf(stderr, " -help (shows this help)\n"); |
|
318 fprintf(stderr, " -fullscreen (test overlay in fullscreen mode)\n"); |
|
319 } |
|
320 |
|
321 int main(int argc, char **argv) |
|
322 { |
|
323 char *argv0 = argv[0]; |
|
324 int flip; |
|
325 int delay; |
|
326 int desired_bpp; |
|
327 Uint32 video_flags, overlay_format; |
|
328 char *bmpfile; |
|
329 #ifdef BENCHMARK_SDL |
|
330 Uint32 then, now; |
|
331 #endif |
|
332 int i; |
|
333 |
|
334 /* Set default options and check command-line */ |
|
335 flip = 0; |
|
336 scale=0; |
|
337 monochrome=0; |
|
338 luminance=100; |
|
339 delay = 1; |
|
340 w = WINDOW_WIDTH; |
|
341 h = WINDOW_HEIGHT; |
|
342 desired_bpp = 0; |
|
343 video_flags = 0; |
|
344 overlay_format = SDL_YV12_OVERLAY; |
|
345 |
|
346 while ( argc > 1 ) { |
|
347 if ( strcmp(argv[1], "-delay") == 0 ) { |
|
348 if ( argv[2] ) { |
|
349 delay = atoi(argv[2]); |
|
350 argv += 2; |
|
351 argc -= 2; |
|
352 } else { |
|
353 fprintf(stderr, |
|
354 "The -delay option requires an argument\n"); |
|
355 return(1); |
|
356 } |
|
357 } else |
|
358 if ( strcmp(argv[1], "-width") == 0 ) { |
|
359 if ( argv[2] && ((w = atoi(argv[2])) > 0) ) { |
|
360 argv += 2; |
|
361 argc -= 2; |
|
362 } else { |
|
363 fprintf(stderr, |
|
364 "The -width option requires an argument\n"); |
|
365 return(1); |
|
366 } |
|
367 } else |
|
368 if ( strcmp(argv[1], "-height") == 0 ) { |
|
369 if ( argv[2] && ((h = atoi(argv[2])) > 0) ) { |
|
370 argv += 2; |
|
371 argc -= 2; |
|
372 } else { |
|
373 fprintf(stderr, |
|
374 "The -height option requires an argument\n"); |
|
375 return(1); |
|
376 } |
|
377 } else |
|
378 if ( strcmp(argv[1], "-bpp") == 0 ) { |
|
379 if ( argv[2] ) { |
|
380 desired_bpp = atoi(argv[2]); |
|
381 argv += 2; |
|
382 argc -= 2; |
|
383 } else { |
|
384 fprintf(stderr, |
|
385 "The -bpp option requires an argument\n"); |
|
386 return(1); |
|
387 } |
|
388 } else |
|
389 if ( strcmp(argv[1], "-lum") == 0 ) { |
|
390 if ( argv[2] ) { |
|
391 luminance = atoi(argv[2]); |
|
392 argv += 2; |
|
393 argc -= 2; |
|
394 } else { |
|
395 fprintf(stderr, |
|
396 "The -lum option requires an argument\n"); |
|
397 return(1); |
|
398 } |
|
399 } else |
|
400 if ( strcmp(argv[1], "-format") == 0 ) { |
|
401 if ( argv[2] ) { |
|
402 if(!strcmp(argv[2],"YV12")) |
|
403 overlay_format = SDL_YV12_OVERLAY; |
|
404 else if(!strcmp(argv[2],"IYUV")) |
|
405 overlay_format = SDL_IYUV_OVERLAY; |
|
406 else if(!strcmp(argv[2],"YUY2")) |
|
407 overlay_format = SDL_YUY2_OVERLAY; |
|
408 else if(!strcmp(argv[2],"UYVY")) |
|
409 overlay_format = SDL_UYVY_OVERLAY; |
|
410 else if(!strcmp(argv[2],"YVYU")) |
|
411 overlay_format = SDL_YVYU_OVERLAY; |
|
412 else |
|
413 { |
|
414 fprintf(stderr, "The -format option %s is not recognized\n",argv[2]); |
|
415 return(1); |
|
416 } |
|
417 argv += 2; |
|
418 argc -= 2; |
|
419 } else { |
|
420 fprintf(stderr, |
|
421 "The -format option requires an argument\n"); |
|
422 return(1); |
|
423 } |
|
424 } else |
|
425 if ( strcmp(argv[1], "-hw") == 0 ) { |
|
426 video_flags |= SDL_HWSURFACE; |
|
427 argv += 1; |
|
428 argc -= 1; |
|
429 } else |
|
430 if ( strcmp(argv[1], "-flip") == 0 ) { |
|
431 video_flags |= SDL_DOUBLEBUF; |
|
432 argv += 1; |
|
433 argc -= 1; |
|
434 } else |
|
435 if ( strcmp(argv[1], "-scale") == 0 ) { |
|
436 scale = 1; |
|
437 argv += 1; |
|
438 argc -= 1; |
|
439 } else |
|
440 if ( strcmp(argv[1], "-mono") == 0 ) { |
|
441 monochrome = 1; |
|
442 argv += 1; |
|
443 argc -= 1; |
|
444 } else |
|
445 if (( strcmp(argv[1], "-help") == 0 ) || (strcmp(argv[1], "-h") == 0)) { |
|
446 PrintUsage(argv0); |
|
447 return(1); |
|
448 } else |
|
449 if ( strcmp(argv[1], "-fullscreen") == 0 ) { |
|
450 video_flags |= SDL_FULLSCREEN; |
|
451 argv += 1; |
|
452 argc -= 1; |
|
453 } else |
|
454 break; |
|
455 } |
|
456 if ( SDL_Init(SDL_INIT_VIDEO) < 0 ) { |
|
457 fprintf(stderr, |
|
458 "Couldn't initialize SDL: %s\n", SDL_GetError()); |
|
459 return(1); |
|
460 } |
|
461 |
|
462 /* Initialize the display */ |
|
463 screen = SDL_SetVideoMode(w, h, desired_bpp, video_flags); |
|
464 if ( screen == NULL ) { |
|
465 fprintf(stderr, "Couldn't set %dx%dx%d video mode: %s\n", |
|
466 w, h, desired_bpp, SDL_GetError()); |
|
467 quit(1); |
|
468 } |
|
469 printf("Set%s %dx%dx%d mode\n", |
|
470 screen->flags & SDL_FULLSCREEN ? " fullscreen" : "", |
|
471 screen->w, screen->h, screen->format->BitsPerPixel); |
|
472 printf("(video surface located in %s memory)\n", |
|
473 (screen->flags&SDL_HWSURFACE) ? "video" : "system"); |
|
474 if ( screen->flags & SDL_DOUBLEBUF ) { |
|
475 printf("Double-buffering enabled\n"); |
|
476 flip = 1; |
|
477 } |
|
478 |
|
479 /* Set the window manager title bar */ |
|
480 SDL_WM_SetCaption("SDL test overlay", "testoverlay"); |
|
481 |
|
482 /* Load picture */ |
|
483 bmpfile=(argv[1]?argv[1]:"sample.bmp"); |
|
484 pic = SDL_LoadBMP(bmpfile); |
|
485 if ( pic == NULL ) { |
|
486 fprintf(stderr, "Couldn't load %s: %s\n", bmpfile, |
|
487 SDL_GetError()); |
|
488 quit(1); |
|
489 } |
|
490 |
|
491 /* Convert the picture to 32bits, for easy conversion */ |
|
492 { |
|
493 SDL_Surface *newsurf; |
|
494 SDL_PixelFormat format; |
|
495 |
|
496 format.palette=NULL; |
|
497 format.BitsPerPixel=32; |
|
498 format.BytesPerPixel=4; |
|
499 #if SDL_BYTEORDER == SDL_LIL_ENDIAN |
|
500 format.Rshift=0; |
|
501 format.Gshift=8; |
|
502 format.Bshift=16; |
|
503 #else |
|
504 format.Rshift=24; |
|
505 format.Gshift=16; |
|
506 format.Bshift=8; |
|
507 #endif |
|
508 format.Ashift=0; |
|
509 format.Rmask=0xff<<format.Rshift; |
|
510 format.Gmask=0xff<<format.Gshift; |
|
511 format.Bmask=0xff<<format.Bshift; |
|
512 format.Amask=0; |
|
513 format.Rloss=0; |
|
514 format.Gloss=0; |
|
515 format.Bloss=0; |
|
516 format.Aloss=8; |
|
517 format.colorkey=0; |
|
518 format.alpha=0; |
|
519 |
|
520 newsurf=SDL_ConvertSurface(pic, &format, SDL_SWSURFACE); |
|
521 if(!newsurf) |
|
522 { |
|
523 fprintf(stderr, "Couldn't convert picture to 32bits RGB: %s\n", |
|
524 SDL_GetError()); |
|
525 quit(1); |
|
526 } |
|
527 SDL_FreeSurface(pic); |
|
528 pic=newsurf; |
|
529 } |
|
530 |
|
531 /* Create the overlay */ |
|
532 overlay = SDL_CreateYUVOverlay(pic->w, pic->h, overlay_format, screen); |
|
533 if ( overlay == NULL ) { |
|
534 fprintf(stderr, "Couldn't create overlay: %s\n", SDL_GetError()); |
|
535 quit(1); |
|
536 } |
|
537 printf("Created %dx%dx%d %s %s overlay\n",overlay->w,overlay->h,overlay->planes, |
|
538 overlay->hw_overlay?"hardware":"software", |
|
539 overlay->format==SDL_YV12_OVERLAY?"YV12": |
|
540 overlay->format==SDL_IYUV_OVERLAY?"IYUV": |
|
541 overlay->format==SDL_YUY2_OVERLAY?"YUY2": |
|
542 overlay->format==SDL_UYVY_OVERLAY?"UYVY": |
|
543 overlay->format==SDL_YVYU_OVERLAY?"YVYU": |
|
544 "Unknown"); |
|
545 for(i=0; i<overlay->planes; i++) |
|
546 { |
|
547 printf(" plane %d: pitch=%d\n", i, overlay->pitches[i]); |
|
548 } |
|
549 |
|
550 /* Convert to YUV, and draw to the overlay */ |
|
551 #ifdef BENCHMARK_SDL |
|
552 then = SDL_GetTicks(); |
|
553 #endif |
|
554 switch(overlay->format) |
|
555 { |
|
556 case SDL_YV12_OVERLAY: |
|
557 ConvertRGBtoYV12(pic,overlay,monochrome,luminance); |
|
558 break; |
|
559 case SDL_UYVY_OVERLAY: |
|
560 ConvertRGBtoUYVY(pic,overlay,monochrome,luminance); |
|
561 break; |
|
562 case SDL_YVYU_OVERLAY: |
|
563 ConvertRGBtoYVYU(pic,overlay,monochrome,luminance); |
|
564 break; |
|
565 case SDL_YUY2_OVERLAY: |
|
566 ConvertRGBtoYUY2(pic,overlay,monochrome,luminance); |
|
567 break; |
|
568 case SDL_IYUV_OVERLAY: |
|
569 ConvertRGBtoIYUV(pic,overlay,monochrome,luminance); |
|
570 break; |
|
571 default: |
|
572 printf("cannot convert RGB picture to obtained YUV format!\n"); |
|
573 quit(1); |
|
574 break; |
|
575 } |
|
576 #ifdef BENCHMARK_SDL |
|
577 now = SDL_GetTicks(); |
|
578 printf("Conversion Time: %d milliseconds\n", now-then); |
|
579 #endif |
|
580 |
|
581 /* Do all the drawing work */ |
|
582 #ifdef BENCHMARK_SDL |
|
583 then = SDL_GetTicks(); |
|
584 #endif |
|
585 Draw(); |
|
586 #ifdef BENCHMARK_SDL |
|
587 now = SDL_GetTicks(); |
|
588 printf("Time: %d milliseconds\n", now-then); |
|
589 #endif |
|
590 SDL_Delay(delay*1000); |
|
591 SDL_Quit(); |
|
592 return(0); |
|
593 } |
|
594 |