git.sesse.net Git - vlc/blob - modules/control/hotkeys.c

   1 /*****************************************************************************
   2  * hotkeys.c: Hotkey handling for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2005 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
   8  *          Jean-Paul Saman <jpsaman #_at_# m2x.nl>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>                                      /* malloc(), free() */
  29
  30 #include <vlc/vlc.h>
  31 #include <vlc/intf.h>
  32 #include <vlc/input.h>
  33 #include <vlc/vout.h>
  34 #include <vlc/aout.h>
  35 #include <vlc_osd.h>
  36
  37 #include "vlc_keys.h"
  38
  39 #define BUFFER_SIZE 10
  40
  41 #define CHANNELS_NUMBER 4
  42 #define VOLUME_TEXT_CHAN     p_intf->p_sys->p_channels[ 0 ]
  43 #define VOLUME_WIDGET_CHAN   p_intf->p_sys->p_channels[ 1 ]
  44 #define POSITION_TEXT_CHAN   p_intf->p_sys->p_channels[ 2 ]
  45 #define POSITION_WIDGET_CHAN p_intf->p_sys->p_channels[ 3 ]
  46 /*****************************************************************************
  47  * intf_sys_t: description and status of FB interface
  48  *****************************************************************************/
  49 struct intf_sys_t
  50 {
  51     vlc_mutex_t         change_lock;  /* mutex to keep the callback
  52                                        * and the main loop from
  53                                        * stepping on each others
  54                                        * toes */
  55     int                 p_keys[ BUFFER_SIZE ]; /* buffer that contains
  56                                                 * keyevents */
  57     int                 i_size;        /* number of events in buffer */
  58     int                 p_channels[ CHANNELS_NUMBER ]; /* contains registered
  59                                                         * channel IDs */
  60     input_thread_t *    p_input;       /* pointer to input */
  61     vout_thread_t *     p_vout;        /* pointer to vout object */
  62 };
  63
  64 /*****************************************************************************
  65  * Local prototypes
  66  *****************************************************************************/
  67 static int  Open    ( vlc_object_t * );
  68 static void Close   ( vlc_object_t * );
  69 static void Run     ( intf_thread_t * );
  70 static int  GetKey  ( intf_thread_t *);
  71 static int  KeyEvent( vlc_object_t *, char const *,
  72                       vlc_value_t, vlc_value_t, void * );
  73 static int  ActionKeyCB( vlc_object_t *, char const *,
  74                          vlc_value_t, vlc_value_t, void * );
  75 static void PlayBookmark( intf_thread_t *, int );
  76 static void SetBookmark ( intf_thread_t *, int );
  77 static void DisplayPosition( intf_thread_t *, vout_thread_t *, input_thread_t * );
  78 static void DisplayVolume  ( intf_thread_t *, vout_thread_t *, audio_volume_t );
  79 static void ClearChannels  ( intf_thread_t *, vout_thread_t * );
  80
  81 /*****************************************************************************
  82  * Module descriptor
  83  *****************************************************************************/
  84 #define BOOKMARK1_TEXT    N_("Playlist bookmark 1")
  85 #define BOOKMARK2_TEXT    N_("Playlist bookmark 2")
  86 #define BOOKMARK3_TEXT    N_("Playlist bookmark 3")
  87 #define BOOKMARK4_TEXT    N_("Playlist bookmark 4")
  88 #define BOOKMARK5_TEXT    N_("Playlist bookmark 5")
  89 #define BOOKMARK6_TEXT    N_("Playlist bookmark 6")
  90 #define BOOKMARK7_TEXT    N_("Playlist bookmark 7")
  91 #define BOOKMARK8_TEXT    N_("Playlist bookmark 8")
  92 #define BOOKMARK9_TEXT    N_("Playlist bookmark 9")
  93 #define BOOKMARK10_TEXT   N_("Playlist bookmark 10")
  94 #define BOOKMARK_LONGTEXT N_("Define playlist bookmarks.")
  95
  96 vlc_module_begin();
  97     set_shortname( _("Hotkeys") );
  98     set_description( _("Hotkeys management interface") );
  99     set_capability( "interface", 0 );
 100     set_callbacks( Open, Close );
 101 vlc_module_end();
 102
 103 /*****************************************************************************
 104  * Open: initialize interface
 105  *****************************************************************************/
 106 static int Open( vlc_object_t *p_this )
 107 {
 108     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 109     MALLOC_ERR( p_intf->p_sys, intf_sys_t );
 110
 111     vlc_mutex_init( p_intf, &p_intf->p_sys->change_lock );
 112     p_intf->p_sys->i_size = 0;
 113     p_intf->pf_run = Run;
 114
 115     p_intf->p_sys->p_input = NULL;
 116     p_intf->p_sys->p_vout = NULL;
 117
 118     var_AddCallback( p_intf->p_libvlc, "key-pressed", KeyEvent, p_intf );
 119     return VLC_SUCCESS;
 120 }
 121
 122 /*****************************************************************************
 123  * Close: destroy interface
 124  *****************************************************************************/
 125 static void Close( vlc_object_t *p_this )
 126 {
 127     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 128
 129     var_DelCallback( p_intf->p_libvlc, "key-pressed", KeyEvent, p_intf );
 130     if( p_intf->p_sys->p_input )
 131     {
 132         vlc_object_release( p_intf->p_sys->p_input );
 133     }
 134     if( p_intf->p_sys->p_vout )
 135     {
 136         vlc_object_release( p_intf->p_sys->p_vout );
 137     }
 138     /* Destroy structure */
 139     free( p_intf->p_sys );
 140 }
 141
 142 /*****************************************************************************
 143  * Run: main loop
 144  *****************************************************************************/
 145 static void Run( intf_thread_t *p_intf )
 146 {
 147     input_thread_t *p_input = NULL;
 148     vout_thread_t *p_vout = NULL;
 149     vout_thread_t *p_last_vout = NULL;
 150     struct hotkey *p_hotkeys = p_intf->p_libvlc->p_hotkeys;
 151     vlc_value_t val;
 152     int i;
 153     playlist_t *p_playlist = pl_Yield( p_intf );
 154
 155     /* Initialize hotkey structure */
 156     for( i = 0; p_hotkeys[i].psz_action != NULL; i++ )
 157     {
 158         var_Create( p_intf->p_libvlc, p_hotkeys[i].psz_action,
 159                     VLC_VAR_HOTKEY | VLC_VAR_DOINHERIT );
 160
 161         var_AddCallback( p_intf->p_libvlc, p_hotkeys[i].psz_action,
 162                          ActionKeyCB, NULL );
 163         var_Get( p_intf->p_libvlc, p_hotkeys[i].psz_action, &val );
 164         var_Set( p_intf->p_libvlc, p_hotkeys[i].psz_action, val );
 165     }
 166
 167     while( !p_intf->b_die )
 168     {
 169         int i_key, i_action;
 170         int i_times = 0;
 171
 172         /* Sleep a bit */
 173         msleep( INTF_IDLE_SLEEP );
 174
 175         /* Update the input */
 176         if( p_intf->p_sys->p_input == NULL )
 177         {
 178             PL_LOCK;
 179             p_intf->p_sys->p_input = p_playlist->p_input;
 180             if( p_intf->p_sys->p_input )
 181                 vlc_object_yield( p_intf->p_sys->p_input );
 182             PL_UNLOCK;
 183         }
 184         else if( p_intf->p_sys->p_input->b_dead )
 185         {
 186             vlc_object_release( p_intf->p_sys->p_input );
 187             p_intf->p_sys->p_input = NULL;
 188         }
 189         p_input = p_intf->p_sys->p_input;
 190
 191         /* Update the vout */
 192         p_last_vout = p_intf->p_sys->p_vout;
 193         if( p_vout == NULL )
 194         {
 195             p_vout = vlc_object_find( p_intf, VLC_OBJECT_VOUT, FIND_ANYWHERE );
 196             p_intf->p_sys->p_vout = p_vout;
 197         }
 198         else if( p_vout->b_die )
 199         {
 200             vlc_object_release( p_vout );
 201             p_vout = NULL;
 202             p_intf->p_sys->p_vout = NULL;
 203         }
 204
 205         /* Register OSD channels */
 206         if( p_vout && p_vout != p_last_vout )
 207         {
 208             for( i = 0; i < CHANNELS_NUMBER; i++ )
 209             {
 210                 spu_Control( p_vout->p_spu, SPU_CHANNEL_REGISTER,
 211                              &p_intf->p_sys->p_channels[ i ] );
 212             }
 213         }
 214
 215         /* Find action triggered by hotkey */
 216         i_action = 0;
 217         i_key = GetKey( p_intf );
 218         for( i = 0; i_key != -1 && p_hotkeys[i].psz_action != NULL; i++ )
 219         {
 220             if( p_hotkeys[i].i_key == i_key )
 221             {
 222                 i_action = p_hotkeys[i].i_action;
 223                 i_times  = p_hotkeys[i].i_times;
 224                 /* times key pressed within max. delta time */
 225                 p_hotkeys[i].i_times = 0;
 226             }
 227         }
 228
 229         if( !i_action )
 230         {
 231             /* No key pressed, sleep a bit more */
 232             msleep( INTF_IDLE_SLEEP );
 233             continue;
 234         }
 235
 236         if( i_action == ACTIONID_QUIT )
 237         {
 238             p_intf->p_libvlc->b_die = VLC_TRUE;
 239             ClearChannels( p_intf, p_vout );
 240             vout_OSDMessage( p_intf, DEFAULT_CHAN, _( "Quit" ) );
 241             continue;
 242         }
 243         else if( i_action == ACTIONID_VOL_UP )
 244         {
 245             audio_volume_t i_newvol;
 246             aout_VolumeUp( p_intf, 1, &i_newvol );
 247             DisplayVolume( p_intf, p_vout, i_newvol );
 248         }
 249         else if( i_action == ACTIONID_VOL_DOWN )
 250         {
 251             audio_volume_t i_newvol;
 252             aout_VolumeDown( p_intf, 1, &i_newvol );
 253             DisplayVolume( p_intf, p_vout, i_newvol );
 254         }
 255         else if( i_action == ACTIONID_VOL_MUTE )
 256         {
 257             audio_volume_t i_newvol = -1;
 258             aout_VolumeMute( p_intf, &i_newvol );
 259             if( p_vout )
 260             {
 261                 if( i_newvol == 0 )
 262                 {
 263                     ClearChannels( p_intf, p_vout );
 264                     vout_OSDIcon( VLC_OBJECT( p_intf ), DEFAULT_CHAN,
 265                                   OSD_MUTE_ICON );
 266                 }
 267                 else
 268                 {
 269                     DisplayVolume( p_intf, p_vout, i_newvol );
 270                 }
 271             }
 272         }
 273         else if( i_action == ACTIONID_INTF_SHOW )
 274             var_SetBool( p_playlist, "intf-show", VLC_TRUE );
 275         else if( i_action == ACTIONID_INTF_HIDE )
 276             var_SetBool( p_playlist, "intf-show", VLC_FALSE );
 277         else if( i_action == ACTIONID_SNAPSHOT )
 278         {
 279             if( p_vout ) vout_Control( p_vout, VOUT_SNAPSHOT );
 280         }
 281         else if( i_action == ACTIONID_FULLSCREEN )
 282         {
 283             if( p_vout )
 284             {
 285                 var_Get( p_vout, "fullscreen", &val );
 286                 val.b_bool = !val.b_bool;
 287                 var_Set( p_vout, "fullscreen", val );
 288             }
 289             else
 290             {
 291                 var_Get( p_playlist, "fullscreen", &val );
 292                 val.b_bool = !val.b_bool;
 293                 var_Set( p_playlist, "fullscreen", val );
 294             }
 295         }
 296         else if( i_action == ACTIONID_PLAY_PAUSE )
 297         {
 298             val.i_int = PLAYING_S;
 299             if( p_input )
 300             {
 301                 ClearChannels( p_intf, p_vout );
 302
 303                 var_Get( p_input, "state", &val );
 304                 if( val.i_int != PAUSE_S )
 305                 {
 306                     vout_OSDIcon( VLC_OBJECT( p_intf ), DEFAULT_CHAN,
 307                                   OSD_PAUSE_ICON );
 308                     val.i_int = PAUSE_S;
 309                 }
 310                 else
 311                 {
 312                     vout_OSDIcon( VLC_OBJECT( p_intf ), DEFAULT_CHAN,
 313                                   OSD_PLAY_ICON );
 314                     val.i_int = PLAYING_S;
 315                 }
 316                 var_Set( p_input, "state", val );
 317             }
 318             else
 319             {
 320                 playlist_Play( p_playlist );
 321             }
 322         }
 323         else if( p_input )
 324         {
 325             /* FIXME --fenrir
 326              * How to get a valid value ?
 327              * That's not that easy with some special stream
 328              */
 329             vlc_bool_t b_seekable = VLC_TRUE;
 330             int i_interval =0;
 331
 332             if( i_action == ACTIONID_PAUSE )
 333             {
 334                 var_Get( p_input, "state", &val );
 335                 if( val.i_int != PAUSE_S )
 336                 {
 337                     ClearChannels( p_intf, p_vout );
 338                     vout_OSDIcon( VLC_OBJECT( p_intf ), DEFAULT_CHAN,
 339                                   OSD_PAUSE_ICON );
 340                     val.i_int = PAUSE_S;
 341                     var_Set( p_input, "state", val );
 342                 }
 343             }
 344             else if( i_action == ACTIONID_JUMP_BACKWARD_EXTRASHORT
 345                      && b_seekable )
 346             {
 347 #define SET_TIME( a, b ) \
 348     i_interval = config_GetInt( p_input, a "-jump-size" ); \
 349     if( i_interval > 0 ) { \
 350         val.i_time = ( (mtime_t)(i_interval * b) * 1000000L \
 351                        * ((mtime_t)(1 << i_times))); \
 352         var_Set( p_input, "time-offset", val ); \
 353         DisplayPosition( p_intf, p_vout, p_input ); \
 354     }
 355                 SET_TIME( "extrashort", -1 );
 356             }
 357             else if( i_action == ACTIONID_JUMP_FORWARD_EXTRASHORT && b_seekable )
 358             {
 359                 SET_TIME( "extrashort", 1 );
 360             }
 361             else if( i_action == ACTIONID_JUMP_BACKWARD_SHORT && b_seekable )
 362             {
 363                 SET_TIME( "short", -1 );
 364             }
 365             else if( i_action == ACTIONID_JUMP_FORWARD_SHORT && b_seekable )
 366             {
 367                 SET_TIME( "short", 1 );
 368             }
 369             else if( i_action == ACTIONID_JUMP_BACKWARD_MEDIUM && b_seekable )
 370             {
 371                 SET_TIME( "medium", -1 );
 372             }
 373             else if( i_action == ACTIONID_JUMP_FORWARD_MEDIUM && b_seekable )
 374             {
 375                 SET_TIME( "medium", 1 );
 376             }
 377             else if( i_action == ACTIONID_JUMP_BACKWARD_LONG && b_seekable )
 378             {
 379                 SET_TIME( "long", -1 );
 380             }
 381             else if( i_action == ACTIONID_JUMP_FORWARD_LONG && b_seekable )
 382             {
 383                 SET_TIME( "long", 1 );
 384 #undef SET_TIME
 385             }
 386             else if( i_action == ACTIONID_AUDIO_TRACK )
 387             {
 388                 vlc_value_t val, list, list2;
 389                 int i_count, i;
 390                 var_Get( p_input, "audio-es", &val );
 391                 var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
 392                             &list, &list2 );
 393                 i_count = list.p_list->i_count;
 394                 if( i_count <= 1 )
 395                 {
 396                     continue;
 397                 }
 398                 for( i = 0; i < i_count; i++ )
 399                 {
 400                     if( val.i_int == list.p_list->p_values[i].i_int )
 401                     {
 402                         break;
 403                     }
 404                 }
 405                 /* value of audio-es was not in choices list */
 406                 if( i == i_count )
 407                 {
 408                     msg_Warn( p_input,
 409                               "invalid current audio track, selecting 0" );
 410                     var_Set( p_input, "audio-es",
 411                              list.p_list->p_values[0] );
 412                     i = 0;
 413                 }
 414                 else if( i == i_count - 1 )
 415                 {
 416                     var_Set( p_input, "audio-es",
 417                              list.p_list->p_values[1] );
 418                     i = 1;
 419                 }
 420                 else
 421                 {
 422                     var_Set( p_input, "audio-es",
 423                              list.p_list->p_values[i+1] );
 424                     i++;
 425                 }
 426                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 427                                  _("Audio track: %s"),
 428                                  list2.p_list->p_values[i].psz_string );
 429             }
 430             else if( i_action == ACTIONID_SUBTITLE_TRACK )
 431             {
 432                 vlc_value_t val, list, list2;
 433                 int i_count, i;
 434                 var_Get( p_input, "spu-es", &val );
 435
 436                 var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
 437                             &list, &list2 );
 438                 i_count = list.p_list->i_count;
 439                 if( i_count <= 1 )
 440                 {
 441                     vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 442                                      _("Subtitle track: %s"), _("N/A") );
 443                     continue;
 444                 }
 445                 for( i = 0; i < i_count; i++ )
 446                 {
 447                     if( val.i_int == list.p_list->p_values[i].i_int )
 448                     {
 449                         break;
 450                     }
 451                 }
 452                 /* value of spu-es was not in choices list */
 453                 if( i == i_count )
 454                 {
 455                     msg_Warn( p_input,
 456                               "invalid current subtitle track, selecting 0" );
 457                     var_Set( p_input, "spu-es", list.p_list->p_values[0] );
 458                     i = 0;
 459                 }
 460                 else if( i == i_count - 1 )
 461                 {
 462                     var_Set( p_input, "spu-es", list.p_list->p_values[0] );
 463                     i = 0;
 464                 }
 465                 else
 466                 {
 467                     var_Set( p_input, "spu-es", list.p_list->p_values[i+1] );
 468                     i = i + 1;
 469                 }
 470                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 471                                  _("Subtitle track: %s"),
 472                                  list2.p_list->p_values[i].psz_string );
 473             }
 474             else if( i_action == ACTIONID_ASPECT_RATIO && p_vout )
 475             {
 476                 vlc_value_t val={0}, val_list, text_list;
 477                 var_Get( p_vout, "aspect-ratio", &val );
 478                 if( var_Change( p_vout, "aspect-ratio", VLC_VAR_GETLIST,
 479                                 &val_list, &text_list ) >= 0 )
 480                 {
 481                     int i;
 482                     for( i = 0; i < val_list.p_list->i_count; i++ )
 483                     {
 484                         if( !strcmp( val_list.p_list->p_values[i].psz_string,
 485                                      val.psz_string ) )
 486                         {
 487                             i++;
 488                             break;
 489                         }
 490                     }
 491                     if( i == val_list.p_list->i_count ) i = 0;
 492                     var_SetString( p_vout, "aspect-ratio",
 493                                    val_list.p_list->p_values[i].psz_string );
 494                     vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 495                                      _("Aspect ratio: %s"),
 496                                      text_list.p_list->p_values[i].psz_string );
 497                 }
 498                 free( val.psz_string );
 499             }
 500             else if( i_action == ACTIONID_CROP && p_vout )
 501             {
 502                 vlc_value_t val={0}, val_list, text_list;
 503                 var_Get( p_vout, "crop", &val );
 504                 if( var_Change( p_vout, "crop", VLC_VAR_GETLIST,
 505                                 &val_list, &text_list ) >= 0 )
 506                 {
 507                     int i;
 508                     for( i = 0; i < val_list.p_list->i_count; i++ )
 509                     {
 510                         if( !strcmp( val_list.p_list->p_values[i].psz_string,
 511                                      val.psz_string ) )
 512                         {
 513                             i++;
 514                             break;
 515                         }
 516                     }
 517                     if( i == val_list.p_list->i_count ) i = 0;
 518                     var_SetString( p_vout, "crop",
 519                                    val_list.p_list->p_values[i].psz_string );
 520                     vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 521                                      _("Crop: %s"),
 522                                      text_list.p_list->p_values[i].psz_string );
 523                 }
 524                 free( val.psz_string );
 525             }
 526             else if( i_action == ACTIONID_DEINTERLACE && p_vout )
 527             {
 528                 vlc_value_t val={0}, val_list, text_list;
 529                 var_Get( p_vout, "deinterlace", &val );
 530                 if( var_Change( p_vout, "deinterlace", VLC_VAR_GETLIST,
 531                                 &val_list, &text_list ) >= 0 )
 532                 {
 533                     int i;
 534                     for( i = 0; i < val_list.p_list->i_count; i++ )
 535                     {
 536                         if( !strcmp( val_list.p_list->p_values[i].psz_string,
 537                                      val.psz_string ) )
 538                         {
 539                             i++;
 540                             break;
 541                         }
 542                     }
 543                     if( i == val_list.p_list->i_count ) i = 0;
 544                     var_SetString( p_vout, "deinterlace",
 545                                    val_list.p_list->p_values[i].psz_string );
 546                     vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 547                                      _("Deinterlace mode: %s"),
 548                                      text_list.p_list->p_values[i].psz_string );
 549                 }
 550                 free( val.psz_string );
 551             }
 552             else if( ( i_action == ACTIONID_ZOOM || i_action == ACTIONID_UNZOOM ) && p_vout )
 553             {
 554                 vlc_value_t val={0}, val_list, text_list;
 555                 var_Get( p_vout, "zoom", &val );
 556                 if( var_Change( p_vout, "zoom", VLC_VAR_GETLIST,
 557                                 &val_list, &text_list ) >= 0 )
 558                 {
 559                     int i;
 560                     for( i = 0; i < val_list.p_list->i_count; i++ )
 561                     {
 562                         if( val_list.p_list->p_values[i].f_float
 563                            == val.f_float )
 564                         {
 565                             if( i_action == ACTIONID_ZOOM )
 566                                 i++;
 567                             else /* ACTIONID_UNZOOM */
 568                                 i--;
 569                             break;
 570                         }
 571                     }
 572                     if( i == val_list.p_list->i_count ) i = 0;
 573                     if( i == -1 ) i = val_list.p_list->i_count-1;
 574                     var_SetFloat( p_vout, "zoom",
 575                                   val_list.p_list->p_values[i].f_float );
 576                     vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 577                                      _("Zoom mode: %s"),
 578                                 text_list.p_list->p_values[i].var.psz_name );
 579                 }
 580             }
 581             else if( i_action == ACTIONID_CROP_TOP && p_vout )
 582                 var_IncInteger( p_vout, "crop-top" );
 583             else if( i_action == ACTIONID_UNCROP_TOP && p_vout )
 584                 var_DecInteger( p_vout, "crop-top" );
 585             else if( i_action == ACTIONID_CROP_BOTTOM && p_vout )
 586                 var_IncInteger( p_vout, "crop-bottom" );
 587             else if( i_action == ACTIONID_UNCROP_BOTTOM && p_vout )
 588                  var_DecInteger( p_vout, "crop-bottom" );
 589             else if( i_action == ACTIONID_CROP_LEFT && p_vout )
 590                  var_IncInteger( p_vout, "crop-left" );
 591             else if( i_action == ACTIONID_UNCROP_LEFT && p_vout )
 592                  var_DecInteger( p_vout, "crop-left" );
 593             else if( i_action == ACTIONID_CROP_RIGHT && p_vout )
 594                  var_IncInteger( p_vout, "crop-right" );
 595             else if( i_action == ACTIONID_UNCROP_RIGHT && p_vout )
 596                  var_DecInteger( p_vout, "crop-right" );
 597
 598             else if( i_action == ACTIONID_NEXT )
 599             {
 600                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN, _("Next") );
 601                 playlist_Next( p_playlist );
 602             }
 603             else if( i_action == ACTIONID_PREV )
 604             {
 605                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 606                                  _("Previous") );
 607                 playlist_Prev( p_playlist );
 608             }
 609             else if( i_action == ACTIONID_STOP )
 610             {
 611                 playlist_Stop( p_playlist );
 612             }
 613             else if( i_action == ACTIONID_FASTER )
 614             {
 615                 var_SetVoid( p_input, "rate-faster" );
 616                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 617                                  _("Faster") );
 618             }
 619             else if( i_action == ACTIONID_SLOWER )
 620             {
 621                 var_SetVoid( p_input, "rate-slower" );
 622                 vout_OSDMessage( VLC_OBJECT(p_input), DEFAULT_CHAN,
 623                                  _("Slower") );
 624             }
 625             else if( i_action == ACTIONID_POSITION && b_seekable )
 626             {
 627                 DisplayPosition( p_intf, p_vout, p_input );
 628             }
 629             else if( i_action >= ACTIONID_PLAY_BOOKMARK1 &&
 630                      i_action <= ACTIONID_PLAY_BOOKMARK10 )
 631             {
 632                 PlayBookmark( p_intf, i_action - ACTIONID_PLAY_BOOKMARK1 + 1 );
 633             }
 634             else if( i_action >= ACTIONID_SET_BOOKMARK1 &&
 635                      i_action <= ACTIONID_SET_BOOKMARK10 )
 636             {
 637                 SetBookmark( p_intf, i_action - ACTIONID_SET_BOOKMARK1 + 1 );
 638             }
 639             /* Only makes sense with DVD */
 640             else if( i_action == ACTIONID_TITLE_PREV )
 641                 var_SetVoid( p_input, "prev-title" );
 642             else if( i_action == ACTIONID_TITLE_NEXT )
 643                 var_SetVoid( p_input, "next-title" );
 644             else if( i_action == ACTIONID_CHAPTER_PREV )
 645                 var_SetVoid( p_input, "prev-chapter" );
 646             else if( i_action == ACTIONID_CHAPTER_NEXT )
 647                 var_SetVoid( p_input, "next-chapter" );
 648             else if( i_action == ACTIONID_DISC_MENU )
 649                 var_SetInteger( p_input, "title  0", 2 );
 650
 651             else if( i_action == ACTIONID_SUBDELAY_DOWN )
 652             {
 653                 int64_t i_delay = var_GetTime( p_input, "spu-delay" );
 654                 i_delay -= 50000;    /* 50 ms */
 655                 var_SetTime( p_input, "spu-delay", i_delay );
 656                 ClearChannels( p_intf, p_vout );
 657                 vout_OSDMessage( p_intf, DEFAULT_CHAN, "Subtitle delay %i ms",
 658                                  (int)(i_delay/1000) );
 659             }
 660             else if( i_action == ACTIONID_SUBDELAY_UP )
 661             {
 662                 int64_t i_delay = var_GetTime( p_input, "spu-delay" );
 663                 i_delay += 50000;    /* 50 ms */
 664                 var_SetTime( p_input, "spu-delay", i_delay );
 665                 ClearChannels( p_intf, p_vout );
 666                 vout_OSDMessage( p_intf, DEFAULT_CHAN, "Subtitle delay %i ms",
 667                                  (int)(i_delay/1000) );
 668             }
 669             else if( i_action == ACTIONID_AUDIODELAY_DOWN )
 670             {
 671                 int64_t i_delay = var_GetTime( p_input, "audio-delay" );
 672                 i_delay -= 50000;    /* 50 ms */
 673                 var_SetTime( p_input, "audio-delay", i_delay );
 674                 ClearChannels( p_intf, p_vout );
 675                 vout_OSDMessage( p_intf, DEFAULT_CHAN, "Audio delay %i ms",
 676                                  (int)(i_delay/1000) );
 677             }
 678             else if( i_action == ACTIONID_AUDIODELAY_UP )
 679             {
 680                 int64_t i_delay = var_GetTime( p_input, "audio-delay" );
 681                 i_delay += 50000;    /* 50 ms */
 682                 var_SetTime( p_input, "audio-delay", i_delay );
 683                 ClearChannels( p_intf, p_vout );
 684                 vout_OSDMessage( p_intf, DEFAULT_CHAN, "Audio delay %i ms",
 685                                  (int)(i_delay/1000) );
 686             }
 687             else if( i_action == ACTIONID_PLAY )
 688             {
 689                 var_Get( p_input, "rate", &val );
 690                 if( val.i_int != INPUT_RATE_DEFAULT )
 691                 {
 692                     /* Return to normal speed */
 693                     var_SetInteger( p_input, "rate", INPUT_RATE_DEFAULT );
 694                 }
 695                 else
 696                 {
 697                     ClearChannels( p_intf, p_vout );
 698                     vout_OSDIcon( VLC_OBJECT( p_intf ), DEFAULT_CHAN,
 699                                   OSD_PLAY_ICON );
 700                     playlist_Play( p_playlist );
 701                 }
 702             }
 703         }
 704     }
 705     pl_Release( p_intf );
 706 }
 707
 708 static int GetKey( intf_thread_t *p_intf)
 709 {
 710     vlc_mutex_lock( &p_intf->p_sys->change_lock );
 711     if ( p_intf->p_sys->i_size == 0 )
 712     {
 713         vlc_mutex_unlock( &p_intf->p_sys->change_lock );
 714         return -1;
 715     }
 716     else
 717     {
 718         int i_return = p_intf->p_sys->p_keys[ 0 ];
 719         int i;
 720         p_intf->p_sys->i_size--;
 721         for ( i = 0; i < BUFFER_SIZE - 1; i++)
 722         {
 723             p_intf->p_sys->p_keys[ i ] = p_intf->p_sys->p_keys[ i + 1 ];
 724         }
 725         vlc_mutex_unlock( &p_intf->p_sys->change_lock );
 726         return i_return;
 727     }
 728 }
 729
 730 /*****************************************************************************
 731  * KeyEvent: callback for keyboard events
 732  *****************************************************************************/
 733 static int KeyEvent( vlc_object_t *p_this, char const *psz_var,
 734                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
 735 {
 736     intf_thread_t *p_intf = (intf_thread_t *)p_data;
 737     vlc_mutex_lock( &p_intf->p_sys->change_lock );
 738     if ( p_intf->p_sys->i_size == BUFFER_SIZE )
 739     {
 740         msg_Warn( p_intf, "event buffer full, dropping keypress" );
 741         vlc_mutex_unlock( &p_intf->p_sys->change_lock );
 742         return VLC_EGENERIC;
 743     }
 744     else
 745     {
 746         p_intf->p_sys->p_keys[ p_intf->p_sys->i_size ] = newval.i_int;
 747         p_intf->p_sys->i_size++;
 748     }
 749     vlc_mutex_unlock( &p_intf->p_sys->change_lock );
 750
 751     return VLC_SUCCESS;
 752 }
 753
 754 static int ActionKeyCB( vlc_object_t *p_this, char const *psz_var,
 755                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
 756 {
 757     libvlc_int_t *p_libvlc = (libvlc_int_t *)p_this;
 758     struct hotkey *p_hotkeys = p_libvlc->p_hotkeys;
 759     mtime_t i_date;
 760     int i;
 761
 762     for( i = 0; p_hotkeys[i].psz_action != NULL; i++ )
 763     {
 764         if( !strcmp( p_hotkeys[i].psz_action, psz_var ) )
 765         {
 766             p_hotkeys[i].i_key = newval.i_int;
 767             /* do hotkey accounting */
 768             i_date = mdate();
 769             if( (p_hotkeys[i].i_delta_date > 0) &&
 770                 (p_hotkeys[i].i_delta_date <= (i_date - p_hotkeys[i].i_last_date) ) )
 771                 p_hotkeys[i].i_times = 0;
 772             else
 773                 p_hotkeys[i].i_times++;
 774             p_hotkeys[i].i_last_date = i_date;
 775         }
 776     }
 777
 778     return VLC_SUCCESS;
 779 }
 780
 781 static void PlayBookmark( intf_thread_t *p_intf, int i_num )
 782 {
 783     vlc_value_t val;
 784     int i;
 785     char psz_bookmark_name[11];
 786     playlist_t *p_playlist = pl_Yield( p_intf );
 787
 788     sprintf( psz_bookmark_name, "bookmark%i", i_num );
 789     var_Create( p_intf, psz_bookmark_name, VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 790     var_Get( p_intf, psz_bookmark_name, &val );
 791
 792     char *psz_bookmark = strdup( val.psz_string );
 793     for( i = 0; i < p_playlist->i_size; i++)
 794     {
 795         if( !strcmp( psz_bookmark,
 796                      p_playlist->pp_items[i]->p_input->psz_uri ) )
 797         {
 798             playlist_LockControl( p_playlist, PLAYLIST_VIEWPLAY, NULL,
 799                                   p_playlist->pp_items[i] );
 800             break;
 801         }
 802     }
 803     vlc_object_release( p_playlist );
 804 }
 805
 806 static void SetBookmark( intf_thread_t *p_intf, int i_num )
 807 {
 808     playlist_t *p_playlist = pl_Yield( p_intf );
 809     char psz_bookmark_name[11];
 810     sprintf( psz_bookmark_name, "bookmark%i", i_num );
 811     var_Create( p_intf, psz_bookmark_name,
 812                 VLC_VAR_STRING|VLC_VAR_DOINHERIT );
 813     if( p_playlist->status.p_item )
 814     {
 815         config_PutPsz( p_intf, psz_bookmark_name,
 816                        p_playlist->status.p_item->p_input->psz_uri);
 817         msg_Info( p_intf, "setting playlist bookmark %i to %s", i_num,
 818                   p_playlist->status.p_item->p_input->psz_uri);
 819         config_SaveConfigFile( p_intf, "hotkeys" );
 820     }
 821     pl_Release( p_intf );
 822 }
 823
 824 static void DisplayPosition( intf_thread_t *p_intf, vout_thread_t *p_vout,
 825                              input_thread_t *p_input )
 826 {
 827     char psz_duration[MSTRTIME_MAX_SIZE];
 828     char psz_time[MSTRTIME_MAX_SIZE];
 829     vlc_value_t time, pos;
 830     mtime_t i_seconds;
 831
 832     if( p_vout == NULL ) return;
 833
 834     ClearChannels( p_intf, p_vout );
 835
 836     var_Get( p_input, "time", &time );
 837     i_seconds = time.i_time / 1000000;
 838     secstotimestr ( psz_time, i_seconds );
 839
 840     var_Get( p_input, "length", &time );
 841     if( time.i_time > 0 )
 842     {
 843         secstotimestr( psz_duration, time.i_time / 1000000 );
 844         vout_OSDMessage( p_input, POSITION_TEXT_CHAN, "%s / %s",
 845                          psz_time, psz_duration );
 846     }
 847     else if( i_seconds > 0 )
 848     {
 849         vout_OSDMessage( p_input, POSITION_TEXT_CHAN, psz_time );
 850     }
 851
 852     if( !p_vout->p_parent_intf || p_vout->b_fullscreen )
 853     {
 854         var_Get( p_input, "position", &pos );
 855         vout_OSDSlider( VLC_OBJECT( p_input ), POSITION_WIDGET_CHAN,
 856                         pos.f_float * 100, OSD_HOR_SLIDER );
 857     }
 858 }
 859
 860 static void DisplayVolume( intf_thread_t *p_intf, vout_thread_t *p_vout,
 861                            audio_volume_t i_vol )
 862 {
 863     if( p_vout == NULL )
 864     {
 865         return;
 866     }
 867     ClearChannels( p_intf, p_vout );
 868
 869     if( !p_vout->p_parent_intf || p_vout->b_fullscreen )
 870     {
 871         vout_OSDSlider( VLC_OBJECT( p_vout ), VOLUME_WIDGET_CHAN,
 872             i_vol*100/AOUT_VOLUME_MAX, OSD_VERT_SLIDER );
 873     }
 874     else
 875     {
 876         vout_OSDMessage( p_vout, VOLUME_TEXT_CHAN, "Volume %d%%",
 877                          i_vol*400/AOUT_VOLUME_MAX );
 878     }
 879 }
 880
 881 static void ClearChannels( intf_thread_t *p_intf, vout_thread_t *p_vout )
 882 {
 883     int i;
 884
 885     if( p_vout )
 886     {
 887         spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR, DEFAULT_CHAN );
 888         for( i = 0; i < CHANNELS_NUMBER; i++ )
 889         {
 890             spu_Control( p_vout->p_spu, SPU_CHANNEL_CLEAR,
 891                          p_intf->p_sys->p_channels[ i ] );
 892         }
 893     }
 894 }