git.sesse.net Git - vlc/blob - plugins/sdl/vout_sdl.c

   1 /*****************************************************************************
   2  * vout_sdl.c: SDL video output display method
   3  *****************************************************************************
   4  * Copyright (C) 1998-2001 VideoLAN
   5  * $Id: vout_sdl.c,v 1.95 2002/06/04 00:11:12 sam Exp $
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *          Pierre Baillet <oct@zoy.org>
   9  *          Arnaud de Bossoreille de Ribou <bozo@via.ecp.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include <errno.h>                                                 /* ENOMEM */
  30 #include <stdlib.h>                                                /* free() */
  31 #include <string.h>                                            /* strerror() */
  32
  33 #include <vlc/vlc.h>
  34 #include <vlc/intf.h>
  35 #include <vlc/vout.h>
  36
  37 #include <sys/types.h>
  38 #ifndef WIN32
  39 #   include <netinet/in.h>                            /* BSD: struct in_addr */
  40 #endif
  41
  42 #include SDL_INCLUDE_FILE
  43
  44 #include "netutils.h"
  45
  46 #define SDL_MAX_DIRECTBUFFERS 10
  47 #define SDL_DEFAULT_BPP 16
  48
  49 /*****************************************************************************
  50  * vout_sys_t: video output SDL method descriptor
  51  *****************************************************************************
  52  * This structure is part of the video output thread descriptor.
  53  * It describes the SDL specific properties of an output thread.
  54  *****************************************************************************/
  55 struct vout_sys_s
  56 {
  57     SDL_Surface *   p_display;                             /* display device */
  58
  59     int i_width;
  60     int i_height;
  61
  62     /* For YUV output */
  63     SDL_Overlay * p_overlay;   /* An overlay we keep to grab the XVideo port */
  64
  65     /* For RGB output */
  66     int i_surfaces;
  67
  68     vlc_bool_t  b_cursor;
  69     vlc_bool_t  b_cursor_autohidden;
  70     mtime_t     i_lastmoved;
  71     mtime_t     i_lastpressed;                        /* to track dbl-clicks */
  72 };
  73
  74 /*****************************************************************************
  75  * picture_sys_t: direct buffer method descriptor
  76  *****************************************************************************
  77  * This structure is part of the picture descriptor, it describes the
  78  * SDL specific properties of a direct buffer.
  79  *****************************************************************************/
  80 struct picture_sys_s
  81 {
  82     SDL_Overlay *p_overlay;
  83 };
  84
  85 /*****************************************************************************
  86  * Local prototypes.
  87  *****************************************************************************/
  88 static int  vout_Create     ( vout_thread_t * );
  89 static int  vout_Init       ( vout_thread_t * );
  90 static void vout_End        ( vout_thread_t * );
  91 static void vout_Destroy    ( vout_thread_t * );
  92 static int  vout_Manage     ( vout_thread_t * );
  93 static void vout_Render     ( vout_thread_t *, picture_t * );
  94 static void vout_Display    ( vout_thread_t *, picture_t * );
  95
  96 static int  OpenDisplay     ( vout_thread_t * );
  97 static void CloseDisplay    ( vout_thread_t * );
  98 static int  NewPicture      ( vout_thread_t *, picture_t * );
  99 static void SetPalette      ( vout_thread_t *, u16 *, u16 *, u16 * );
 100
 101 /*****************************************************************************
 102  * Functions exported as capabilities. They are declared as static so that
 103  * we don't pollute the namespace too much.
 104  *****************************************************************************/
 105 void _M( vout_getfunctions )( function_list_t * p_function_list )
 106 {
 107     p_function_list->functions.vout.pf_create     = vout_Create;
 108     p_function_list->functions.vout.pf_init       = vout_Init;
 109     p_function_list->functions.vout.pf_end        = vout_End;
 110     p_function_list->functions.vout.pf_destroy    = vout_Destroy;
 111     p_function_list->functions.vout.pf_manage     = vout_Manage;
 112     p_function_list->functions.vout.pf_render     = vout_Render;
 113     p_function_list->functions.vout.pf_display    = vout_Display;
 114 }
 115
 116 /*****************************************************************************
 117  * vout_Create: allocate SDL video thread output method
 118  *****************************************************************************
 119  * This function allocate and initialize a SDL vout method. It uses some of the
 120  * vout properties to choose the correct mode, and change them according to the
 121  * mode actually used.
 122  *****************************************************************************/
 123 static int vout_Create( vout_thread_t *p_vout )
 124 {
 125 #ifdef HAVE_SETENV
 126     char *psz_method;
 127 #endif
 128
 129     if( SDL_WasInit( SDL_INIT_VIDEO ) != 0 )
 130     {
 131         return( 1 );
 132     }
 133
 134     /* Allocate structure */
 135     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 136     if( p_vout->p_sys == NULL )
 137     {
 138         msg_Err( p_vout, "out of memory" );
 139         return( 1 );
 140     }
 141
 142 #ifdef HAVE_SETENV
 143     psz_method = config_GetPsz( p_vout, "vout" );
 144     if( psz_method )
 145     {
 146         while( *psz_method && *psz_method != ':' )
 147         {
 148             psz_method++;
 149         }
 150
 151         if( *psz_method )
 152         {
 153             setenv( "SDL_VIDEODRIVER", psz_method + 1, 1 );
 154         }
 155     }
 156 #endif
 157
 158     /* Initialize library */
 159     if( SDL_Init( SDL_INIT_VIDEO
 160 #ifndef WIN32
 161     /* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
 162                 | SDL_INIT_EVENTTHREAD
 163 #endif
 164 #ifdef DEBUG
 165     /* In debug mode you may want vlc to dump a core instead of staying
 166      * stuck */
 167                 | SDL_INIT_NOPARACHUTE
 168 #endif
 169                 ) < 0 )
 170     {
 171         msg_Err( p_vout, "cannot initialize SDL (%s)", SDL_GetError() );
 172         free( p_vout->p_sys );
 173         return( 1 );
 174     }
 175
 176     p_vout->p_sys->b_cursor = 1;
 177     p_vout->p_sys->b_cursor_autohidden = 0;
 178     p_vout->p_sys->i_lastmoved = mdate();
 179
 180     if( OpenDisplay( p_vout ) )
 181     {
 182         msg_Err( p_vout, "cannot set up SDL (%s)", SDL_GetError() );
 183         SDL_QuitSubSystem( SDL_INIT_VIDEO );
 184         free( p_vout->p_sys );
 185         return( 1 );
 186     }
 187
 188     return( 0 );
 189 }
 190
 191 /*****************************************************************************
 192  * vout_Init: initialize SDL video thread output method
 193  *****************************************************************************
 194  * This function initialize the SDL display device.
 195  *****************************************************************************/
 196 static int vout_Init( vout_thread_t *p_vout )
 197 {
 198     int i_index;
 199     picture_t *p_pic;
 200
 201     p_vout->p_sys->i_surfaces = 0;
 202
 203     I_OUTPUTPICTURES = 0;
 204
 205     /* Initialize the output structure */
 206     if( p_vout->p_sys->p_overlay == NULL )
 207     {
 208         /* All we have is an RGB image with square pixels */
 209         p_vout->output.i_width  = p_vout->p_sys->i_width;
 210         p_vout->output.i_height = p_vout->p_sys->i_height;
 211         p_vout->output.i_aspect = p_vout->output.i_width
 212                                    * VOUT_ASPECT_FACTOR
 213                                    / p_vout->output.i_height;
 214     }
 215     else
 216     {
 217         /* We may need to convert the chroma, but at least we keep the
 218          * aspect ratio */
 219         p_vout->output.i_width  = p_vout->render.i_width;
 220         p_vout->output.i_height = p_vout->render.i_height;
 221         p_vout->output.i_aspect = p_vout->render.i_aspect;
 222     }
 223
 224     /* Try to initialize SDL_MAX_DIRECTBUFFERS direct buffers */
 225     while( I_OUTPUTPICTURES < SDL_MAX_DIRECTBUFFERS )
 226     {
 227         p_pic = NULL;
 228
 229         /* Find an empty picture slot */
 230         for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
 231         {
 232             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
 233             {
 234                 p_pic = p_vout->p_picture + i_index;
 235                 break;
 236             }
 237         }
 238
 239         /* Allocate the picture if we found one */
 240         if( p_pic == NULL || NewPicture( p_vout, p_pic ) )
 241         {
 242             break;
 243         }
 244
 245         p_pic->i_status = DESTROYED_PICTURE;
 246         p_pic->i_type   = DIRECT_PICTURE;
 247
 248         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
 249
 250         I_OUTPUTPICTURES++;
 251     }
 252
 253     return( 0 );
 254 }
 255
 256 /*****************************************************************************
 257  * vout_End: terminate Sys video thread output method
 258  *****************************************************************************
 259  * Terminate an output method created by vout_SDLCreate
 260  *****************************************************************************/
 261 static void vout_End( vout_thread_t *p_vout )
 262 {
 263     int i_index;
 264
 265     /* Free the output buffers we allocated */
 266     for( i_index = I_OUTPUTPICTURES ; i_index ; )
 267     {
 268         i_index--;
 269         if( p_vout->p_sys->p_overlay == NULL )
 270         {
 271             /* RGB picture */
 272         }
 273         else
 274         {
 275             SDL_UnlockYUVOverlay(
 276                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 277             SDL_FreeYUVOverlay(
 278                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 279         }
 280         free( PP_OUTPUTPICTURE[ i_index ]->p_sys );
 281     }
 282 }
 283
 284 /*****************************************************************************
 285  * vout_Destroy: destroy Sys video thread output method
 286  *****************************************************************************
 287  * Terminate an output method created by vout_SDLCreate
 288  *****************************************************************************/
 289 static void vout_Destroy( vout_thread_t *p_vout )
 290 {
 291     CloseDisplay( p_vout );
 292
 293     SDL_QuitSubSystem( SDL_INIT_VIDEO );
 294
 295     free( p_vout->p_sys );
 296 }
 297
 298 /*****************************************************************************
 299  * vout_Manage: handle Sys events
 300  *****************************************************************************
 301  * This function should be called regularly by video output thread. It returns
 302  * a non null value if an error occured.
 303  *****************************************************************************/
 304 static int vout_Manage( vout_thread_t *p_vout )
 305 {
 306     SDL_Event event;                                            /* SDL event */
 307
 308     /* Process events */
 309     while( SDL_PollEvent(&event) )
 310     {
 311         switch( event.type )
 312         {
 313         case SDL_VIDEORESIZE:                          /* Resizing of window */
 314             /* Update dimensions */
 315             p_vout->i_changes |= VOUT_SIZE_CHANGE;
 316             p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
 317             p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
 318             break;
 319
 320         case SDL_MOUSEMOTION:
 321             if( p_vout->p_sys->b_cursor &&
 322                 (abs(event.motion.xrel) > 2 || abs(event.motion.yrel) > 2) )
 323             {
 324                 if( p_vout->p_sys->b_cursor_autohidden )
 325                 {
 326                     p_vout->p_sys->b_cursor_autohidden = 0;
 327                     SDL_ShowCursor( 1 );
 328                 }
 329                 else
 330                 {
 331                     p_vout->p_sys->i_lastmoved = mdate();
 332                 }
 333             }
 334             break;
 335
 336         case SDL_MOUSEBUTTONUP:
 337             switch( event.button.button )
 338             {
 339             case SDL_BUTTON_RIGHT:
 340                 {
 341                     intf_thread_t *p_intf;
 342                     p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
 343                                                       FIND_ANYWHERE );
 344                     if( p_intf )
 345                     {
 346                         p_intf->b_menu_change = 1;
 347                         vlc_object_release( p_intf );
 348                     }
 349                 }
 350                 break;
 351             }
 352             break;
 353
 354         case SDL_MOUSEBUTTONDOWN:
 355             switch( event.button.button )
 356             {
 357             case SDL_BUTTON_LEFT:
 358                 /* In this part we will eventually manage
 359                  * clicks for DVD navigation for instance. */
 360
 361                 /* detect double-clicks */
 362                 if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
 363                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 364
 365                 p_vout->p_sys->i_lastpressed = mdate();
 366                 break;
 367
 368             case 4:
 369                 input_Seek( p_vout, 15, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 370                 break;
 371
 372             case 5:
 373                 input_Seek( p_vout, -15, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 374                 break;
 375             }
 376             break;
 377
 378         case SDL_QUIT:
 379             p_vout->p_vlc->b_die = 1;
 380             break;
 381
 382         case SDL_KEYDOWN:                             /* if a key is pressed */
 383
 384             switch( event.key.keysym.sym )
 385             {
 386             case SDLK_ESCAPE:
 387                 if( p_vout->b_fullscreen )
 388                 {
 389                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 390                 }
 391                 else
 392                 {
 393                     p_vout->p_vlc->b_die = 1;
 394                 }
 395                 break;
 396
 397             case SDLK_q:                                             /* quit */
 398                 p_vout->p_vlc->b_die = 1;
 399                 break;
 400
 401             case SDLK_f:                             /* switch to fullscreen */
 402                 p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 403                 break;
 404
 405             case SDLK_c:                                 /* toggle grayscale */
 406                 p_vout->b_grayscale = ! p_vout->b_grayscale;
 407                 p_vout->i_changes |= VOUT_GRAYSCALE_CHANGE;
 408                 break;
 409
 410             case SDLK_i:                                      /* toggle info */
 411                 p_vout->b_info = ! p_vout->b_info;
 412                 p_vout->i_changes |= VOUT_INFO_CHANGE;
 413                 break;
 414
 415             case SDLK_s:                                   /* toggle scaling */
 416                 p_vout->b_scale = ! p_vout->b_scale;
 417                 p_vout->i_changes |= VOUT_SCALE_CHANGE;
 418                 break;
 419
 420             case SDLK_SPACE:                             /* toggle interface */
 421                 p_vout->b_interface = ! p_vout->b_interface;
 422                 p_vout->i_changes |= VOUT_INTF_CHANGE;
 423                 break;
 424
 425             case SDLK_MENU:
 426                 {
 427                     intf_thread_t *p_intf;
 428                     p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
 429                                                       FIND_ANYWHERE );
 430                     if( p_intf )
 431                     {
 432                         p_intf->b_menu_change = 1;
 433                         vlc_object_release( p_intf );
 434                     }
 435                 }
 436                 break;
 437
 438             case SDLK_LEFT:
 439                 input_Seek( p_vout, -5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 440                 break;
 441
 442             case SDLK_RIGHT:
 443                 input_Seek( p_vout, 5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 444                 break;
 445
 446             case SDLK_UP:
 447                 input_Seek( p_vout, 60, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 448                 break;
 449
 450             case SDLK_DOWN:
 451                 input_Seek( p_vout, -60, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 452                 break;
 453
 454             case SDLK_F1: network_ChannelJoin( p_vout, 1 ); break;
 455             case SDLK_F2: network_ChannelJoin( p_vout, 2 ); break;
 456             case SDLK_F3: network_ChannelJoin( p_vout, 3 ); break;
 457             case SDLK_F4: network_ChannelJoin( p_vout, 4 ); break;
 458             case SDLK_F5: network_ChannelJoin( p_vout, 5 ); break;
 459             case SDLK_F6: network_ChannelJoin( p_vout, 6 ); break;
 460             case SDLK_F7: network_ChannelJoin( p_vout, 7 ); break;
 461             case SDLK_F8: network_ChannelJoin( p_vout, 8 ); break;
 462             case SDLK_F9: network_ChannelJoin( p_vout, 9 ); break;
 463             case SDLK_F10: network_ChannelJoin( p_vout, 10 ); break;
 464             case SDLK_F11: network_ChannelJoin( p_vout, 11 ); break;
 465             case SDLK_F12: network_ChannelJoin( p_vout, 12 ); break;
 466
 467             default:
 468                 break;
 469             }
 470             break;
 471
 472         default:
 473             break;
 474         }
 475     }
 476
 477     /* Fullscreen change */
 478     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
 479     {
 480         p_vout->b_fullscreen = ! p_vout->b_fullscreen;
 481
 482         p_vout->p_sys->b_cursor_autohidden = 0;
 483         SDL_ShowCursor( p_vout->p_sys->b_cursor &&
 484                         ! p_vout->p_sys->b_cursor_autohidden );
 485
 486         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 487         p_vout->i_changes |= VOUT_SIZE_CHANGE;
 488     }
 489
 490     /*
 491      * Size change
 492      */
 493     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
 494     {
 495         msg_Dbg( p_vout, "video display resized (%dx%d)",
 496                  p_vout->p_sys->i_width, p_vout->p_sys->i_height );
 497
 498         CloseDisplay( p_vout );
 499         OpenDisplay( p_vout );
 500
 501         /* We don't need to signal the vout thread about the size change if
 502          * we can handle rescaling ourselves */
 503         if( p_vout->p_sys->p_overlay != NULL )
 504             p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
 505
 506     }
 507
 508     /* Pointer change */
 509     if( ! p_vout->p_sys->b_cursor_autohidden &&
 510         ( mdate() - p_vout->p_sys->i_lastmoved > 2000000 ) )
 511     {
 512         /* Hide the mouse automatically */
 513         p_vout->p_sys->b_cursor_autohidden = 1;
 514         SDL_ShowCursor( 0 );
 515     }
 516
 517     return( 0 );
 518 }
 519
 520 /*****************************************************************************
 521  * vout_Render: render previously calculated output
 522  *****************************************************************************/
 523 static void vout_Render( vout_thread_t *p_vout, picture_t *p_pic )
 524 {
 525     ;
 526 }
 527
 528 /*****************************************************************************
 529  * vout_Display: displays previously rendered output
 530  *****************************************************************************
 531  * This function sends the currently rendered image to the display.
 532  *****************************************************************************/
 533 static void vout_Display( vout_thread_t *p_vout, picture_t *p_pic )
 534 {
 535     int x, y, w, h;
 536     SDL_Rect disp;
 537
 538     vout_PlacePicture( p_vout, p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 539                        &x, &y, &w, &h );
 540     disp.x = x;
 541     disp.y = y;
 542     disp.w = w;
 543     disp.h = h;
 544
 545     if( p_vout->p_sys->p_overlay == NULL )
 546     {
 547         /* RGB picture */
 548         SDL_Flip( p_vout->p_sys->p_display );
 549     }
 550     else
 551     {
 552         /* Overlay picture */
 553         SDL_UnlockYUVOverlay( p_pic->p_sys->p_overlay);
 554         SDL_DisplayYUVOverlay( p_pic->p_sys->p_overlay , &disp );
 555         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay);
 556     }
 557 }
 558
 559 /* following functions are local */
 560
 561 /*****************************************************************************
 562  * OpenDisplay: open and initialize SDL device
 563  *****************************************************************************
 564  * Open and initialize display according to preferences specified in the vout
 565  * thread fields.
 566  *****************************************************************************/
 567 static int OpenDisplay( vout_thread_t *p_vout )
 568 {
 569     Uint32 i_flags;
 570     int    i_bpp;
 571
 572     /* Set main window's size */
 573     p_vout->p_sys->i_width = p_vout->b_fullscreen ? p_vout->output.i_width :
 574                                                     p_vout->i_window_width;
 575     p_vout->p_sys->i_height = p_vout->b_fullscreen ? p_vout->output.i_height :
 576                                                      p_vout->i_window_height;
 577
 578     /* Initialize flags and cursor */
 579     i_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
 580     i_flags |= p_vout->b_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
 581
 582     i_bpp = SDL_VideoModeOK( p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 583                              SDL_DEFAULT_BPP, i_flags );
 584     if( i_bpp == 0 )
 585     {
 586         msg_Err( p_vout, "no video mode available" );
 587         return( 1 );
 588     }
 589
 590     p_vout->p_sys->p_display = SDL_SetVideoMode( p_vout->p_sys->i_width,
 591                                                  p_vout->p_sys->i_height,
 592                                                  i_bpp, i_flags );
 593
 594     if( p_vout->p_sys->p_display == NULL )
 595     {
 596         msg_Err( p_vout, "cannot set video mode" );
 597         return( 1 );
 598     }
 599
 600     SDL_LockSurface( p_vout->p_sys->p_display );
 601
 602     /* Choose the chroma we will try first. */
 603     switch( p_vout->render.i_chroma )
 604     {
 605         case FOURCC_YUY2:
 606         case FOURCC_YUNV:
 607             p_vout->output.i_chroma = SDL_YUY2_OVERLAY;
 608             break;
 609         case FOURCC_UYVY:
 610         case FOURCC_UYNV:
 611         case FOURCC_Y422:
 612             p_vout->output.i_chroma = SDL_UYVY_OVERLAY;
 613             break;
 614         case FOURCC_YVYU:
 615             p_vout->output.i_chroma = SDL_YVYU_OVERLAY;
 616             break;
 617         case FOURCC_YV12:
 618         case FOURCC_I420:
 619         case FOURCC_IYUV:
 620         default:
 621             p_vout->output.i_chroma = SDL_YV12_OVERLAY;
 622             break;
 623     }
 624
 625     p_vout->p_sys->p_overlay =
 626         SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 627                               p_vout->p_sys->p_display );
 628     /* FIXME: if the first overlay we find is software, don't stop,
 629      * because we may find a hardware one later ... */
 630
 631     /* If this best choice failed, fall back to other chromas */
 632     if( p_vout->p_sys->p_overlay == NULL )
 633     {
 634         p_vout->output.i_chroma = SDL_IYUV_OVERLAY;
 635         p_vout->p_sys->p_overlay =
 636             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 637                                   p_vout->p_sys->p_display );
 638     }
 639
 640     if( p_vout->p_sys->p_overlay == NULL )
 641     {
 642         p_vout->output.i_chroma = SDL_YV12_OVERLAY;
 643         p_vout->p_sys->p_overlay =
 644             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 645                                   p_vout->p_sys->p_display );
 646     }
 647
 648     if( p_vout->p_sys->p_overlay == NULL )
 649     {
 650         p_vout->output.i_chroma = SDL_YUY2_OVERLAY;
 651         p_vout->p_sys->p_overlay =
 652             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 653                                   p_vout->p_sys->p_display );
 654     }
 655
 656     if( p_vout->p_sys->p_overlay == NULL )
 657     {
 658         msg_Warn( p_vout, "no SDL overlay for 0x%.8x (%4.4s)",
 659                   p_vout->render.i_chroma, (char*)&p_vout->render.i_chroma );
 660
 661         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 662         {
 663             case 8:
 664                 p_vout->output.i_chroma = FOURCC_RGB2;
 665                 p_vout->output.pf_setpalette = SetPalette;
 666                 break;
 667             case 15:
 668                 p_vout->output.i_chroma = FOURCC_RV15;
 669                 break;
 670             case 16:
 671                 p_vout->output.i_chroma = FOURCC_RV16;
 672                 break;
 673             case 24:
 674                 p_vout->output.i_chroma = FOURCC_RV24;
 675                 break;
 676             case 32:
 677                 p_vout->output.i_chroma = FOURCC_RV32;
 678                 break;
 679             default:
 680                 msg_Err( p_vout, "unknown screen depth %i",
 681                          p_vout->p_sys->p_display->format->BitsPerPixel );
 682                 SDL_UnlockSurface( p_vout->p_sys->p_display );
 683                 SDL_FreeSurface( p_vout->p_sys->p_display );
 684                 return( -1 );
 685         }
 686
 687         p_vout->output.i_rmask = p_vout->p_sys->p_display->format->Rmask;
 688         p_vout->output.i_gmask = p_vout->p_sys->p_display->format->Gmask;
 689         p_vout->output.i_bmask = p_vout->p_sys->p_display->format->Bmask;
 690
 691         SDL_WM_SetCaption( VOUT_TITLE " (software RGB SDL output)",
 692                            VOUT_TITLE " (software RGB SDL output)" );
 693     }
 694     else
 695     {
 696         if( p_vout->p_sys->p_overlay->hw_overlay )
 697         {
 698             SDL_WM_SetCaption( VOUT_TITLE " (hardware YUV SDL output)",
 699                                VOUT_TITLE " (hardware YUV SDL output)" );
 700         }
 701         else
 702         {
 703             SDL_WM_SetCaption( VOUT_TITLE " (software YUV SDL output)",
 704                                VOUT_TITLE " (software YUV SDL output)" );
 705         }
 706     }
 707
 708     SDL_EventState( SDL_KEYUP, SDL_IGNORE );               /* ignore keys up */
 709
 710     return( 0 );
 711 }
 712
 713 /*****************************************************************************
 714  * CloseDisplay: close and reset SDL device
 715  *****************************************************************************
 716  * This function returns all resources allocated by OpenDisplay and restore
 717  * the original state of the device.
 718  *****************************************************************************/
 719 static void CloseDisplay( vout_thread_t *p_vout )
 720 {
 721     SDL_FreeYUVOverlay( p_vout->p_sys->p_overlay );
 722     SDL_UnlockSurface ( p_vout->p_sys->p_display );
 723     SDL_FreeSurface( p_vout->p_sys->p_display );
 724 }
 725
 726 /*****************************************************************************
 727  * NewPicture: allocate a picture
 728  *****************************************************************************
 729  * Returns 0 on success, -1 otherwise
 730  *****************************************************************************/
 731 static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic )
 732 {
 733     int i_width  = p_vout->output.i_width;
 734     int i_height = p_vout->output.i_height;
 735
 736     if( p_vout->p_sys->p_overlay == NULL )
 737     {
 738         /* RGB picture */
 739         if( p_vout->p_sys->i_surfaces )
 740         {
 741             /* We already allocated this surface, return */
 742             return -1;
 743         }
 744
 745         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 746
 747         if( p_pic->p_sys == NULL )
 748         {
 749             return -1;
 750         }
 751
 752         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 753         {
 754             case 8:
 755                 p_pic->p->i_pixel_bytes = 1;
 756                 break;
 757             case 15:
 758             case 16:
 759                 p_pic->p->i_pixel_bytes = 2;
 760                 break;
 761             case 24:
 762             case 32:
 763                 p_pic->p->i_pixel_bytes = 4;
 764                 break;
 765             default:
 766                 return( -1 );
 767         }
 768
 769         p_pic->p->p_pixels = p_vout->p_sys->p_display->pixels;
 770         p_pic->p->i_lines = p_vout->p_sys->p_display->h;
 771         p_pic->p->i_pitch = p_vout->p_sys->p_display->pitch;
 772
 773         if( p_pic->p->i_pitch ==
 774                 p_pic->p->i_pixel_bytes * p_vout->p_sys->p_display->w )
 775         {
 776             p_pic->p->b_margin = 0;
 777         }
 778         else
 779         {
 780             p_pic->p->b_margin = 1;
 781             p_pic->p->b_hidden = 1;
 782             p_pic->p->i_visible_bytes =
 783                 p_pic->p->i_pixel_bytes * p_vout->p_sys->p_display->w;
 784         }
 785
 786         p_vout->p_sys->i_surfaces++;
 787
 788         p_pic->i_planes = 1;
 789     }
 790     else
 791     {
 792         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 793
 794         if( p_pic->p_sys == NULL )
 795         {
 796             return -1;
 797         }
 798
 799         p_pic->p_sys->p_overlay =
 800             SDL_CreateYUVOverlay( i_width, i_height,
 801                                   p_vout->output.i_chroma,
 802                                   p_vout->p_sys->p_display );
 803
 804         if( p_pic->p_sys->p_overlay == NULL )
 805         {
 806             free( p_pic->p_sys );
 807             return -1;
 808         }
 809
 810         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay );
 811
 812         p_pic->Y_PIXELS = p_pic->p_sys->p_overlay->pixels[0];
 813         p_pic->p[Y_PLANE].i_lines = p_pic->p_sys->p_overlay->h;
 814         p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[0];
 815
 816         switch( p_vout->output.i_chroma )
 817         {
 818         case SDL_YV12_OVERLAY:
 819             p_pic->p[Y_PLANE].i_pixel_bytes = 1;
 820             p_pic->p[Y_PLANE].b_margin = 0;
 821
 822             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
 823             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 824             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
 825             p_pic->p[U_PLANE].i_pixel_bytes = 1;
 826             p_pic->p[U_PLANE].b_margin = 0;
 827
 828             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
 829             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 830             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
 831             p_pic->p[V_PLANE].i_pixel_bytes = 1;
 832             p_pic->p[V_PLANE].b_margin = 0;
 833
 834             p_pic->i_planes = 3;
 835             break;
 836
 837         case SDL_IYUV_OVERLAY:
 838             p_pic->p[Y_PLANE].i_pixel_bytes = 1;
 839             p_pic->p[Y_PLANE].b_margin = 0;
 840
 841             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
 842             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 843             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
 844             p_pic->p[U_PLANE].i_pixel_bytes = 1;
 845             p_pic->p[U_PLANE].b_margin = 0;
 846
 847             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
 848             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 849             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
 850             p_pic->p[V_PLANE].i_pixel_bytes = 1;
 851             p_pic->p[V_PLANE].b_margin = 0;
 852
 853             p_pic->i_planes = 3;
 854             break;
 855
 856         default:
 857             p_pic->p[Y_PLANE].i_pixel_bytes = 2;
 858             p_pic->p[Y_PLANE].b_margin = 0;
 859
 860             p_pic->i_planes = 1;
 861             break;
 862         }
 863     }
 864
 865     return 0;
 866 }
 867
 868 /*****************************************************************************
 869  * SetPalette: sets an 8 bpp palette
 870  *****************************************************************************/
 871 static void SetPalette( vout_thread_t *p_vout, u16 *red, u16 *green, u16 *blue )
 872 {
 873     SDL_Color colors[256];
 874     int i;
 875
 876     /* Fill colors with color information */
 877     for( i = 0; i < 256; i++ )
 878     {
 879         colors[ i ].r = red[ i ] >> 8;
 880         colors[ i ].g = green[ i ] >> 8;
 881         colors[ i ].b = blue[ i ] >> 8;
 882     }
 883
 884     /* Set palette */
 885     if( SDL_SetColors( p_vout->p_sys->p_display, colors, 0, 256 ) == 0 )
 886     {
 887         msg_Err( p_vout, "failed setting palette" );
 888     }
 889 }
 890