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 #if defined (HAVE_MAEMO)
  90 # define BUTTON_DEFAULT "left"
  91 #else
  92 # define BUTTON_DEFAULT "right"
  93 #endif
  94
  95 static const char *const button_list[] = { "left", "middle", "right" };
  96 static const char *const button_list_text[] =
  97                                    { N_("Left"), N_("Middle"), N_("Right") };
  98
  99 vlc_module_begin ()
 100     set_shortname( N_("Gestures"))
 101     set_category( CAT_INTERFACE )
 102     set_subcategory( SUBCAT_INTERFACE_CONTROL )
 103     add_integer( "gestures-threshold", 30, NULL,
 104                  THRESHOLD_TEXT, THRESHOLD_LONGTEXT, true )
 105     add_string( "gestures-button", BUTTON_DEFAULT,
 106                 BUTTON_TEXT, BUTTON_LONGTEXT, false )
 107         change_string_list( button_list, button_list_text, 0 )
 108     set_description( N_("Mouse gestures control interface") )
 109
 110     set_capability( "interface", 0 )
 111     set_callbacks( Open, Close )
 112 vlc_module_end ()
 113
 114 /*****************************************************************************
 115  * OpenIntf: initialize interface
 116  *****************************************************************************/
 117 int Open ( vlc_object_t *p_this )
 118 {
 119     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 120
 121     /* Allocate instance and initialize some members */
 122     intf_sys_t *p_sys = p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
 123     if( p_intf->p_sys == NULL )
 124         return VLC_ENOMEM;
 125
 126     // Configure the module
 127     p_intf->pf_run = RunIntf;
 128
 129     vlc_mutex_init( &p_sys->lock );
 130     p_sys->p_vout = NULL;
 131     p_sys->b_got_gesture = false;
 132     p_sys->b_button_pressed = false;
 133     p_sys->i_threshold = var_InheritInteger( p_intf, "gestures-threshold" );
 134
 135     // Choose the tight button to use
 136     char *psz_button = var_InheritString( p_intf, "gestures-button" );
 137     if( psz_button && !strcmp( psz_button, "left" ) )
 138         p_sys->i_button_mask = 1;
 139     else if( psz_button && !strcmp( psz_button, "middle" ) )
 140         p_sys->i_button_mask = 2;
 141     else // psz_button == "right"
 142         p_sys->i_button_mask = 4;
 143     free( psz_button );
 144
 145     p_sys->i_pattern = 0;
 146     p_sys->i_num_gestures = 0;
 147
 148     return VLC_SUCCESS;
 149 }
 150
 151 /*****************************************************************************
 152  * gesture: return a subpattern within a pattern
 153  *****************************************************************************/
 154 static int gesture( int i_pattern, int i_num )
 155 {
 156     return ( i_pattern >> ( i_num * 4 ) ) & 0xF;
 157 }
 158
 159 /*****************************************************************************
 160  * CloseIntf: destroy dummy interface
 161  *****************************************************************************/
 162 void Close ( vlc_object_t *p_this )
 163 {
 164     intf_thread_t *p_intf = (intf_thread_t *)p_this;
 165
 166     // Destroy the callbacks
 167     if( p_intf->p_sys->p_vout )
 168     {
 169         var_DelCallback( p_intf->p_sys->p_vout, "mouse-moved",
 170                          MouseEvent, p_intf );
 171         var_DelCallback( p_intf->p_sys->p_vout, "mouse-button-down",
 172                          MouseEvent, p_intf );
 173         vlc_object_release( p_intf->p_sys->p_vout );
 174     }
 175
 176     /* Destroy structure */
 177     vlc_mutex_destroy( &p_intf->p_sys->lock );
 178     free( p_intf->p_sys );
 179 }
 180
 181
 182 /*****************************************************************************
 183  * RunIntf: main loop
 184  *****************************************************************************/
 185 static void RunIntf( intf_thread_t *p_intf )
 186 {
 187     intf_sys_t *p_sys = p_intf->p_sys;
 188     int canc = vlc_savecancel();
 189     input_thread_t *p_input;
 190
 191     /* Main loop */
 192     while( vlc_object_alive( p_intf ) )
 193     {
 194         vlc_mutex_lock( &p_sys->lock );
 195
 196         /*
 197          * mouse cursor
 198          */
 199         if( p_sys->b_got_gesture )
 200         {
 201             int i_interval = 0;
 202             /* Do something */
 203             /* If you modify this, please try to follow this convention:
 204                Start with LEFT, RIGHT for playback related commands
 205                and UP, DOWN, for other commands */
 206             playlist_t * p_playlist = pl_Get( p_intf );
 207             switch( p_sys->i_pattern )
 208             {
 209             case LEFT:
 210                 msg_Dbg( p_intf, "Go backward in the movie!" );
 211                 p_input = playlist_CurrentInput( p_playlist );
 212                 if( p_input )
 213                 {
 214                     i_interval = var_InheritInteger( p_intf , "short-jump-size" );
 215                     if ( i_interval > 0 )
 216                     {
 217                         mtime_t i_time = ( (mtime_t)( -i_interval ) * 1000000L);
 218                         var_SetTime( p_input, "time-offset", i_time );
 219                     }
 220                     vlc_object_release( p_input );
 221                 }
 222                 break;
 223
 224             case RIGHT:
 225                 msg_Dbg( p_intf, "Go forward in the movie!" );
 226                 p_input = playlist_CurrentInput( p_playlist );
 227                 if( p_input )
 228                 {
 229                     i_interval = var_InheritInteger( p_intf , "short-jump-size" );
 230                     if ( i_interval > 0 )
 231                     {
 232                         mtime_t i_time = ( (mtime_t)( i_interval ) * 1000000L);
 233                         var_SetTime( p_input, "time-offset", i_time );
 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                 var_TriggerCallback( p_playlist, "rate-slower" );
 242                 break;
 243
 244             case GESTURE(RIGHT,UP,NONE,NONE):
 245                 msg_Dbg( p_intf, "Going faster." );
 246                 var_TriggerCallback( p_playlist, "rate-faster" );
 247                 break;
 248
 249             case GESTURE(LEFT,RIGHT,NONE,NONE):
 250             case GESTURE(RIGHT,LEFT,NONE,NONE):
 251                 msg_Dbg( p_intf, "Play/Pause" );
 252                 p_input = playlist_CurrentInput( p_playlist );
 253
 254                 if( p_input )
 255                 {
 256                     int i_state = var_GetInteger( p_input, "state" );
 257                     var_SetInteger( p_input, "state", ( i_state != PLAYING_S )
 258                                                       ? PLAYING_S : PAUSE_S );
 259                     vlc_object_release( p_input );
 260                 }
 261                 break;
 262
 263             case GESTURE(LEFT,DOWN,NONE,NONE):
 264                 playlist_Prev( p_playlist );
 265                 break;
 266
 267             case GESTURE(RIGHT,DOWN,NONE,NONE):
 268                 playlist_Next( p_playlist );
 269                 break;
 270
 271             case UP:
 272                 msg_Dbg(p_intf, "Louder");
 273                 aout_VolumeUp( p_playlist, 1, NULL );
 274                 break;
 275
 276             case DOWN:
 277                 msg_Dbg(p_intf, "Quieter");
 278                 aout_VolumeDown( p_playlist, 1, NULL );
 279                 break;
 280
 281             case GESTURE(UP,DOWN,NONE,NONE):
 282             case GESTURE(DOWN,UP,NONE,NONE):
 283                 msg_Dbg( p_intf, "Mute sound" );
 284                 aout_ToggleMute( p_playlist, NULL );
 285                 break;
 286
 287             case GESTURE(UP,RIGHT,NONE,NONE):
 288                 {
 289                     vlc_value_t list, list2;
 290                     int i_count, i, i_audio_es;
 291
 292                     p_input = playlist_CurrentInput( p_playlist );
 293                     if( !p_input )
 294                         break;
 295
 296                     i_audio_es = var_GetInteger( p_input, "audio-es" );
 297                     var_Change( p_input, "audio-es", VLC_VAR_GETCHOICES,
 298                                 &list, &list2 );
 299                     i_count = list.p_list->i_count;
 300                     if( i_count <= 1 )
 301                     {
 302                         var_FreeList( &list, &list2 );
 303                         vlc_object_release( p_input );
 304                         break;
 305                     }
 306                     for( i = 0; i < i_count; i++ )
 307                     {
 308                         if( i_audio_es == list.p_list->p_values[i].i_int )
 309                             break;
 310                     }
 311                     /* value of audio-es was not in choices list */
 312                     if( i == i_count )
 313                     {
 314                         msg_Warn( p_input,
 315                                   "invalid current audio track, selecting 0" );
 316                         i = 0;
 317                     }
 318                     else if( i == i_count - 1 )
 319                         i = 1;
 320                     else
 321                         i++;
 322                     var_SetInteger( p_input, "audio-es", list.p_list->p_values[i].i_int );
 323                     var_FreeList( &list, &list2 );
 324                     vlc_object_release( p_input );
 325                 }
 326                 break;
 327             case GESTURE(DOWN,RIGHT,NONE,NONE):
 328                 {
 329                     vlc_value_t list, list2;
 330                     int i_count, i, i_spu_es;
 331
 332                     p_input = playlist_CurrentInput( p_playlist );
 333                     if( !p_input )
 334                         break;
 335
 336                     i_spu_es = var_GetInteger( p_input, "spu-es" );
 337
 338                     var_Change( p_input, "spu-es", VLC_VAR_GETCHOICES,
 339                             &list, &list2 );
 340                     i_count = list.p_list->i_count;
 341                     if( i_count <= 1 )
 342                     {
 343                         vlc_object_release( p_input );
 344                         var_FreeList( &list, &list2 );
 345                         break;
 346                     }
 347                     for( i = 0; i < i_count; i++ )
 348                     {
 349                         if( i_spu_es == list.p_list->p_values[i].i_int )
 350                         {
 351                             break;
 352                         }
 353                     }
 354                     /* value of spu-es was not in choices list */
 355                     if( i == i_count )
 356                     {
 357                         msg_Warn( p_input,
 358                                 "invalid current subtitle track, selecting 0" );
 359                         i = 0;
 360                     }
 361                     else if( i == i_count - 1 )
 362                         i = 0;
 363                     else
 364                         i++;
 365                     var_SetInteger( p_input, "spu-es", list.p_list->p_values[i].i_int);
 366                     var_FreeList( &list, &list2 );
 367                     vlc_object_release( p_input );
 368                 }
 369                 break;
 370
 371             case GESTURE(UP,LEFT,NONE,NONE):
 372             {
 373                 bool val = var_ToggleBool( pl_Get( p_intf ), "fullscreen" );
 374                 if( p_sys->p_vout )
 375                     var_SetBool( p_sys->p_vout, "fullscreen", val );
 376                 break;
 377            }
 378
 379             case GESTURE(DOWN,LEFT,NONE,NONE):
 380                 /* FIXME: Should close the vout!"*/
 381                 libvlc_Quit( p_intf->p_libvlc );
 382                 break;
 383             case GESTURE(DOWN,LEFT,UP,RIGHT):
 384             case GESTURE(UP,RIGHT,DOWN,LEFT):
 385                 msg_Dbg( p_intf, "a square was drawn!" );
 386                 break;
 387             default:
 388                 break;
 389             }
 390             p_sys->i_num_gestures = 0;
 391             p_sys->i_pattern = 0;
 392             p_sys->b_got_gesture = false;
 393         }
 394
 395         /*
 396          * video output
 397          */
 398         if( p_sys->p_vout && !vlc_object_alive( p_sys->p_vout ) )
 399         {
 400             var_DelCallback( p_sys->p_vout, "mouse-moved",
 401                              MouseEvent, p_intf );
 402             var_DelCallback( p_sys->p_vout, "mouse-button-down",
 403                              MouseEvent, p_intf );
 404             vlc_object_release( p_sys->p_vout );
 405             p_sys->p_vout = NULL;
 406         }
 407
 408         if( p_sys->p_vout == NULL )
 409         {
 410             p_input = playlist_CurrentInput( pl_Get( p_intf ) );
 411             if( p_input )
 412             {
 413                 p_sys->p_vout = input_GetVout( p_input );
 414                 vlc_object_release( p_input );
 415             }
 416             if( p_sys->p_vout )
 417             {
 418                 var_AddCallback( p_sys->p_vout, "mouse-moved",
 419                                  MouseEvent, p_intf );
 420                 var_AddCallback( p_sys->p_vout, "mouse-button-down",
 421                                  MouseEvent, p_intf );
 422             }
 423         }
 424
 425         vlc_mutex_unlock( &p_sys->lock );
 426
 427         /* Wait a bit */
 428         msleep( INTF_IDLE_SLEEP );
 429     }
 430
 431     vlc_restorecancel( canc );
 432 }
 433
 434 /*****************************************************************************
 435  * MouseEvent: callback for mouse events
 436  *****************************************************************************/
 437 static int MouseEvent( vlc_object_t *p_this, char const *psz_var,
 438                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 439 {
 440     VLC_UNUSED(p_this); VLC_UNUSED(oldval);
 441     int pattern = 0;
 442
 443     signed int i_horizontal, i_vertical;
 444     intf_thread_t *p_intf = (intf_thread_t *)p_data;
 445     intf_sys_t    *p_sys = p_intf->p_sys;
 446
 447     vlc_mutex_lock( &p_sys->lock );
 448
 449     /* don't process new gestures before the last events are processed */
 450     if( p_sys->b_got_gesture )
 451     {
 452         vlc_mutex_unlock( &p_sys->lock );
 453         return VLC_SUCCESS;
 454     }
 455
 456     if( !strcmp( psz_var, "mouse-moved" ) && p_sys->b_button_pressed )
 457     {
 458         p_sys->i_mouse_x = newval.coords.x;
 459         p_sys->i_mouse_y = newval.coords.y;
 460         i_horizontal = p_sys->i_mouse_x - p_sys->i_last_x;
 461         i_horizontal = i_horizontal / p_sys->i_threshold;
 462         i_vertical = p_sys->i_mouse_y - p_sys->i_last_y;
 463         i_vertical = i_vertical / p_sys->i_threshold;
 464
 465         if( i_horizontal < 0 )
 466         {
 467             msg_Dbg( p_intf, "left gesture (%d)", i_horizontal );
 468             pattern = LEFT;
 469         }
 470         else if( i_horizontal > 0 )
 471         {
 472             msg_Dbg( p_intf, "right gesture (%d)", i_horizontal );
 473             pattern = RIGHT;
 474         }
 475         if( i_vertical < 0 )
 476         {
 477             msg_Dbg( p_intf, "up gesture (%d)", i_vertical );
 478             pattern = UP;
 479         }
 480         else if( i_vertical > 0 )
 481         {
 482             msg_Dbg( p_intf, "down gesture (%d)", i_vertical );
 483             pattern = DOWN;
 484         }
 485         if( pattern )
 486         {
 487             p_sys->i_last_y = p_sys->i_mouse_y;
 488             p_sys->i_last_x = p_sys->i_mouse_x;
 489             if( gesture( p_sys->i_pattern, p_sys->i_num_gestures - 1 )
 490                     != pattern )
 491             {
 492                 p_sys->i_pattern |= pattern << ( p_sys->i_num_gestures * 4 );
 493                 p_sys->i_num_gestures++;
 494             }
 495         }
 496
 497     }
 498     else if( !strcmp( psz_var, "mouse-button-down" ) )
 499     {
 500         if( (newval.i_int & p_sys->i_button_mask) && !p_sys->b_button_pressed )
 501         {
 502             p_sys->b_button_pressed = true;
 503             var_GetCoords( p_sys->p_vout, "mouse-moved",
 504                            &p_sys->i_last_x, &p_sys->i_last_y );
 505         }
 506         else if( !( newval.i_int & p_sys->i_button_mask ) && p_sys->b_button_pressed )
 507         {
 508             p_sys->b_button_pressed = false;
 509             p_sys->b_got_gesture = true;
 510         }
 511     }
 512
 513     vlc_mutex_unlock( &p_sys->lock );
 514
 515     return VLC_SUCCESS;
 516 }