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 the VideoLAN team
   5  * $Id$
   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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #include <errno.h>                                                 /* ENOMEM */
  30
  31 #include <vlc/vlc.h>
  32 #include <vlc_interface.h>
  33 #include <vlc_playlist.h>
  34 #include <vlc_vout.h>
  35 #include <vlc_keys.h>
  36 //#include <vlc_aout.h>
  37
  38 #include <sys/types.h>
  39 #ifndef WIN32
  40 #   include <netinet/in.h>                            /* BSD: struct in_addr */
  41 #endif
  42
  43 #include SDL_INCLUDE_FILE
  44
  45 /* SDL is not able to crop overlays - so use only 1 direct buffer */
  46 #define SDL_MAX_DIRECTBUFFERS 1
  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     unsigned int i_desktop_width;
  63     unsigned int i_desktop_height;
  64
  65     /* For YUV output */
  66     SDL_Overlay * p_overlay;   /* An overlay we keep to grab the XVideo port */
  67
  68     /* For RGB output */
  69     int i_surfaces;
  70
  71     vlc_bool_t  b_cursor;
  72     vlc_bool_t  b_cursor_autohidden;
  73     mtime_t     i_lastmoved;
  74     mtime_t     i_lastpressed;                        /* to track dbl-clicks */
  75 };
  76
  77 /*****************************************************************************
  78  * picture_sys_t: direct buffer method descriptor
  79  *****************************************************************************
  80  * This structure is part of the picture descriptor, it describes the
  81  * SDL specific properties of a direct buffer.
  82  *****************************************************************************/
  83 struct picture_sys_t
  84 {
  85     SDL_Overlay *p_overlay;
  86 };
  87
  88 /*****************************************************************************
  89  * Local prototypes
  90  *****************************************************************************/
  91 static int  Open      ( vlc_object_t * );
  92 static void Close     ( vlc_object_t * );
  93 static int  Init      ( vout_thread_t * );
  94 static void End       ( vout_thread_t * );
  95 static int  Manage    ( vout_thread_t * );
  96 static void Display   ( vout_thread_t *, picture_t * );
  97
  98 static int  OpenDisplay     ( vout_thread_t * );
  99 static void CloseDisplay    ( vout_thread_t * );
 100 static int  NewPicture      ( vout_thread_t *, picture_t * );
 101 static void SetPalette      ( vout_thread_t *,
 102                               uint16_t *, uint16_t *, uint16_t * );
 103
 104 static int ConvertKey( SDLKey );
 105
 106
 107 #define CHROMA_TEXT N_("SDL chroma format")
 108 #define CHROMA_LONGTEXT N_( \
 109     "Force the SDL renderer to use a specific chroma format instead of " \
 110     "trying to improve performances by using the most efficient one.")
 111
 112 /*****************************************************************************
 113  * Module descriptor
 114  *****************************************************************************/
 115 vlc_module_begin();
 116     set_shortname( "SDL" );
 117     set_category( CAT_VIDEO );
 118     set_subcategory( SUBCAT_VIDEO_VOUT );
 119     set_description( _("Simple DirectMedia Layer video output") );
 120     set_capability( "video output", 60 );
 121     add_shortcut( "sdl" );
 122     add_string( "sdl-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT, VLC_TRUE );
 123     set_callbacks( Open, Close );
 124 #if defined( __i386__ ) || defined( __x86_64__ )
 125     /* On i386, SDL is linked against svgalib */
 126     linked_with_a_crap_library_which_uses_atexit();
 127 #endif
 128 vlc_module_end();
 129
 130 /*****************************************************************************
 131  * OpenVideo: allocate SDL video thread output method
 132  *****************************************************************************
 133  * This function allocate and initialize a SDL vout method. It uses some of the
 134  * vout properties to choose the correct mode, and change them according to the
 135  * mode actually used.
 136  *****************************************************************************/
 137 static int Open ( vlc_object_t *p_this )
 138 {
 139     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 140     /* XXX: check for conflicts with the SDL audio output */
 141     vlc_mutex_t *lock = var_AcquireMutex( "sdl" );
 142
 143 #ifdef HAVE_SETENV
 144     char *psz_method;
 145 #endif
 146
 147     if( lock == NULL )
 148         return VLC_ENOMEM;
 149
 150     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 151     if( p_vout->p_sys == NULL )
 152     {
 153         vlc_mutex_unlock( lock );
 154         return VLC_ENOMEM;
 155     }
 156
 157     /* Check if SDL video module has been initialized */
 158     if( SDL_WasInit( SDL_INIT_VIDEO ) != 0 )
 159     {
 160         vlc_mutex_unlock( lock );
 161         free( p_vout->p_sys );
 162         return VLC_EGENERIC;
 163     }
 164
 165     /* Allocate structure */
 166     p_vout->pf_init = Init;
 167     p_vout->pf_end = End;
 168     p_vout->pf_manage = Manage;
 169     p_vout->pf_render = NULL;
 170     p_vout->pf_display = Display;
 171     p_vout->pf_control = NULL;
 172
 173 #ifdef HAVE_SETENV
 174     psz_method = config_GetPsz( p_vout, "vout" );
 175     if( psz_method )
 176     {
 177         while( *psz_method && *psz_method != ':' )
 178         {
 179             psz_method++;
 180         }
 181
 182         if( *psz_method )
 183         {
 184             setenv( "SDL_VIDEODRIVER", psz_method + 1, 1 );
 185         }
 186     }
 187 #endif
 188
 189     /* Initialize library */
 190     if( SDL_Init( SDL_INIT_VIDEO
 191 #ifndef WIN32
 192     /* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
 193                 | SDL_INIT_EVENTTHREAD
 194 #endif
 195 #ifdef DEBUG
 196     /* In debug mode you may want vlc to dump a core instead of staying
 197      * stuck */
 198                 | SDL_INIT_NOPARACHUTE
 199 #endif
 200                 ) < 0 )
 201     {
 202         msg_Err( p_vout, "cannot initialize SDL (%s)", SDL_GetError() );
 203         free( p_vout->p_sys );
 204         vlc_mutex_unlock( lock );
 205         return VLC_EGENERIC;
 206     }
 207
 208     vlc_mutex_unlock( lock );
 209
 210     /* Translate keys into unicode */
 211     SDL_EnableUNICODE(1);
 212
 213     /* Get the desktop resolution */
 214     p_vout->p_sys->i_desktop_width = SDL_GetVideoInfo()->current_w;
 215     p_vout->p_sys->i_desktop_height = SDL_GetVideoInfo()->current_h;
 216
 217     /* Create the cursor */
 218     p_vout->p_sys->b_cursor = 1;
 219     p_vout->p_sys->b_cursor_autohidden = 0;
 220     p_vout->p_sys->i_lastmoved = p_vout->p_sys->i_lastpressed = mdate();
 221
 222     if( OpenDisplay( p_vout ) )
 223     {
 224         msg_Err( p_vout, "cannot set up SDL (%s)", SDL_GetError() );
 225         SDL_QuitSubSystem( SDL_INIT_VIDEO );
 226         free( p_vout->p_sys );
 227         return VLC_EGENERIC;
 228     }
 229
 230     return VLC_SUCCESS;
 231 }
 232
 233 /*****************************************************************************
 234  * Init: initialize SDL video thread output method
 235  *****************************************************************************
 236  * This function initialize the SDL display device.
 237  *****************************************************************************/
 238 static int Init( vout_thread_t *p_vout )
 239 {
 240     int i_index;
 241     picture_t *p_pic;
 242
 243     p_vout->p_sys->i_surfaces = 0;
 244
 245     I_OUTPUTPICTURES = 0;
 246
 247     /* Initialize the output structure */
 248     if( p_vout->p_sys->p_overlay == NULL )
 249     {
 250         /* All we have is an RGB image with square pixels */
 251         p_vout->output.i_width  = p_vout->p_sys->i_width;
 252         p_vout->output.i_height = p_vout->p_sys->i_height;
 253         p_vout->output.i_aspect = p_vout->output.i_width
 254                                    * VOUT_ASPECT_FACTOR
 255                                    / p_vout->output.i_height;
 256     }
 257     else
 258     {
 259         /* We may need to convert the chroma, but at least we keep the
 260          * aspect ratio */
 261         p_vout->output.i_width  = p_vout->render.i_width;
 262         p_vout->output.i_height = p_vout->render.i_height;
 263         p_vout->output.i_aspect = p_vout->render.i_aspect;
 264     }
 265
 266     /* Try to initialize SDL_MAX_DIRECTBUFFERS direct buffers */
 267     while( I_OUTPUTPICTURES < SDL_MAX_DIRECTBUFFERS )
 268     {
 269         p_pic = NULL;
 270
 271         /* Find an empty picture slot */
 272         for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
 273         {
 274             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
 275             {
 276                 p_pic = p_vout->p_picture + i_index;
 277                 break;
 278             }
 279         }
 280
 281         /* Allocate the picture if we found one */
 282         if( p_pic == NULL || NewPicture( p_vout, p_pic ) )
 283         {
 284             break;
 285         }
 286
 287         p_pic->i_status = DESTROYED_PICTURE;
 288         p_pic->i_type   = DIRECT_PICTURE;
 289
 290         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
 291
 292         I_OUTPUTPICTURES++;
 293     }
 294
 295     return VLC_SUCCESS;
 296 }
 297
 298 /*****************************************************************************
 299  * End: terminate Sys video thread output method
 300  *****************************************************************************
 301  * Terminate an output method created by OpenVideo
 302  *****************************************************************************/
 303 static void End( vout_thread_t *p_vout )
 304 {
 305     int i_index;
 306
 307     /* Free the output buffers we allocated */
 308     for( i_index = I_OUTPUTPICTURES ; i_index ; )
 309     {
 310         i_index--;
 311         if( p_vout->p_sys->p_overlay == NULL )
 312         {
 313             /* RGB picture */
 314         }
 315         else
 316         {
 317             SDL_UnlockYUVOverlay(
 318                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 319             SDL_FreeYUVOverlay(
 320                     PP_OUTPUTPICTURE[ i_index ]->p_sys->p_overlay );
 321         }
 322         free( PP_OUTPUTPICTURE[ i_index ]->p_sys );
 323     }
 324 }
 325
 326 /*****************************************************************************
 327  * CloseVideo: destroy Sys video thread output method
 328  *****************************************************************************
 329  * Terminate an output method created by vout_SDLCreate
 330  *****************************************************************************/
 331 static void Close ( vlc_object_t *p_this )
 332 {
 333     vout_thread_t * p_vout = (vout_thread_t *)p_this;
 334
 335     CloseDisplay( p_vout );
 336     SDL_QuitSubSystem( SDL_INIT_VIDEO );
 337
 338     free( p_vout->p_sys );
 339 }
 340
 341 /*****************************************************************************
 342  * Manage: handle Sys events
 343  *****************************************************************************
 344  * This function should be called regularly by video output thread. It returns
 345  * a non null value if an error occurred.
 346  *****************************************************************************/
 347 static int Manage( vout_thread_t *p_vout )
 348 {
 349     SDL_Event event;                                            /* SDL event */
 350     vlc_value_t val;
 351     unsigned int i_width, i_height, i_x, i_y;
 352
 353     /* Process events */
 354     while( SDL_PollEvent( &event ) )
 355     {
 356         switch( event.type )
 357         {
 358         /* Resizing of window */
 359         case SDL_VIDEORESIZE:
 360             p_vout->i_changes |= VOUT_SIZE_CHANGE;
 361             p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
 362             p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
 363             break;
 364
 365         /* Mouse move */
 366         case SDL_MOUSEMOTION:
 367             vout_PlacePicture( p_vout, p_vout->p_sys->i_width,
 368                                p_vout->p_sys->i_height,
 369                                &i_x, &i_y, &i_width, &i_height );
 370
 371             /* Compute the x coordinate and check if the value is
 372                in [0,p_vout->fmt_in.i_visible_width] */
 373             val.i_int = ( event.motion.x - i_x ) *
 374                         p_vout->fmt_in.i_visible_width / i_width +
 375                         p_vout->fmt_in.i_x_offset;
 376
 377             if( (int)(event.motion.x - i_x) < 0 )
 378                 val.i_int = 0;
 379             else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_width )
 380                 val.i_int = p_vout->fmt_in.i_visible_width;
 381
 382             var_Set( p_vout, "mouse-x", val );
 383
 384             /* compute the y coordinate and check if the value is
 385                in [0,p_vout->fmt_in.i_visible_height] */
 386             val.i_int = ( event.motion.y - i_y ) *
 387                         p_vout->fmt_in.i_visible_height / i_height +
 388                         p_vout->fmt_in.i_y_offset;
 389
 390             if( (int)(event.motion.y - i_y) < 0 )
 391                 val.i_int = 0;
 392             else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_height )
 393                 val.i_int = p_vout->fmt_in.i_visible_height;
 394
 395             var_Set( p_vout, "mouse-y", val );
 396
 397             val.b_bool = VLC_TRUE;
 398             var_Set( p_vout, "mouse-moved", val );
 399
 400             if( p_vout->p_sys->b_cursor )
 401             {
 402                 if( p_vout->p_sys->b_cursor_autohidden )
 403                 {
 404                     p_vout->p_sys->b_cursor_autohidden = 0;
 405                     SDL_ShowCursor( 1 );
 406                 }
 407                 else
 408                 {
 409                     p_vout->p_sys->i_lastmoved = mdate();
 410                 }
 411             }
 412             break;
 413
 414         /* Mouse button released */
 415         case SDL_MOUSEBUTTONUP:
 416             switch( event.button.button )
 417             {
 418             case SDL_BUTTON_LEFT:
 419                 var_Get( p_vout, "mouse-button-down", &val );
 420                 val.i_int &= ~1;
 421                 var_Set( p_vout, "mouse-button-down", val );
 422
 423                 val.b_bool = VLC_TRUE;
 424                 var_Set( p_vout, "mouse-clicked", val );
 425                 break;
 426
 427             case SDL_BUTTON_MIDDLE:
 428                 {
 429                     playlist_t *p_playlist;
 430
 431                     var_Get( p_vout, "mouse-button-down", &val );
 432                     val.i_int &= ~2;
 433                     var_Set( p_vout, "mouse-button-down", val );
 434
 435                     p_playlist = vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
 436                                               FIND_ANYWHERE );
 437                     if( p_playlist != NULL )
 438                     {
 439                         vlc_value_t val;
 440                         var_Get( p_playlist, "intf-show", &val );
 441                         val.b_bool = !val.b_bool;
 442                         var_Set( p_playlist, "intf-show", val );
 443                         vlc_object_release( p_playlist );
 444                     }
 445                 }
 446                 break;
 447
 448             case SDL_BUTTON_RIGHT:
 449                 {
 450                     intf_thread_t *p_intf;
 451                     playlist_t *p_playlist;
 452
 453                     var_Get( p_vout, "mouse-button-down", &val );
 454                     val.i_int &= ~4;
 455                     var_Set( p_vout, "mous-button-down", val );
 456                     p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
 457                                                       FIND_ANYWHERE );
 458                     if( p_intf )
 459                     {
 460                         p_intf->b_menu_change = 1;
 461                         vlc_object_release( p_intf );
 462                     }
 463
 464                     p_playlist = vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
 465                                                 FIND_ANYWHERE );
 466
 467                     if( p_playlist != NULL )
 468                     {
 469                         vlc_value_t val;
 470                         val.b_bool = VLC_TRUE;
 471                         var_Set( p_playlist, "intf-popupmenu", val );
 472                         vlc_object_release( p_playlist );
 473                     }
 474                 }
 475                 break;
 476             }
 477             break;
 478
 479         /* Mouse button pressed */
 480         case SDL_MOUSEBUTTONDOWN:
 481             switch( event.button.button )
 482             {
 483             case SDL_BUTTON_LEFT:
 484                 var_Get( p_vout, "mouse-button-down", &val );
 485                 val.i_int |= 1;
 486                 var_Set( p_vout, "mouse-button-down", val );
 487
 488                 /* detect double-clicks */
 489                 if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
 490                     p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
 491
 492                 p_vout->p_sys->i_lastpressed = mdate();
 493                 break;
 494
 495             case SDL_BUTTON_MIDDLE:
 496                 var_Get( p_vout, "mouse-button-down", &val );
 497                 val.i_int |= 2;
 498                 var_Set( p_vout, "mouse-button-down", val );
 499                 break;
 500
 501             case SDL_BUTTON_RIGHT:
 502                 var_Get( p_vout, "mouse-button-down", &val );
 503                 val.i_int |= 4;
 504                 var_Set( p_vout, "mouse-button-down", val );
 505                 break;
 506             }
 507             break;
 508
 509         /* Quit event (close the window) */
 510         case SDL_QUIT:
 511             {
 512                 playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
 513                 if( p_playlist != NULL )
 514                 {
 515                     playlist_Stop( p_playlist );
 516                     vlc_object_release( p_playlist );
 517                 }
 518             }
 519             break;
 520
 521         /* Key pressed */
 522         case SDL_KEYDOWN:
 523             /* convert the key if possible */
 524             val.i_int = ConvertKey( event.key.keysym.sym );
 525
 526             if( !val.i_int )
 527             {
 528                 /* Find the right caracter */
 529                 if( ( event.key.keysym.unicode & 0xff80 ) == 0 )
 530                 {
 531                     val.i_int = event.key.keysym.unicode & 0x7f;
 532                     /* FIXME: find a better solution than this
 533                               hack to find the right caracter */
 534                     if( val.i_int >= 1 && val.i_int <= 26 )
 535                         val.i_int += 96;
 536                     else if( val.i_int >= 65 && val.i_int <= 90 )
 537                         val.i_int += 32;
 538                 }
 539             }
 540
 541             if( val.i_int )
 542             {
 543                 if( ( event.key.keysym.mod & KMOD_SHIFT ) )
 544                 {
 545                     val.i_int |= KEY_MODIFIER_SHIFT;
 546                 }
 547                 if( ( event.key.keysym.mod & KMOD_CTRL ) )
 548                 {
 549                     val.i_int |= KEY_MODIFIER_CTRL;
 550                 }
 551                 if( ( event.key.keysym.mod & KMOD_ALT ) )
 552                 {
 553                     val.i_int |= KEY_MODIFIER_ALT;
 554                 }
 555                 var_Set( p_vout->p_libvlc, "key-pressed", val );
 556             }
 557
 558         default:
 559             break;
 560         }
 561     }
 562
 563     /* Fullscreen change */
 564     if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
 565     {
 566         vlc_value_t val_fs;
 567
 568         /* Update the object variable and trigger callback */
 569         val_fs.b_bool = !p_vout->b_fullscreen;
 570         p_vout->b_fullscreen = !p_vout->b_fullscreen;
 571         var_Set( p_vout, "fullscreen", val_fs );
 572
 573         /*TODO: add the "always on top" code here !*/
 574
 575         p_vout->p_sys->b_cursor_autohidden = 0;
 576         SDL_ShowCursor( p_vout->p_sys->b_cursor &&
 577                         ! p_vout->p_sys->b_cursor_autohidden );
 578
 579         p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
 580         p_vout->i_changes |= VOUT_SIZE_CHANGE;
 581     }
 582
 583     /* Crop or Aspect Ratio Changes */
 584     if( p_vout->i_changes & VOUT_CROP_CHANGE ||
 585         p_vout->i_changes & VOUT_ASPECT_CHANGE )
 586     {
 587         p_vout->i_changes &= ~VOUT_CROP_CHANGE;
 588         p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
 589
 590         p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
 591         p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
 592         p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
 593         p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
 594         p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
 595         p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
 596         p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
 597         p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
 598
 599         p_vout->i_changes |= VOUT_SIZE_CHANGE;
 600     }
 601
 602     /* Size change */
 603     if( p_vout->i_changes & VOUT_SIZE_CHANGE )
 604     {
 605         msg_Dbg( p_vout, "video display resized (%dx%d)",
 606                  p_vout->p_sys->i_width, p_vout->p_sys->i_height );
 607
 608         CloseDisplay( p_vout );
 609         OpenDisplay( p_vout );
 610
 611         /* We don't need to signal the vout thread about the size change if
 612          * we can handle rescaling ourselves */
 613         if( p_vout->p_sys->p_overlay != NULL )
 614             p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
 615     }
 616
 617     /* Pointer change */
 618     if( ! p_vout->p_sys->b_cursor_autohidden &&
 619         ( mdate() - p_vout->p_sys->i_lastmoved > 2000000 ) )
 620     {
 621         /* Hide the mouse automatically */
 622         p_vout->p_sys->b_cursor_autohidden = 1;
 623         SDL_ShowCursor( 0 );
 624     }
 625
 626     return VLC_SUCCESS;
 627 }
 628
 629 /*****************************************************************************
 630  * Key events handling
 631  *****************************************************************************/
 632 static struct
 633 {
 634     SDLKey sdl_key;
 635     int i_vlckey;
 636 } sdlkeys_to_vlckeys[] =
 637 {
 638     { SDLK_F1,  KEY_F1 },
 639     { SDLK_F2,  KEY_F2 },
 640     { SDLK_F3,  KEY_F3 },
 641     { SDLK_F4,  KEY_F4 },
 642     { SDLK_F5,  KEY_F5 },
 643     { SDLK_F6,  KEY_F6 },
 644     { SDLK_F7,  KEY_F7 },
 645     { SDLK_F8,  KEY_F8 },
 646     { SDLK_F9,  KEY_F9 },
 647     { SDLK_F10, KEY_F10 },
 648     { SDLK_F11, KEY_F11 },
 649     { SDLK_F12, KEY_F12 },
 650
 651     { SDLK_RETURN, KEY_ENTER },
 652     { SDLK_KP_ENTER, KEY_ENTER },
 653     { SDLK_SPACE, KEY_SPACE },
 654     { SDLK_ESCAPE, KEY_ESC },
 655
 656     { SDLK_MENU, KEY_MENU },
 657     { SDLK_LEFT, KEY_LEFT },
 658     { SDLK_RIGHT, KEY_RIGHT },
 659     { SDLK_UP, KEY_UP },
 660     { SDLK_DOWN, KEY_DOWN },
 661
 662     { SDLK_HOME, KEY_HOME },
 663     { SDLK_END, KEY_END },
 664     { SDLK_PAGEUP, KEY_PAGEUP },
 665     { SDLK_PAGEDOWN,  KEY_PAGEDOWN },
 666
 667     { SDLK_INSERT, KEY_INSERT },
 668     { SDLK_DELETE, KEY_DELETE },
 669     /*TODO: find a equivalent for SDL
 670     { , KEY_MEDIA_NEXT_TRACK }
 671     { , KEY_MEDIA_PREV_TRACK }
 672     { , KEY_VOLUME_MUTE }
 673     { , KEY_VOLUME_DOWN }
 674     { , KEY_VOLUME_UP }
 675     { , KEY_MEDIA_PLAY_PAUSE }
 676     { , KEY_MEDIA_PLAY_PAUSE }*/
 677
 678     { 0, 0 }
 679 };
 680
 681 static int ConvertKey( SDLKey sdl_key )
 682 {
 683     int i;
 684     for( i=0; sdlkeys_to_vlckeys[i].sdl_key != 0; i++ )
 685     {
 686         if( sdlkeys_to_vlckeys[i].sdl_key == sdl_key )
 687         {
 688             return sdlkeys_to_vlckeys[i].i_vlckey;
 689         }
 690     }
 691     return 0;
 692 }
 693
 694
 695 /*****************************************************************************
 696  * Display: displays previously rendered output
 697  *****************************************************************************
 698  * This function sends the currently rendered image to the display.
 699  *****************************************************************************/
 700 static void Display( vout_thread_t *p_vout, picture_t *p_pic )
 701 {
 702     unsigned int x, y, w, h;
 703     SDL_Rect disp;
 704
 705     vout_PlacePicture( p_vout, p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 706                        &x, &y, &w, &h );
 707     disp.x = x;
 708     disp.y = y;
 709     disp.w = w;
 710     disp.h = h;
 711
 712     if( p_vout->p_sys->p_overlay == NULL )
 713     {
 714         /* RGB picture */
 715         SDL_Flip( p_vout->p_sys->p_display );
 716     }
 717     else
 718     {
 719         /* Overlay picture */
 720         SDL_UnlockYUVOverlay( p_pic->p_sys->p_overlay);
 721         SDL_DisplayYUVOverlay( p_pic->p_sys->p_overlay , &disp );
 722         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay);
 723     }
 724 }
 725
 726 /* following functions are local */
 727
 728 /*****************************************************************************
 729  * OpenDisplay: open and initialize SDL device
 730  *****************************************************************************
 731  * Open and initialize display according to preferences specified in the vout
 732  * thread fields.
 733  *****************************************************************************/
 734 static int OpenDisplay( vout_thread_t *p_vout )
 735 {
 736     uint32_t i_flags;
 737     int i_bpp;
 738
 739     /* SDL fucked up fourcc definitions on bigendian machines */
 740     uint32_t i_sdl_chroma;
 741     char *psz_chroma = NULL;
 742     uint32_t i_chroma = 0;
 743
 744     /* Set main window's size */
 745     p_vout->p_sys->i_width = p_vout->b_fullscreen ? p_vout->p_sys->i_desktop_width :
 746                                                     p_vout->i_window_width;
 747     p_vout->p_sys->i_height = p_vout->b_fullscreen ? p_vout->p_sys->i_desktop_height :
 748                                                      p_vout->i_window_height;
 749
 750     /* Initialize flags and cursor */
 751     i_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
 752     i_flags |= p_vout->b_fullscreen ? SDL_FULLSCREEN : SDL_RESIZABLE;
 753
 754     i_bpp = SDL_VideoModeOK( p_vout->p_sys->i_width, p_vout->p_sys->i_height,
 755                              SDL_DEFAULT_BPP, i_flags );
 756     if( i_bpp == 0 )
 757     {
 758         msg_Err( p_vout, "no video mode available" );
 759         return VLC_EGENERIC;
 760     }
 761
 762     p_vout->p_sys->p_display = SDL_SetVideoMode( p_vout->p_sys->i_width,
 763                                                  p_vout->p_sys->i_height,
 764                                                  i_bpp, i_flags );
 765
 766     if( p_vout->p_sys->p_display == NULL )
 767     {
 768         msg_Err( p_vout, "cannot set video mode" );
 769         return VLC_EGENERIC;
 770     }
 771
 772     SDL_LockSurface( p_vout->p_sys->p_display );
 773
 774     if( ( psz_chroma = config_GetPsz( p_vout, "sdl-chroma" ) ) )
 775     {
 776         if( strlen( psz_chroma ) >= 4 )
 777         {
 778             memcpy(&i_chroma, psz_chroma, 4);
 779             msg_Dbg( p_vout, "Forcing chroma to 0x%.8x (%4.4s)", i_chroma, (char*)&i_chroma );
 780         }
 781         else
 782         {
 783             free( psz_chroma );
 784             psz_chroma = NULL;
 785         }
 786     }
 787
 788     /* Choose the chroma we will try first. */
 789     do
 790     {
 791         if( !psz_chroma ) i_chroma = 0;
 792         switch( i_chroma ? i_chroma : p_vout->render.i_chroma )
 793         {
 794             case VLC_FOURCC('Y','U','Y','2'):
 795             case VLC_FOURCC('Y','U','N','V'):
 796                 p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
 797                 i_sdl_chroma = SDL_YUY2_OVERLAY;
 798                 break;
 799             case VLC_FOURCC('U','Y','V','Y'):
 800             case VLC_FOURCC('U','Y','N','V'):
 801             case VLC_FOURCC('Y','4','2','2'):
 802                 p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
 803                 i_sdl_chroma = SDL_UYVY_OVERLAY;
 804                 break;
 805             case VLC_FOURCC('Y','V','Y','U'):
 806                 p_vout->output.i_chroma = VLC_FOURCC('Y','V','Y','U');
 807                 i_sdl_chroma = SDL_YVYU_OVERLAY;
 808                 break;
 809             case VLC_FOURCC('Y','V','1','2'):
 810             case VLC_FOURCC('I','4','2','0'):
 811             case VLC_FOURCC('I','Y','U','V'):
 812             default:
 813                 p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 814                 i_sdl_chroma = SDL_YV12_OVERLAY;
 815                 break;
 816         }
 817         free( psz_chroma ); psz_chroma = NULL;
 818
 819         p_vout->p_sys->p_overlay =
 820             SDL_CreateYUVOverlay( 32, 32, i_sdl_chroma,
 821                                   p_vout->p_sys->p_display );
 822         /* FIXME: if the first overlay we find is software, don't stop,
 823          * because we may find a hardware one later ... */
 824     }
 825     while( i_chroma && !p_vout->p_sys->p_overlay );
 826
 827
 828     /* If this best choice failed, fall back to other chromas */
 829     if( p_vout->p_sys->p_overlay == NULL )
 830     {
 831         p_vout->output.i_chroma = VLC_FOURCC('I','Y','U','V');
 832         p_vout->p_sys->p_overlay =
 833             SDL_CreateYUVOverlay( 32, 32, SDL_IYUV_OVERLAY,
 834                                   p_vout->p_sys->p_display );
 835     }
 836
 837     if( p_vout->p_sys->p_overlay == NULL )
 838     {
 839         p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 840         p_vout->p_sys->p_overlay =
 841             SDL_CreateYUVOverlay( 32, 32, SDL_YV12_OVERLAY,
 842                                   p_vout->p_sys->p_display );
 843     }
 844
 845     if( p_vout->p_sys->p_overlay == NULL )
 846     {
 847         p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
 848         p_vout->p_sys->p_overlay =
 849             SDL_CreateYUVOverlay( 32, 32, SDL_YUY2_OVERLAY,
 850                                   p_vout->p_sys->p_display );
 851     }
 852
 853     if( p_vout->p_sys->p_overlay == NULL )
 854     {
 855         msg_Warn( p_vout, "no SDL overlay for 0x%.8x (%4.4s)",
 856                   p_vout->render.i_chroma, (char*)&p_vout->render.i_chroma );
 857
 858         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 859         {
 860             case 8:
 861                 p_vout->output.i_chroma = VLC_FOURCC('R','G','B','2');
 862                 p_vout->output.pf_setpalette = SetPalette;
 863                 break;
 864             case 15:
 865                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','5');
 866                 break;
 867             case 16:
 868                 p_vout->output.i_chroma = VLC_FOURCC('R','V','1','6');
 869                 break;
 870             case 24:
 871                 p_vout->output.i_chroma = VLC_FOURCC('R','V','2','4');
 872                 break;
 873             case 32:
 874                 p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
 875                 break;
 876             default:
 877                 msg_Err( p_vout, "unknown screen depth %i",
 878                          p_vout->p_sys->p_display->format->BitsPerPixel );
 879                 SDL_UnlockSurface( p_vout->p_sys->p_display );
 880                 SDL_FreeSurface( p_vout->p_sys->p_display );
 881                 return VLC_EGENERIC;
 882         }
 883
 884         p_vout->output.i_rmask = p_vout->p_sys->p_display->format->Rmask;
 885         p_vout->output.i_gmask = p_vout->p_sys->p_display->format->Gmask;
 886         p_vout->output.i_bmask = p_vout->p_sys->p_display->format->Bmask;
 887
 888         SDL_WM_SetCaption( VOUT_TITLE " (software RGB SDL output)",
 889                            VOUT_TITLE " (software RGB SDL output)" );
 890     }
 891     else
 892     {
 893         if( p_vout->p_sys->p_overlay->hw_overlay )
 894         {
 895             SDL_WM_SetCaption( VOUT_TITLE " (hardware YUV SDL output)",
 896                                VOUT_TITLE " (hardware YUV SDL output)" );
 897         }
 898         else
 899         {
 900             SDL_WM_SetCaption( VOUT_TITLE " (software YUV SDL output)",
 901                                VOUT_TITLE " (software YUV SDL output)" );
 902         }
 903     }
 904
 905     SDL_EventState( SDL_KEYUP, SDL_IGNORE );               /* ignore keys up */
 906
 907     return VLC_SUCCESS;
 908 }
 909
 910 /*****************************************************************************
 911  * CloseDisplay: close and reset SDL device
 912  *****************************************************************************
 913  * This function returns all resources allocated by OpenDisplay and restore
 914  * the original state of the device.
 915  *****************************************************************************/
 916 static void CloseDisplay( vout_thread_t *p_vout )
 917 {
 918     SDL_FreeYUVOverlay( p_vout->p_sys->p_overlay );
 919     SDL_UnlockSurface ( p_vout->p_sys->p_display );
 920     SDL_FreeSurface( p_vout->p_sys->p_display );
 921 }
 922
 923 /*****************************************************************************
 924  * NewPicture: allocate a picture
 925  *****************************************************************************
 926  * Returns 0 on success, -1 otherwise
 927  *****************************************************************************/
 928 static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic )
 929 {
 930     int i_width  = p_vout->output.i_width;
 931     int i_height = p_vout->output.i_height;
 932
 933     if( p_vout->p_sys->p_overlay == NULL )
 934     {
 935         /* RGB picture */
 936         if( p_vout->p_sys->i_surfaces )
 937         {
 938             /* We already allocated this surface, return */
 939             return VLC_EGENERIC;
 940         }
 941
 942         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 943
 944         if( p_pic->p_sys == NULL )
 945         {
 946             return VLC_ENOMEM;
 947         }
 948
 949         switch( p_vout->p_sys->p_display->format->BitsPerPixel )
 950         {
 951             case 8:
 952                 p_pic->p->i_pixel_pitch = 1;
 953                 break;
 954             case 15:
 955             case 16:
 956                 p_pic->p->i_pixel_pitch = 2;
 957                 break;
 958             case 24:
 959             case 32:
 960                 p_pic->p->i_pixel_pitch = 4;
 961                 break;
 962             default:
 963                 return VLC_EGENERIC;
 964         }
 965
 966         p_pic->p->p_pixels = p_vout->p_sys->p_display->pixels;
 967         p_pic->p->i_lines = p_vout->p_sys->p_display->h;
 968         p_pic->p->i_visible_lines = p_vout->p_sys->p_display->h;
 969         p_pic->p->i_pitch = p_vout->p_sys->p_display->pitch;
 970         p_pic->p->i_visible_pitch =
 971             p_pic->p->i_pixel_pitch * p_vout->p_sys->p_display->w;
 972
 973         p_vout->p_sys->i_surfaces++;
 974
 975         p_pic->i_planes = 1;
 976     }
 977     else
 978     {
 979         p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
 980
 981         if( p_pic->p_sys == NULL )
 982         {
 983             return VLC_ENOMEM;
 984         }
 985
 986         p_pic->p_sys->p_overlay =
 987             SDL_CreateYUVOverlay( i_width, i_height,
 988                                   p_vout->output.i_chroma,
 989                                   p_vout->p_sys->p_display );
 990
 991         if( p_pic->p_sys->p_overlay == NULL )
 992         {
 993             free( p_pic->p_sys );
 994             return VLC_EGENERIC;
 995         }
 996
 997         SDL_LockYUVOverlay( p_pic->p_sys->p_overlay );
 998
 999         p_pic->Y_PIXELS = p_pic->p_sys->p_overlay->pixels[0];
1000         p_pic->p[Y_PLANE].i_lines = p_pic->p_sys->p_overlay->h;
1001         p_pic->p[Y_PLANE].i_visible_lines = p_pic->p_sys->p_overlay->h;
1002         p_pic->p[Y_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[0];
1003
1004         switch( p_vout->output.i_chroma )
1005         {
1006         case SDL_YV12_OVERLAY:
1007             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
1008             p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w;
1009
1010             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
1011             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
1012             p_pic->p[U_PLANE].i_visible_lines = p_pic->p_sys->p_overlay->h / 2;
1013             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
1014             p_pic->p[U_PLANE].i_pixel_pitch = 1;
1015             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
1016
1017             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
1018             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
1019             p_pic->p[V_PLANE].i_visible_lines = p_pic->p_sys->p_overlay->h / 2;
1020             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
1021             p_pic->p[V_PLANE].i_pixel_pitch = 1;
1022             p_pic->p[V_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
1023
1024             p_pic->i_planes = 3;
1025             break;
1026
1027         case SDL_IYUV_OVERLAY:
1028             p_pic->p[Y_PLANE].i_pixel_pitch = 1;
1029             p_pic->p[Y_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w;
1030
1031             p_pic->U_PIXELS = p_pic->p_sys->p_overlay->pixels[1];
1032             p_pic->p[U_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
1033             p_pic->p[U_PLANE].i_visible_lines = p_pic->p_sys->p_overlay->h / 2;
1034             p_pic->p[U_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[1];
1035             p_pic->p[U_PLANE].i_pixel_pitch = 1;
1036             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
1037
1038             p_pic->V_PIXELS = p_pic->p_sys->p_overlay->pixels[2];
1039             p_pic->p[V_PLANE].i_lines = p_pic->p_sys->p_overlay->h / 2;
1040             p_pic->p[V_PLANE].i_visible_lines = p_pic->p_sys->p_overlay->h / 2;
1041             p_pic->p[V_PLANE].i_pitch = p_pic->p_sys->p_overlay->pitches[2];
1042             p_pic->p[V_PLANE].i_pixel_pitch = 1;
1043             p_pic->p[V_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w / 2;
1044
1045             p_pic->i_planes = 3;
1046             break;
1047
1048         default:
1049             p_pic->p[Y_PLANE].i_pixel_pitch = 2;
1050             p_pic->p[U_PLANE].i_visible_pitch = p_pic->p_sys->p_overlay->w * 2;
1051
1052             p_pic->i_planes = 1;
1053             break;
1054         }
1055     }
1056
1057     return VLC_SUCCESS;
1058 }
1059
1060 /*****************************************************************************
1061  * SetPalette: sets an 8 bpp palette
1062  *****************************************************************************/
1063 static void SetPalette( vout_thread_t *p_vout,
1064                         uint16_t *red, uint16_t *green, uint16_t *blue )
1065 {
1066     SDL_Color colors[256];
1067     int i;
1068
1069     /* Fill colors with color information */
1070     for( i = 0; i < 256; i++ )
1071     {
1072         colors[ i ].r = red[ i ] >> 8;
1073         colors[ i ].g = green[ i ] >> 8;
1074         colors[ i ].b = blue[ i ] >> 8;
1075     }
1076
1077     /* Set palette */
1078     if( SDL_SetColors( p_vout->p_sys->p_display, colors, 0, 256 ) == 0 )
1079     {
1080         msg_Err( p_vout, "failed to set palette" );
1081     }
1082 }
1083