don't kill hints on minimize
[sdl_omap.git] / test / testoverlay.c
... / ...
CommitLineData
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
17SDL_Surface *screen, *pic;
18SDL_Overlay *overlay;
19int scale;
20int monochrome;
21int luminance;
22int w, h;
23
24/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
25static 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
35void 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
81void 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
121void 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
161void 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
194void 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
230void 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
266void 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
302static 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
321int 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