test/testoverlay.c

   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