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

   1 /*****************************************************************************
   2  * gestures.c: control vlc with mouse gestures
   3  *****************************************************************************
   4  * Copyright (C) 2004-2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Sigmund Augdal Helberg <dnumgis@videolan.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_interface.h>
  35 #include <vlc_vout.h>
  36 #include <vlc_aout.h>
  37 #include <vlc_playlist.h>
  38
  39 #ifdef HAVE_UNISTD_H
  40 #    include <unistd.h>
  41 #endif
  42
  43 /*****************************************************************************
  44  * intf_sys_t: description and status of interface
  45  *****************************************************************************/
  46 struct intf_sys_t
  47 {
  48     vlc_mutex_t         lock;
  49     vout_thread_t      *p_vout;
  50     bool                b_got_gesture;
  51     bool                b_button_pressed;
  52     int                 i_mouse_x, i_mouse_y;
  53     int                 i_last_x, i_last_y;
  54     unsigned int        i_pattern;
  55     int                 i_num_gestures;
  56     int                 i_threshold;
  57     int                 i_button_mask;
  58 };
  59
  60 /*****************************************************************************
  61  * Local prototypes.
  62  *****************************************************************************/
  63 #define UP 1
  64 #define DOWN 2
  65 #define LEFT 3
  66 #define RIGHT 4
  67 #define NONE 0
  68 #define GESTURE( a, b, c, d ) (a | ( b << 4 ) | ( c << 8 ) | ( d << 12 ))
  69
  70 int  Open   ( vlc_object_t * );
  71 void Close  ( vlc_object_t * );
  72 static int  MouseEvent     ( vlc_object_t *, char const *,
  73                              vlc_value_t, vlc_value_t, void * );
  74
  75 /* Exported functions */
  76 static void RunIntf        ( intf_thread_t *p_intf );
  77
  78 /*****************************************************************************
  79  * Module descriptor
  80  *****************************************************************************/
  81 #define THRESHOLD_TEXT N_( "Motion threshold (10-100)" )
  82 #define THRESHOLD_LONGTEXT N_( \
  83     "Amount of movement required for a mouse gesture to be recorded." )
  84
  85 #define BUTTON_TEXT N_( "Trigger button" )
  86 #define BUTTON_LONGTEXT N_( \
  87     "Trigger button for mouse gestures." )
  88
  89 static const char *const button_list[] = { "left", "middle", "right" };
  90 static const char *const button_list_text[] =
  91                                    { N_("Left"), N_("Middle"), N_("Right") };
  92
  93 vlc_module_begin ()
  94     set_shortname( N_("Gestures"))
  95     set_category( CAT_INTERFACE )
  96     set_subcategory( SUBCAT_INTERFACE_CONTROL )
  97     add_integer( "gestures-threshold", 30, NULL,
  98                  THRESHOLD_TEXT, THRESHOLD_LONGTEXT, true )
  99     add_string( "gestures-button", "right", NULL,
 100                 BUTTON_TEXT, BUTTON_LONGTEXT, false )
 101         change_string_list( button_list, button_list_text, 0 )
 102     set_description( N_("Mouse gestures control interface") )
 103
 104     set_capability( "interface", 0 )
 105     set_callbacks( Open, Close )
 106 vlc_module_end ()
 107
 108 /*****************************************************************************
 109  * OpenIntf: initialize interface
 110  *****************************************************************************/
 111 int Open ( vlc_object_t *p_this )
 112 {
 113     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 114
 115     /* Allocate instance and initialize some members */
 116     intf_sys_t *p_sys = p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
 117     if( p_intf->p_sys == NULL )
 118         return VLC_ENOMEM;
 119
 120     // Configure the module
 121     p_intf->pf_run = RunIntf;
 122
 123     vlc_mutex_init( &p_sys->lock );
 124     p_sys->p_vout = NULL;
 125     p_sys->b_got_gesture = false;
 126     p_sys->b_button_pressed = false;
 127     p_sys->i_threshold = config_GetInt( p_intf, "gestures-threshold" );
 128
 129     // Choose the tight button to use
 130     char *psz_button = config_GetPsz( p_intf, "gestures-button" );
 131     if( !strcmp( psz_button, "left" ) )
 132         p_sys->i_button_mask = 1;
 133     else if( !strcmp( psz_button, "middle" ) )
 134         p_sys->i_button_mask = 2;
 135     else // psz_button == "right"
 136         p_sys->i_button_mask = 4;
 137     free( psz_button );
 138
 139     p_sys->i_pattern = 0;
 140     p_sys->i_num_gestures = 0;
 141
 142     return VLC_SUCCESS;
 143 }
 144
 145 /*****************************************************************************
 146  * gesture: return a subpattern within a pattern
 147  *****************************************************************************/
 148 static int gesture( int i_pattern, int i_num )
 149 {
 150     return ( i_pattern >> ( i_num * 4 ) ) & 0xF;
 151 }
 152
 153 /*****************************************************************************
 154  * CloseIntf: destroy dummy interface
 155  *****************************************************************************/
 156 void Close ( vlc_object_t *p_this )
 157 {
 158     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 159
 160     // Destroy the callbacks
 161     if( p_intf->p_sys->p_vout )
 162     {
 163         var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
 164                          MouseEvent, p_intf );
 165         var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
 166                          MouseEvent, p_intf );
 167         vlc_object_release( p_intf->p_sys->p_vout );
 168     }
 169
 170     /* Destroy structure */
 171     vlc_mutex_destroy( &p_intf->p_sys->lock );
 172     free( p_intf->p_sys );
 173 }
 174
 175
 176 /*****************************************************************************
 177  * RunIntf: main loop
 178  *****************************************************************************/
 179 static void RunIntf( intf_thread_t *p_intf )
 180 {
 181     intf_sys_t *p_sys = p_intf->p_sys;
 182     playlist_t * p_playlist = NULL;
 183     int canc = vlc_savecancel();
 184     input_thread_t *p_input;
 185
 186     /* Main loop */
 187     while( vlc_object_alive( p_intf ) )
 188     {
 189         vlc_mutex_lock( &p_sys->lock );
 190
 191         /*
 192          * mouse cursor
 193          */
 194         if( p_sys->b_got_gesture )
 195         {
 196             vlc_value_t val;
 197             int i_interval = 0;
 198             /* Do something */
 199             /* If you modify this, please try to follow this convention:
 200                Start with LEFT, RIGHT for playback related commands
 201                and UP, DOWN, for other commands */
 202             switch( p_sys->i_pattern )
 203             {
 204             case LEFT:
 205                 msg_Dbg( p_intf, "Go backward in the movie!" );
 206                 p_playlist = pl_Hold( p_intf );
 207                 p_input = playlist_CurrentInput( p_playlist );
 208                 pl_Release( p_intf );
 209                 if( p_input )
 210                 {
 211                     i_interval = config_GetInt( p_intf , "short-jump-size" );
 212                     if ( i_interval > 0 )
 213                     {
 214                         val.i_time = ( (mtime_t)( -i_interval ) * 1000000L);
 215                         var_Set( p_input, "time-offset", val );
 216                     }
 217                     vlc_object_release( p_input );
 218                 }
 219                 break;
 220
 221             case RIGHT:
 222                 msg_Dbg( p_intf, "Go forward in the movie!" );
 223                 p_playlist = pl_Hold( p_intf );
 224                 p_input = playlist_CurrentInput( p_playlist );
 225                 pl_Release( p_intf );
 226
 227                 if( p_input )
 228                 {
 229                     i_interval = config_GetInt( p_intf , "short-jump-size" );
 230                     if ( i_interval > 0 )
 231                     {
 232                         val.i_time = ( (mtime_t)( i_interval ) * 1000000L);
 233                         var_Set( p_input, "time-offset", val );
 234                     }
 235                     vlc_object_release( p_input );
 236                 }
 237                 break;
 238
 239             case GESTURE(LEFT,UP,NONE,NONE):
 240                 msg_Dbg( p_intf, "Going slower." );
 241                 p_playlist = pl_Hold( p_intf );
 242                 p_input = playlist_CurrentInput( p_playlist );
 243                 pl_Release( p_intf );
 244                 if( p_input )
 245                 {
 246                     var_SetVoid( p_input, "rate-slower" );
 247                     vlc_object_release( p_input );
 248                 }
 249                 break;
 250
 251             case GESTURE(RIGHT,UP,NONE,NONE):
 252                 msg_Dbg( p_intf, "Going faster." );
 253                 p_playlist = pl_Hold( p_intf );
 254                 p_input = playlist_CurrentInput( p_playlist );
 255                 pl_Release( p_intf );
 256                 if( p_input )
 257                 {
 258                     var_SetVoid( p_input, "rate-faster" );
 259                     vlc_object_release( p_input );
 260                 }
 261                 break;
 262
 263             case GESTURE(LEFT,RIGHT,NONE,NONE):
 264             case GESTURE(RIGHT,LEFT,NONE,NONE):
 265                 msg_Dbg( p_intf, "Play/Pause" );
 266                 p_playlist = pl_Hold( p_intf );
 267                 p_input = playlist_CurrentInput( p_playlist );
 268                 pl_Release( p_intf );
 269
 270                 if( p_input )
 271                 {
 272                     var_Get( p_input, "state", &val);
 273                     val.i_int = ( val.i_int != PLAYING_S ) ? PLAYING_S : PAUSE_S;
 274                     var_Set( p_input, "state", val);
 275                     vlc_object_release( p_input );
 276                 }
 277                 break;
 278
 279             case GESTURE(LEFT,DOWN,NONE,NONE):
 280                 p_playlist = pl_Hold( p_intf );
 281                 playlist_Prev( p_playlist );
 282                 pl_Release( p_intf );
 283                 break;
 284
 285             case GESTURE(RIGHT,DOWN,NONE,NONE):
 286                 p_playlist = pl_Hold( p_intf );
 287                 playlist_Next( p_playlist );
 288                 pl_Release( p_intf );
 289                 break;
 290
 291             case UP:
 292                 msg_Dbg(p_intf, "Louder");
 293                 aout_VolumeUp( p_intf, 1, NULL );
 294                 break;
 295
 296             case DOWN:
 297                 msg_Dbg(p_intf, "Quieter");
 298                 aout_VolumeDown( p_intf, 1, NULL );
 299                 break;
 300
 301             case GESTURE(UP,DOWN,NONE,NONE):
 302             case GESTURE(DOWN,UP,NONE,NONE):
 303                 msg_Dbg( p_intf, "Mute sound" );
 304                 aout_VolumeMute( p_intf, NULL );
 305                 break;
 306
 307             case GESTURE(UP,RIGHT,NONE,NONE):
 308                 {
 309                    vlc_value_t val, list, list2;
 310                    int i_count, i;
 311
 312                     p_playlist = pl_Hold( p_intf );
 313                     p_input = playlist_CurrentInput( p_playlist );
 314                     pl_Release( p_intf );
 315
 316                     if( !p_input )
 317                         break;
 318
 319                    var_Get( p_input, "audio-es", &val );
 320                    var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
 321                                &list, &list2 );
 322                    i_count = list.p_list->i_count;
 323                    if( i_count <= 1 )
 324                    {
 325                        vlc_object_release( p_input );
 326                        break;
 327                    }
 328                    for( i = 0; i < i_count; i++ )
 329                    {
 330                        if( val.i_int == list.p_list->p_values[i].i_int )
 331                            break;
 332                    }
 333                     /* value of audio-es was not in choices list */
 334                     if( i == i_count )
 335                     {
 336                         msg_Warn( p_input,
 337                                   "invalid current audio track, selecting 0" );
 338                         i = 0;
 339                     }
 340                     else if( i == i_count - 1 )
 341                         i = 1;
 342                     else
 343                         i++;
 344                     var_Set( p_input, "audio-es", list.p_list->p_values[i] );
 345                     vlc_object_release( p_input );
 346                 }
 347                 break;
 348             case GESTURE(DOWN,RIGHT,NONE,NONE):
 349                 {
 350                     vlc_value_t val, list, list2;
 351                     int i_count, i;
 352
 353                     p_playlist = pl_Hold( p_intf );
 354                     p_input = playlist_CurrentInput( p_playlist );
 355                     pl_Release( p_intf );
 356
 357                     if( !p_input )
 358                         break;
 359
 360                     var_Get( p_input, "spu-es", &val );
 361
 362                     var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
 363                             &list, &list2 );
 364                     i_count = list.p_list->i_count;
 365                     if( i_count <= 1 )
 366                     {
 367                         vlc_object_release( p_input );
 368                         break;
 369                     }
 370                     for( i = 0; i < i_count; i++ )
 371                     {
 372                         if( val.i_int == list.p_list->p_values[i].i_int )
 373                         {
 374                             break;
 375                         }
 376                     }
 377                     /* value of spu-es was not in choices list */
 378                     if( i == i_count )
 379                     {
 380                         msg_Warn( p_input,
 381                                 "invalid current subtitle track, selecting 0" );
 382                         i = 0;
 383                     }
 384                     else if( i == i_count - 1 )
 385                         i = 0;
 386                     else
 387                         i++;
 388                     var_Set( p_input, "spu-es", list.p_list->p_values[i] );
 389                     vlc_object_release( p_input );
 390                 }
 391                 break;
 392
 393             case GESTURE(UP,LEFT,NONE,NONE):
 394                 if( p_sys->p_vout )
 395                 {
 396                     var_Get( p_sys->p_vout, "fullscreen", &val );
 397                     val.b_bool = !val.b_bool;
 398                     var_Set( p_sys->p_vout, "fullscreen", val );
 399                 }
 400                 break;
 401
 402             case GESTURE(DOWN,LEFT,NONE,NONE):
 403                 /* FIXME: Should close the vout!"*/
 404                 libvlc_Quit( p_intf->p_libvlc );
 405                 break;
 406             case GESTURE(DOWN,LEFT,UP,RIGHT):
 407             case GESTURE(UP,RIGHT,DOWN,LEFT):
 408                 msg_Dbg( p_intf, "a square was drawn!" );
 409                 break;
 410             default:
 411                 break;
 412             }
 413             p_sys->i_num_gestures = 0;
 414             p_sys->i_pattern = 0;
 415             p_sys->b_got_gesture = false;
 416         }
 417
 418         /*
 419          * video output
 420          */
 421         if( p_sys->p_vout && !vlc_object_alive( p_sys->p_vout ) )
 422         {
 423             var_DelCallback( p_sys->p_vout, "mouse-moved",
 424                              MouseEvent, p_intf );
 425             var_DelCallback( p_sys->p_vout, "mouse-button-down",
 426                              MouseEvent, p_intf );
 427             vlc_object_release( p_sys->p_vout );
 428             p_sys->p_vout = NULL;
 429         }
 430
 431         if( p_sys->p_vout == NULL )
 432         {
 433             p_playlist = pl_Hold( p_intf );
 434             p_input = playlist_CurrentInput( p_playlist );
 435             pl_Release( p_intf );
 436             if( p_input )
 437             {
 438                 p_sys->p_vout = input_GetVout( p_input );
 439                 vlc_object_release( p_input );
 440             }
 441             if( p_sys->p_vout )
 442             {
 443                 var_AddCallback( p_sys->p_vout, "mouse-moved",
 444                                  MouseEvent, p_intf );
 445                 var_AddCallback( p_sys->p_vout, "mouse-button-down",
 446                                  MouseEvent, p_intf );
 447             }
 448         }
 449
 450         vlc_mutex_unlock( &p_sys->lock );
 451
 452         /* Wait a bit */
 453         msleep( INTF_IDLE_SLEEP );
 454     }
 455
 456     vlc_restorecancel( canc );
 457 }
 458
 459 /*****************************************************************************
 460  * MouseEvent: callback for mouse events
 461  *****************************************************************************/
 462 static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
 463                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 464 {
 465     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
 466     int pattern = 0;
 467
 468     signed int i_horizontal, i_vertical;
 469     intf_thread_t *p_intf = (intf_thread_t *)p_data;
 470     intf_sys_t    *p_sys = p_intf->p_sys;
 471
 472     vlc_mutex_lock( &p_sys->lock );
 473
 474     /* don't process new gestures before the last events are processed */
 475     if( p_sys->b_got_gesture )
 476     {
 477         vlc_mutex_unlock( &p_sys->lock );
 478         return VLC_SUCCESS;
 479     }
 480
 481     if( !strcmp( psz_var, "mouse-moved" ) && p_sys->b_button_pressed )
 482     {
 483         p_sys->i_mouse_x = var_GetInteger( p_sys->p_vout, "mouse-x" );
 484         p_sys->i_mouse_y = var_GetInteger( p_sys->p_vout, "mouse-y" );
 485         i_horizontal = p_sys->i_mouse_x - p_sys->i_last_x;
 486         i_horizontal = i_horizontal / p_sys->i_threshold;
 487         i_vertical = p_sys->i_mouse_y - p_sys->i_last_y;
 488         i_vertical = i_vertical / p_sys->i_threshold;
 489
 490         if( i_horizontal < 0 )
 491         {
 492             msg_Dbg( p_intf, "left gesture (%d)", i_horizontal );
 493             pattern = LEFT;
 494         }
 495         else if( i_horizontal > 0 )
 496         {
 497             msg_Dbg( p_intf, "right gesture (%d)", i_horizontal );
 498             pattern = RIGHT;
 499         }
 500         if( i_vertical < 0 )
 501         {
 502             msg_Dbg( p_intf, "up gesture (%d)", i_vertical );
 503             pattern = UP;
 504         }
 505         else if( i_vertical > 0 )
 506         {
 507             msg_Dbg( p_intf, "down gesture (%d)", i_vertical );
 508             pattern = DOWN;
 509         }
 510         if( pattern )
 511         {
 512             p_sys->i_last_y = p_sys->i_mouse_y;
 513             p_sys->i_last_x = p_sys->i_mouse_x;
 514             if( gesture( p_sys->i_pattern, p_sys->i_num_gestures - 1 )
 515                     != pattern )
 516             {
 517                 p_sys->i_pattern |= pattern << ( p_sys->i_num_gestures * 4 );
 518                 p_sys->i_num_gestures++;
 519             }
 520         }
 521
 522     }
 523     else if( !strcmp( psz_var, "mouse-button-down" ) )
 524     {
 525         if( (newval.i_int & p_sys->i_button_mask) && !p_sys->b_button_pressed )
 526         {
 527             p_sys->b_button_pressed = true;
 528             p_sys->i_last_x = var_GetInteger( p_sys->p_vout, "mouse-x" );
 529             p_sys->i_last_y = var_GetInteger( p_sys->p_vout, "mouse-y" );
 530         }
 531         else if( !( newval.i_int & p_sys->i_button_mask ) && p_sys->b_button_pressed )
 532         {
 533             p_sys->b_button_pressed = false;
 534             p_sys->b_got_gesture = true;
 535         }
 536     }
 537
 538     vlc_mutex_unlock( &p_sys->lock );
 539
 540     return VLC_SUCCESS;
 541 }