git.sesse.net Git - vlc/blob - modules/video_output/sdl.c

   1 /*****************************************************************************
   2  * sdl.c: SDL video output display method
   3  *****************************************************************************
   4  * Copyright (C) 1998-2001 VideoLAN
   5  * $Id: sdl.c,v 1.7 2003/01/13 13:28:55 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_t
  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_t
  81 {
  82     SDL_Overlay *p_overlay;
  83 };
  84
  85 /*****************************************************************************
  86  * Local prototypes
  87  *****************************************************************************/
  88 static int  Open      ( vlc_object_t * );
  89 static void Close     ( vlc_object_t * );
  90 static int  Init      ( vout_thread_t * );
  91 static void End       ( vout_thread_t * );
  92 static int  Manage    ( vout_thread_t * );
  93 static void Display   ( vout_thread_t *, picture_t * );
  94
  95 static int  OpenDisplay     ( vout_thread_t * );
  96 static void CloseDisplay    ( vout_thread_t * );
  97 static int  NewPicture      ( vout_thread_t *, picture_t * );
  98 static void SetPalette      ( vout_thread_t *,
  99                               uint16_t *, uint16_t *, uint16_t * );
 100
 101 /*****************************************************************************
 102  * Module descriptor
 103  *****************************************************************************/
 104 vlc_module_begin();
 105     set_description( _("Simple DirectMedia Layer video module") );
 106     set_capability( "video output", 60 );
 107     add_shortcut( "sdl" );
 108     set_callbacks( Open, Close );
 109     /* XXX: check for conflicts with the SDL audio output */
 110     var_Create( p_module->p_libvlc, "sdl", VLC_VAR_MUTEX );
 111 vlc_module_end();
 112
 113 /*****************************************************************************
 114  * OpenVideo: allocate SDL video thread output method
 115  *****************************************************************************
 116  * This function allocate and initialize a SDL vout method. It uses some of the
 117  * vout properties to choose the correct mode, and change them according to the
 118  * mode actually used.
 119  *****************************************************************************/
 120 static int Open ( vlc_object_t *p_this )
 121 {
 122     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 123     vlc_value_t lockval;
 124
 125 #ifdef HAVE_SETENV
 126     char *psz_method;
 127 #endif
 128
 129     var_Get( p_this->p_libvlc, "sdl", &lockval );
 130     vlc_mutex_lock( lockval.p_address );
 131
 132     if( SDL_WasInit( SDL_INIT_VIDEO ) != 0 )
 133     {
 134         vlc_mutex_unlock( lockval.p_address );
 135         return VLC_EGENERIC;
 136     }
 137
 138     /* Allocate structure */
 139     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 140     if( p_vout->p_sys == NULL )
 141     {
 142         msg_Err( p_vout, "out of memory" );
 143         vlc_mutex_unlock( lockval.p_address );
 144         return VLC_ENOMEM;
 145     }
 146
 147     p_vout->pf_init = Init;
 148     p_vout->pf_end = End;
 149     p_vout->pf_manage = Manage;
 150     p_vout->pf_render = NULL;
 151     p_vout->pf_display = Display;
 152
 153 #ifdef HAVE_SETENV
 154     psz_method = config_GetPsz( p_vout, "vout" );
 155     if( psz_method )
 156     {
 157         while( *psz_method && *psz_method != ':' )
 158         {
 159             psz_method++;
 160         }
 161
 162         if( *psz_method )
 163         {
 164             setenv( "SDL_VIDEODRIVER", psz_method + 1, 1 );
 165         }
 166     }
 167 #endif
 168
 169     /* Initialize library */
 170     if( SDL_Init( SDL_INIT_VIDEO
 171 #ifndef WIN32
 172     /* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
 173                 | SDL_INIT_EVENTTHREAD
 174 #endif
 175 #ifdef DEBUG
 176     /* In debug mode you may want vlc to dump a core instead of staying
 177      * stuck */
 178                 | SDL_INIT_NOPARACHUTE
 179 #endif
 180                 ) < 0 )
 181     {
 182         msg_Err( p_vout, "cannot initialize SDL (%s)", SDL_GetError() );
 183         free( p_vout->p_sys );
 184         vlc_mutex_unlock( lockval.p_address );
 185         return VLC_EGENERIC;
 186     }
 187
 188     vlc_mutex_unlock( lockval.p_address );
 189
 190     p_vout->p_sys->b_cursor = 1;
 191     p_vout->p_sys->b_cursor_autohidden = 0;
 192     p_vout->p_sys->i_lastmoved = mdate();
 193
 194     if( OpenDisplay( p_vout ) )
 195     {
 196         msg_Err( p_vout, "cannot set up SDL (%s)", SDL_GetError() );
 197         SDL_QuitSubSystem( SDL_INIT_VIDEO );
 198         free( p_vout->p_sys );
 199         return( 1 );
 200     }
 201
 202     return( 0 );
 203 }
 204
 205 /*****************************************************************************
 206  * Init: initialize SDL video thread output method
 207  *****************************************************************************
 208  * This function initialize the SDL display device.
 209  *****************************************************************************/
 210 static int Init( vout_thread_t *p_vout )
 211 {
 212     int i_index;
 213     picture_t *p_pic;
 214
 215     p_vout->p_sys->i_surfaces = 0;
 216
 217     I_OUTPUTPICTURES = 0;
 218
 219     /* Initialize the output structure */
 220     if( p_vout->p_sys->p_overlay == NULL )
 221     {
 222         /* All we have is an RGB image with square pixels */
 223         p_vout->output.i_width  = p_vout->p_sys->i_width;
 224         p_vout->output.i_height = p_vout->p_sys->i_height;
 225         p_vout->output.i_aspect = p_vout->output.i_width
 226                                    * VOUT_ASPECT_FACTOR
 227                                    / p_vout->output.i_height;
 228     }
 229     else
 230     {
 231         /* We may need to convert the chroma, but at least we keep the
 232          * aspect ratio */
 233         p_vout->output.i_width  = p_vout->render.i_width;
 234         p_vout->output.i_height = p_vout->render.i_height;
 235         p_vout->output.i_aspect = p_vout->render.i_aspect;
 236     }
 237
 238     /* Try to initialize SDL_MAX_DIRECTBUFFERS direct buffers */
 239     while( I_OUTPUTPICTURES < SDL_MAX_DIRECTBUFFERS )
 240     {
 241         p_pic = NULL;
 242
 243         /* Find an empty picture slot */
 244         for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
 245         {
 246             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
 247             {
 248                 p_pic = p_vout->p_picture + i_index;
 249                 break;
 250             }
 251         }
 252
 253         /* Allocate the picture if we found one */
 254         if( p_pic == NULL || NewPicture( p_vout, p_pic ) )
 255         {
 256             break;
 257         }
 258
 259         p_pic->i_status = DESTROYED_PICTURE;
 260         p_pic->i_type   = DIRECT_PICTURE;
 261
 262         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
 263
 264         I_OUTPUTPICTURES++;
 265     }
 266
 267     return( 0 );
 268 }
 269
 270 /*****************************************************************************
 271  * End: terminate Sys video thread output method
 272  *****************************************************************************
 273  * Terminate an output method created by OpenVideo
 274  *****************************************************************************/
 275 static void End( vout_thread_t *p_vout )
 276 {
 277     int i_index;
 278
 279     /* Free the output buffers we allocated */
 280     for( i_index = I_OUTPUTPICTURES ; i_index ; )
 281     {
 282         i_index--;
 283         if( p_vout->p_sys->p_overlay == NULL )
 284         {
 285             /* RGB picture */
 286         }
 287         else
 288         {
 289             SDL_UnlockYUVOverlay(
 290                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 291             SDL_FreeYUVOverlay(
 292                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 293         }
 294         free( PP_OUTPUTPICTURE[ i_index ]->p_sys );
 295     }
 296 }
 297
 298 /*****************************************************************************
 299  * CloseVideo: destroy Sys video thread output method
 300  *****************************************************************************
 301  * Terminate an output method created by vout_SDLCreate
 302  *****************************************************************************/
 303 static void Close ( vlc_object_t *p_this )
 304 {
 305     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 306
 307     CloseDisplay( p_vout );
 308     SDL_QuitSubSystem( SDL_INIT_VIDEO );
 309
 310     free( p_vout->p_sys );
 311 }
 312
 313 /*****************************************************************************
 314  * Manage: handle Sys events
 315  *****************************************************************************
 316  * This function should be called regularly by video output thread. It returns
 317  * a non null value if an error occured.
 318  *****************************************************************************/
 319 static int Manage( vout_thread_t *p_vout )
 320 {
 321     SDL_Event event;                                            /* SDL event */
 322     vlc_value_t val;
 323     int i_width, i_height, i_x, i_y;
 324
 325     /* Process events */
 326     while( SDL_PollEvent(&event) )
 327     {
 328         switch( event.type )
 329         {
 330         case SDL_VIDEORESIZE:                          /* Resizing of window */
 331             /* Update dimensions */
 332             p_vout->i_changes |= VOUT_SIZE_CHANGE;
 333             p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
 334             p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
 335             break;
 336
 337         case SDL_MOUSEMOTION:
 338             vout_PlacePicture( p_vout, p_vout->p_sys->i_width,
 339                                p_vout->p_sys->i_height,
 340                                &i_x, &i_y, &i_width, &i_height );
 341
 342             val.i_int = ( event.motion.x - i_x )
 343                          * p_vout->render.i_width / i_width;
 344             var_Set( p_vout, "mouse-x", val );
 345             val.i_int = ( event.motion.y - i_y )
 346                          * p_vout->render.i_height / i_height;
 347             var_Set( p_vout, "mouse-y", val );
 348
 349             val.b_bool = VLC_TRUE;
 350             var_Set( p_vout, "mouse-moved", val );
 351
 352             if( p_vout->p_sys->b_cursor &&
 353                 (abs(event.motion.xrel) > 2 || abs(event.motion.yrel) > 2) )
 354             {
 355                 if( p_vout->p_sys->b_cursor_autohidden )
 356                 {
 357                     p_vout->p_sys->b_cursor_autohidden = 0;
 358                     SDL_ShowCursor( 1 );
 359                 }
 360                 else
 361                 {
 362                     p_vout->p_sys->i_lastmoved = mdate();
 363                 }
 364             }
 365             break;
 366
 367         case SDL_MOUSEBUTTONUP:
 368             switch( event.button.button )
 369             {
 370             case SDL_BUTTON_LEFT:
 371                 val.b_bool = VLC_TRUE;
 372                 var_Set( p_vout, "mouse-clicked", val );
 373                 break;
 374
 375             case SDL_BUTTON_RIGHT:
 376                 {
 377                     intf_thread_t *p_intf;
 378                     p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
 379                                                       FIND_ANYWHERE );
 380                     if( p_intf )
 381                     {
 382                         p_intf->b_menu_change = 1;
 383                         vlc_object_release( p_intf );
 384                     }
 385                 }
 386                 break;
 387             }
 388             break;
 389
 390         case SDL_MOUSEBUTTONDOWN:
 391             switch( event.button.button )
 392             {
 393             case SDL_BUTTON_LEFT:
 394                 /* In this part we will eventually manage
 395                  * clicks for DVD navigation for instance. */
 396
 397                 /* detect double-clicks */
 398                 if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
 399                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 400
 401                 p_vout->p_sys->i_lastpressed = mdate();
 402                 break;
 403
 404             case 4:
 405                 input_Seek( p_vout, 15, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 406                 break;
 407
 408             case 5:
 409                 input_Seek( p_vout, -15, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 410                 break;
 411             }
 412             break;
 413
 414         case SDL_QUIT:
 415             p_vout->p_vlc->b_die = 1;
 416             break;
 417
 418         case SDL_KEYDOWN:                             /* if a key is pressed */
 419
 420             switch( event.key.keysym.sym )
 421             {
 422             case SDLK_ESCAPE:
 423                 if( p_vout->b_fullscreen )
 424                 {
 425                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 426                 }
 427                 else
 428                 {
 429                     p_vout->p_vlc->b_die = 1;
 430                 }
 431                 break;
 432
 433             case SDLK_q:                                             /* quit */
 434                 p_vout->p_vlc->b_die = 1;
 435                 break;
 436
 437             case SDLK_f:                             /* switch to fullscreen */
 438                 p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 439                 break;
 440
 441             case SDLK_c:                                 /* toggle grayscale */
 442                 p_vout->b_grayscale = ! p_vout->b_grayscale;
 443                 p_vout->i_changes |= VOUT_GRAYSCALE_CHANGE;
 444                 break;
 445
 446             case SDLK_i:                                      /* toggle info */
 447                 p_vout->b_info = ! p_vout->b_info;
 448                 p_vout->i_changes |= VOUT_INFO_CHANGE;
 449                 break;
 450
 451             case SDLK_s:                                   /* toggle scaling */
 452                 p_vout->b_scale = ! p_vout->b_scale;
 453                 p_vout->i_changes |= VOUT_SCALE_CHANGE;
 454                 break;
 455
 456             case SDLK_SPACE:                             /* toggle interface */
 457                 p_vout->b_interface = ! p_vout->b_interface;
 458                 p_vout->i_changes |= VOUT_INTF_CHANGE;
 459                 break;
 460
 461             case SDLK_MENU:
 462                 {
 463                     intf_thread_t *p_intf;
 464                     p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
 465                                                       FIND_ANYWHERE );
 466                     if( p_intf != NULL )
 467                     {
 468                         p_intf->b_menu_change = 1;
 469                         vlc_object_release( p_intf );
 470                     }
 471                 }
 472                 break;
 473
 474             case SDLK_LEFT:
 475                 input_Seek( p_vout, -5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 476                 break;
 477
 478             case SDLK_RIGHT:
 479                 input_Seek( p_vout, 5, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 480                 break;
 481
 482             case SDLK_UP:
 483                 input_Seek( p_vout, 60, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 484                 break;
 485
 486             case SDLK_DOWN:
 487                 input_Seek( p_vout, -60, INPUT_SEEK_SECONDS | INPUT_SEEK_CUR );
 488                 break;
 489
 490             case SDLK_F1: network_ChannelJoin( p_vout, 1 ); break;
 491             case SDLK_F2: network_ChannelJoin( p_vout, 2 ); break;
 492             case SDLK_F3: network_ChannelJoin( p_vout, 3 ); break;
 493             case SDLK_F4: network_ChannelJoin( p_vout, 4 ); break;
 494             case SDLK_F5: network_ChannelJoin( p_vout, 5 ); break;
 495             case SDLK_F6: network_ChannelJoin( p_vout, 6 ); break;
 496             case SDLK_F7: network_ChannelJoin( p_vout, 7 ); break;
 497             case SDLK_F8: network_ChannelJoin( p_vout, 8 ); break;
 498             case SDLK_F9: network_ChannelJoin( p_vout, 9 ); break;
 499             case SDLK_F10: network_ChannelJoin( p_vout, 10 ); break;
 500             case SDLK_F11: network_ChannelJoin( p_vout, 11 ); break;
 501             case SDLK_F12: network_ChannelJoin( p_vout, 12 ); break;
 502
 503             case SDLK_b:
 504                 {
 505                     aout_instance_t * p_aout;
 506                     audio_volume_t i_volume;
 507                     p_aout = vlc_object_find( p_vout, VLC_OBJECT_AOUT,
 508                                                       FIND_ANYWHERE );
 509                     if( p_aout != NULL )
 510                     {
 511                         if ( !aout_VolumeDown( p_aout, 1, &i_volume ) )
 512                         {
 513                             msg_Dbg( p_vout, "audio volume is now %d", i_volume );
 514                         }
 515                         else
 516                         {
 517                             msg_Dbg( p_vout, "audio volume: operation not supported" );
 518                         }
 519                         vlc_object_release( (vlc_object_t *)p_aout );
 520                     }
 521                 }
 522                 break;
 523
 524             case SDLK_n:
 525                 {
 526                     aout_instance_t * p_aout;
 527                     audio_volume_t i_volume;
 528                     p_aout = vlc_object_find( p_vout, VLC_OBJECT_AOUT,
 529                                                       FIND_ANYWHERE );
 530                     if( p_aout != NULL )
 531                     {
 532                         if ( !aout_VolumeUp( p_aout, 1, &i_volume ) )
 533                         {
 534                             msg_Dbg( p_vout, "audio volume is now %d", i_volume );
 535                         }
 536                         else
 537                         {
 538                             msg_Dbg( p_vout, "audio volume: operation not supported" );
 539                         }
 540                         vlc_object_release( (vlc_object_t *)p_aout );
 541                     }
 542                 }
 543                 break;
 544
 545              default:
 546                 break;
 547             }
 548             break;
 549
 550         default:
 551             break;
 552         }
 553     }
 554
 555     /* Fullscreen change */
 556     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
 557     {
 558         p_vout->b_fullscreen = ! p_vout->b_fullscreen;
 559
 560         p_vout->p_sys->b_cursor_autohidden = 0;
 561         SDL_ShowCursor( p_vout->p_sys->b_cursor &&
 562                         ! p_vout->p_sys->b_cursor_autohidden );
 563
 564         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 565         p_vout->i_changes |= VOUT_SIZE_CHANGE;
 566     }
 567
 568     /*
 569      * Size change
 570      */
 571     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
 572     {
 573         msg_Dbg( p_vout, "video display resized (%dx%d)",
 574                  p_vout->p_sys->i_width, p_vout->p_sys->i_height );
 575
 576         CloseDisplay( p_vout );
 577         OpenDisplay( p_vout );
 578
 579         /* We don't need to signal the vout thread about the size change if
 580          * we can handle rescaling ourselves */
 581         if( p_vout->p_sys->p_overlay != NULL )
 582             p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
 583
 584     }
 585
 586     /* Pointer change */
 587     if( ! p_vout->p_sys->b_cursor_autohidden &&
 588         ( mdate() - p_vout->p_sys->i_lastmoved > 2000000 ) )
 589     {
 590         /* Hide the mouse automatically */
 591         p_vout->p_sys->b_cursor_autohidden = 1;
 592         SDL_ShowCursor( 0 );
 593     }
 594
 595     return( 0 );
 596 }
 597
 598 /*****************************************************************************
 599  * Display: displays previously rendered output
 600  *****************************************************************************
 601  * This function sends the currently rendered image to the display.
 602  *****************************************************************************/
 603 static void Display( vout_thread_t *p_vout, picture_t *p_pic )
 604 {
 605     int x, y, w, h;
 606     SDL_Rect disp;
 607
 608     vout_PlacePicture( p_vout, p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 609                        &x, &y, &w, &h );
 610     disp.x = x;
 611     disp.y = y;
 612     disp.w = w;
 613     disp.h = h;
 614
 615     if( p_vout->p_sys->p_overlay == NULL )
 616     {
 617         /* RGB picture */
 618         SDL_Flip( p_vout->p_sys->p_display );
 619     }
 620     else
 621     {
 622         /* Overlay picture */
 623         SDL_UnlockYUVOverlay( p_pic->p_sys->p_overlay);
 624         SDL_DisplayYUVOverlay( p_pic->p_sys->p_overlay , &disp );
 625         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay);
 626     }
 627 }
 628
 629 /* following functions are local */
 630
 631 /*****************************************************************************
 632  * OpenDisplay: open and initialize SDL device
 633  *****************************************************************************
 634  * Open and initialize display according to preferences specified in the vout
 635  * thread fields.
 636  *****************************************************************************/
 637 static int OpenDisplay( vout_thread_t *p_vout )
 638 {
 639     Uint32 i_flags;
 640     int    i_bpp;
 641
 642     /* Set main window's size */
 643     p_vout->p_sys->i_width = p_vout->b_fullscreen ? p_vout->output.i_width :
 644                                                     p_vout->i_window_width;
 645     p_vout->p_sys->i_height = p_vout->b_fullscreen ? p_vout->output.i_height :
 646                                                      p_vout->i_window_height;
 647
 648     /* Initialize flags and cursor */
 649     i_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
 650     i_flags |= p_vout->b_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
 651
 652     i_bpp = SDL_VideoModeOK( p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 653                              SDL_DEFAULT_BPP, i_flags );
 654     if( i_bpp == 0 )
 655     {
 656         msg_Err( p_vout, "no video mode available" );
 657         return( 1 );
 658     }
 659
 660     p_vout->p_sys->p_display = SDL_SetVideoMode( p_vout->p_sys->i_width,
 661                                                  p_vout->p_sys->i_height,
 662                                                  i_bpp, i_flags );
 663
 664     if( p_vout->p_sys->p_display == NULL )
 665     {
 666         msg_Err( p_vout, "cannot set video mode" );
 667         return( 1 );
 668     }
 669
 670     SDL_LockSurface( p_vout->p_sys->p_display );
 671
 672     /* Choose the chroma we will try first. */
 673     switch( p_vout->render.i_chroma )
 674     {
 675         case VLC_FOURCC('Y','U','Y','2'):
 676         case VLC_FOURCC('Y','U','N','V'):
 677             p_vout->output.i_chroma = SDL_YUY2_OVERLAY;
 678             break;
 679         case VLC_FOURCC('U','Y','V','Y'):
 680         case VLC_FOURCC('U','Y','N','V'):
 681         case VLC_FOURCC('Y','4','2','2'):
 682             p_vout->output.i_chroma = SDL_UYVY_OVERLAY;
 683             break;
 684         case VLC_FOURCC('Y','V','Y','U'):
 685             p_vout->output.i_chroma = SDL_YVYU_OVERLAY;
 686             break;
 687         case VLC_FOURCC('Y','V','1','2'):
 688         case VLC_FOURCC('I','4','2','0'):
 689         case VLC_FOURCC('I','Y','U','V'):
 690         default:
 691             p_vout->output.i_chroma = SDL_YV12_OVERLAY;
 692             break;
 693     }
 694
 695     p_vout->p_sys->p_overlay =
 696         SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 697                               p_vout->p_sys->p_display );
 698     /* FIXME: if the first overlay we find is software, don't stop,
 699      * because we may find a hardware one later ... */
 700
 701     /* If this best choice failed, fall back to other chromas */
 702     if( p_vout->p_sys->p_overlay == NULL )
 703     {
 704         p_vout->output.i_chroma = SDL_IYUV_OVERLAY;
 705         p_vout->p_sys->p_overlay =
 706             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 707                                   p_vout->p_sys->p_display );
 708     }
 709
 710     if( p_vout->p_sys->p_overlay == NULL )
 711     {
 712         p_vout->output.i_chroma = SDL_YV12_OVERLAY;
 713         p_vout->p_sys->p_overlay =
 714             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 715                                   p_vout->p_sys->p_display );
 716     }
 717
 718     if( p_vout->p_sys->p_overlay == NULL )
 719     {
 720         p_vout->output.i_chroma = SDL_YUY2_OVERLAY;
 721         p_vout->p_sys->p_overlay =
 722             SDL_CreateYUVOverlay( 32, 32, p_vout->output.i_chroma,
 723                                   p_vout->p_sys->p_display );
 724     }
 725
 726     if( p_vout->p_sys->p_overlay == NULL )
 727     {
 728         msg_Warn( p_vout, "no SDL overlay for 0x%.8x (%4.4s)",
 729                   p_vout->render.i_chroma, (char*)&p_vout->render.i_chroma );
 730
 731         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 732         {
 733             case 8:
 734                 p_vout->output.i_chroma = VLC_FOURCC('R','G','B','2');
 735                 p_vout->output.pf_setpalette = SetPalette;
 736                 break;
 737             case 15:
 738                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
 739                 break;
 740             case 16:
 741                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
 742                 break;
 743             case 24:
 744                 p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
 745                 break;
 746             case 32:
 747                 p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
 748                 break;
 749             default:
 750                 msg_Err( p_vout, "unknown screen depth %i",
 751                          p_vout->p_sys->p_display->format->BitsPerPixel );
 752                 SDL_UnlockSurface( p_vout->p_sys->p_display );
 753                 SDL_FreeSurface( p_vout->p_sys->p_display );
 754                 return( -1 );
 755         }
 756
 757         p_vout->output.i_rmask = p_vout->p_sys->p_display->format->Rmask;
 758         p_vout->output.i_gmask = p_vout->p_sys->p_display->format->Gmask;
 759         p_vout->output.i_bmask = p_vout->p_sys->p_display->format->Bmask;
 760
 761         SDL_WM_SetCaption( VOUT_TITLE " (software RGB SDL output)",
 762                            VOUT_TITLE " (software RGB SDL output)" );
 763     }
 764     else
 765     {
 766         if( p_vout->p_sys->p_overlay->hw_overlay )
 767         {
 768             SDL_WM_SetCaption( VOUT_TITLE " (hardware YUV SDL output)",
 769                                VOUT_TITLE " (hardware YUV SDL output)" );
 770         }
 771         else
 772         {
 773             SDL_WM_SetCaption( VOUT_TITLE " (software YUV SDL output)",
 774                                VOUT_TITLE " (software YUV SDL output)" );
 775         }
 776     }
 777
 778     SDL_EventState( SDL_KEYUP, SDL_IGNORE );               /* ignore keys up */
 779
 780     return( 0 );
 781 }
 782
 783 /*****************************************************************************
 784  * CloseDisplay: close and reset SDL device
 785  *****************************************************************************
 786  * This function returns all resources allocated by OpenDisplay and restore
 787  * the original state of the device.
 788  *****************************************************************************/
 789 static void CloseDisplay( vout_thread_t *p_vout )
 790 {
 791     SDL_FreeYUVOverlay( p_vout->p_sys->p_overlay );
 792     SDL_UnlockSurface ( p_vout->p_sys->p_display );
 793     SDL_FreeSurface( p_vout->p_sys->p_display );
 794 }
 795
 796 /*****************************************************************************
 797  * NewPicture: allocate a picture
 798  *****************************************************************************
 799  * Returns 0 on success, -1 otherwise
 800  *****************************************************************************/
 801 static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic )
 802 {
 803     int i_width  = p_vout->output.i_width;
 804     int i_height = p_vout->output.i_height;
 805
 806     if( p_vout->p_sys->p_overlay == NULL )
 807     {
 808         /* RGB picture */
 809         if( p_vout->p_sys->i_surfaces )
 810         {
 811             /* We already allocated this surface, return */
 812             return -1;
 813         }
 814
 815         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 816
 817         if( p_pic->p_sys == NULL )
 818         {
 819             return -1;
 820         }
 821
 822         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 823         {
 824             case 8:
 825                 p_pic->p->i_pixel_pitch = 1;
 826                 break;
 827             case 15:
 828             case 16:
 829                 p_pic->p->i_pixel_pitch = 2;
 830                 break;
 831             case 24:
 832             case 32:
 833                 p_pic->p->i_pixel_pitch = 4;
 834                 break;
 835             default:
 836                 return( -1 );
 837         }
 838
 839         p_pic->p->p_pixels = p_vout->p_sys->p_display->pixels;
 840         p_pic->p->i_lines = p_vout->p_sys->p_display->h;
 841         p_pic->p->i_pitch = p_vout->p_sys->p_display->pitch;
 842         p_pic->p->i_visible_pitch =
 843             p_pic->p->i_pixel_pitch * p_vout->p_sys->p_display->w;
 844
 845         p_vout->p_sys->i_surfaces++;
 846
 847         p_pic->i_planes = 1;
 848     }
 849     else
 850     {
 851         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 852
 853         if( p_pic->p_sys == NULL )
 854         {
 855             return -1;
 856         }
 857
 858         p_pic->p_sys->p_overlay =
 859             SDL_CreateYUVOverlay( i_width, i_height,
 860                                   p_vout->output.i_chroma,
 861                                   p_vout->p_sys->p_display );
 862
 863         if( p_pic->p_sys->p_overlay == NULL )
 864         {
 865             free( p_pic->p_sys );
 866             return -1;
 867         }
 868
 869         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay );
 870
 871         p_pic->Y_PIXELS = p_pic->p_sys->p_overlay->pixels[0];
 872         p_pic->p[Y_PLANE].i_lines = p_pic->p_sys->p_overlay->h;
 873         p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[0];
 874
 875         switch( p_vout->output.i_chroma )
 876         {
 877         case SDL_YV12_OVERLAY:
 878             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
 879             p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w;
 880
 881             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
 882             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 883             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
 884             p_pic->p[U_PLANE].i_pixel_pitch = 1;
 885             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
 886
 887             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
 888             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 889             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
 890             p_pic->p[V_PLANE].i_pixel_pitch = 1;
 891             p_pic->p[V_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
 892
 893             p_pic->i_planes = 3;
 894             break;
 895
 896         case SDL_IYUV_OVERLAY:
 897             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
 898             p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w;
 899
 900             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
 901             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 902             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
 903             p_pic->p[U_PLANE].i_pixel_pitch = 1;
 904             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
 905
 906             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
 907             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
 908             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
 909             p_pic->p[V_PLANE].i_pixel_pitch = 1;
 910             p_pic->p[V_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
 911
 912             p_pic->i_planes = 3;
 913             break;
 914
 915         default:
 916             p_pic->p[Y_PLANE].i_pixel_pitch = 2;
 917             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w * 2;
 918
 919             p_pic->i_planes = 1;
 920             break;
 921         }
 922     }
 923
 924     return 0;
 925 }
 926
 927 /*****************************************************************************
 928  * SetPalette: sets an 8 bpp palette
 929  *****************************************************************************/
 930 static void SetPalette( vout_thread_t *p_vout,
 931                         uint16_t *red, uint16_t *green, uint16_t *blue )
 932 {
 933     SDL_Color colors[256];
 934     int i;
 935
 936     /* Fill colors with color information */
 937     for( i = 0; i < 256; i++ )
 938     {
 939         colors[ i ].r = red[ i ] >> 8;
 940         colors[ i ].g = green[ i ] >> 8;
 941         colors[ i ].b = blue[ i ] >> 8;
 942     }
 943
 944     /* Set palette */
 945     if( SDL_SetColors( p_vout->p_sys->p_display, colors, 0, 256 ) == 0 )
 946     {
 947         msg_Err( p_vout, "failed setting palette" );
 948     }
 949 }
 950