That shouldn't have been part of the previous commit
[vlc.git] / modules / control / rc.c
1 /*****************************************************************************
2  * rc.c : remote control stdin/stdout module for vlc
3  *****************************************************************************
4  * Copyright (C) 2004-2007 the VideoLAN team
5  * $Id$
6  *
7  * Author: Peter Surda <shurdeek@panorama.sth.ac.at>
8  *         Jean-Paul Saman <jpsaman #_at_# m2x _replaceWith#dot_ 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 <vlc/vlc.h>
29
30
31 #include <errno.h>                                                 /* ENOMEM */
32 #include <ctype.h>
33 #include <signal.h>
34
35 #include <vlc_interface.h>
36 #include <vlc_aout.h>
37 #include <vlc_vout.h>
38 #include <vlc_osd.h>
39 #include <vlc_playlist.h>
40 #include <vlc_update.h>
41
42 #ifdef HAVE_UNISTD_H
43 #    include <unistd.h>
44 #endif
45
46 #ifdef HAVE_SYS_TIME_H
47 #    include <sys/time.h>
48 #endif
49 #include <sys/types.h>
50
51 #include <vlc_network.h>
52 #include "vlc_url.h"
53
54 #include <vlc_charset.h>
55
56 #if defined(AF_UNIX) && !defined(AF_LOCAL)
57 #    define AF_LOCAL AF_UNIX
58 #endif
59
60 #if defined(AF_LOCAL) && ! defined(WIN32)
61 #    include <sys/un.h>
62 #endif
63
64 #define MAX_LINE_LENGTH 256
65 #define STATUS_CHANGE "status change: "
66
67 /*****************************************************************************
68  * Local prototypes
69  *****************************************************************************/
70 static int  Activate     ( vlc_object_t * );
71 static void Deactivate   ( vlc_object_t * );
72 static void Run          ( intf_thread_t * );
73
74 static void Help         ( intf_thread_t *, vlc_bool_t );
75 static void RegisterCallbacks( intf_thread_t * );
76
77 static vlc_bool_t ReadCommand( intf_thread_t *, char *, int * );
78
79 static input_item_t *parse_MRL( intf_thread_t *, char * );
80
81 static int  Input        ( vlc_object_t *, char const *,
82                            vlc_value_t, vlc_value_t, void * );
83 static int  Playlist     ( vlc_object_t *, char const *,
84                            vlc_value_t, vlc_value_t, void * );
85 static int  Quit         ( vlc_object_t *, char const *,
86                            vlc_value_t, vlc_value_t, void * );
87 static int  Intf         ( vlc_object_t *, char const *,
88                            vlc_value_t, vlc_value_t, void * );
89 static int  Volume       ( vlc_object_t *, char const *,
90                            vlc_value_t, vlc_value_t, void * );
91 static int  VolumeMove   ( vlc_object_t *, char const *,
92                            vlc_value_t, vlc_value_t, void * );
93 static int  VideoConfig  ( vlc_object_t *, char const *,
94                            vlc_value_t, vlc_value_t, void * );
95 static int  AudioConfig  ( vlc_object_t *, char const *,
96                            vlc_value_t, vlc_value_t, void * );
97 static int  Menu         ( vlc_object_t *, char const *,
98                            vlc_value_t, vlc_value_t, void * );
99 static void checkUpdates( intf_thread_t *p_intf, char *psz_arg );
100
101 /* Status Callbacks */
102 static int TimeOffsetChanged( vlc_object_t *, char const *,
103                               vlc_value_t, vlc_value_t , void * );
104 static int VolumeChanged    ( vlc_object_t *, char const *,
105                               vlc_value_t, vlc_value_t, void * );
106 static int StateChanged     ( vlc_object_t *, char const *,
107                               vlc_value_t, vlc_value_t, void * );
108 static int RateChanged      ( vlc_object_t *, char const *,
109                               vlc_value_t, vlc_value_t, void * );
110
111 struct intf_sys_t
112 {
113     int *pi_socket_listen;
114     int i_socket;
115     char *psz_unix_path;
116
117     /* status changes */
118     vlc_mutex_t       status_lock;
119     playlist_status_t i_last_state;
120
121 #ifdef WIN32
122     HANDLE hConsoleIn;
123     vlc_bool_t b_quiet;
124 #endif
125 };
126
127 #ifdef HAVE_VARIADIC_MACROS
128 #   define msg_rc( psz_format, args... ) \
129       __msg_rc( p_intf, psz_format, ## args )
130 #endif
131
132 static void __msg_rc( intf_thread_t *p_intf, const char *psz_fmt, ... )
133 {
134     va_list args;
135     va_start( args, psz_fmt );
136
137     if( p_intf->p_sys->i_socket == -1 )
138     {
139         utf8_vfprintf( stdout, psz_fmt, args );
140         printf( "\r\n" );
141     }
142     else
143     {
144         net_vaPrintf( p_intf, p_intf->p_sys->i_socket, NULL, psz_fmt, args );
145         net_Write( p_intf, p_intf->p_sys->i_socket, NULL, (uint8_t*)"\r\n", 2 );
146     }
147     va_end( args );
148 }
149
150 /*****************************************************************************
151  * Module descriptor
152  *****************************************************************************/
153 #define POS_TEXT N_("Show stream position")
154 #define POS_LONGTEXT N_("Show the current position in seconds within the " \
155                         "stream from time to time." )
156
157 #define TTY_TEXT N_("Fake TTY")
158 #define TTY_LONGTEXT N_("Force the rc module to use stdin as if it was a TTY.")
159
160 #define UNIX_TEXT N_("UNIX socket command input")
161 #define UNIX_LONGTEXT N_("Accept commands over a Unix socket rather than " \
162                          "stdin." )
163
164 #define HOST_TEXT N_("TCP command input")
165 #define HOST_LONGTEXT N_("Accept commands over a socket rather than stdin. " \
166             "You can set the address and port the interface will bind to." )
167
168 #ifdef WIN32
169 #define QUIET_TEXT N_("Do not open a DOS command box interface")
170 #define QUIET_LONGTEXT N_( \
171     "By default the rc interface plugin will start a DOS command box. " \
172     "Enabling the quiet mode will not bring this command box but can also " \
173     "be pretty annoying when you want to stop VLC and no video window is " \
174     "open." )
175 #endif
176
177 vlc_module_begin();
178     set_shortname( _("RC"));
179     set_category( CAT_INTERFACE );
180     set_subcategory( SUBCAT_INTERFACE_MAIN );
181     set_description( _("Remote control interface") );
182     add_bool( "rc-show-pos", 0, NULL, POS_TEXT, POS_LONGTEXT, VLC_TRUE );
183
184 #ifdef WIN32
185     add_bool( "rc-quiet", 0, NULL, QUIET_TEXT, QUIET_LONGTEXT, VLC_FALSE );
186 #else
187 #if defined (HAVE_ISATTY)
188     add_bool( "rc-fake-tty", 0, NULL, TTY_TEXT, TTY_LONGTEXT, VLC_TRUE );
189 #endif
190     add_string( "rc-unix", 0, NULL, UNIX_TEXT, UNIX_LONGTEXT, VLC_TRUE );
191 #endif
192     add_string( "rc-host", 0, NULL, HOST_TEXT, HOST_LONGTEXT, VLC_TRUE );
193
194     set_capability( "interface", 20 );
195     set_callbacks( Activate, Deactivate );
196 vlc_module_end();
197
198 /*****************************************************************************
199  * Activate: initialize and create stuff
200  *****************************************************************************/
201 static int Activate( vlc_object_t *p_this )
202 {
203     intf_thread_t *p_intf = (intf_thread_t*)p_this;
204     char *psz_host, *psz_unix_path;
205     int  *pi_socket = NULL;
206
207 #ifndef WIN32
208 #if defined(HAVE_ISATTY)
209     /* Check that stdin is a TTY */
210     if( !config_GetInt( p_intf, "rc-fake-tty" ) && !isatty( 0 ) )
211     {
212         msg_Warn( p_intf, "fd 0 is not a TTY" );
213         return VLC_EGENERIC;
214     }
215 #endif
216
217     psz_unix_path = config_GetPsz( p_intf, "rc-unix" );
218     if( psz_unix_path )
219     {
220         int i_socket;
221
222 #ifndef AF_LOCAL
223         msg_Warn( p_intf, "your OS doesn't support filesystem sockets" );
224         free( psz_unix_path );
225         return VLC_EGENERIC;
226 #else
227         struct sockaddr_un addr;
228
229         memset( &addr, 0, sizeof(struct sockaddr_un) );
230
231         msg_Dbg( p_intf, "trying UNIX socket" );
232
233         if( (i_socket = socket( AF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
234         {
235             msg_Warn( p_intf, "can't open socket: %m" );
236             free( psz_unix_path );
237             return VLC_EGENERIC;
238         }
239
240         addr.sun_family = AF_LOCAL;
241         strncpy( addr.sun_path, psz_unix_path, sizeof( addr.sun_path ) );
242         addr.sun_path[sizeof( addr.sun_path ) - 1] = '\0';
243
244         if (bind (i_socket, (struct sockaddr *)&addr, sizeof (addr))
245          && (errno == EADDRINUSE)
246          && connect (i_socket, (struct sockaddr *)&addr, sizeof (addr))
247          && (errno == ECONNREFUSED))
248         {
249             msg_Info (p_intf, "Removing dead UNIX socket: %s", psz_unix_path);
250             unlink (psz_unix_path);
251
252             if (bind (i_socket, (struct sockaddr *)&addr, sizeof (addr)))
253             {
254                 msg_Err (p_intf, "cannot bind UNIX socket at %s: %m",
255                          psz_unix_path);
256                 free (psz_unix_path);
257                 net_Close (i_socket);
258                 return VLC_EGENERIC;
259             }
260         }
261
262         if( listen( i_socket, 1 ) )
263         {
264             msg_Warn( p_intf, "can't listen on socket: %m");
265             free( psz_unix_path );
266             net_Close( i_socket );
267             return VLC_EGENERIC;
268         }
269
270         /* FIXME: we need a core function to merge listening sockets sets */
271         pi_socket = calloc( 2, sizeof( int ) );
272         if( pi_socket == NULL )
273         {
274             free( psz_unix_path );
275             net_Close( i_socket );
276             return VLC_ENOMEM;
277         }
278         pi_socket[0] = i_socket;
279         pi_socket[1] = -1;
280 #endif /* AF_LOCAL */
281     }
282 #endif /* !WIN32 */
283
284     if( ( pi_socket == NULL ) &&
285         ( psz_host = config_GetPsz( p_intf, "rc-host" ) ) != NULL )
286     {
287         vlc_url_t url;
288
289         vlc_UrlParse( &url, psz_host, 0 );
290
291         msg_Dbg( p_intf, "base: %s, port: %d", url.psz_host, url.i_port );
292
293         pi_socket = net_ListenTCP(p_this, url.psz_host, url.i_port);
294         if( pi_socket == NULL )
295         {
296             msg_Warn( p_intf, "can't listen to %s port %i",
297                       url.psz_host, url.i_port );
298             vlc_UrlClean( &url );
299             free( psz_host );
300             return VLC_EGENERIC;
301         }
302
303         vlc_UrlClean( &url );
304         free( psz_host );
305     }
306
307     p_intf->p_sys = malloc( sizeof( intf_sys_t ) );
308     if( !p_intf->p_sys )
309     {
310         msg_Err( p_intf, "no memory" );
311         return VLC_ENOMEM;
312     }
313
314     p_intf->p_sys->pi_socket_listen = pi_socket;
315     p_intf->p_sys->i_socket = -1;
316     p_intf->p_sys->psz_unix_path = psz_unix_path;
317     vlc_mutex_init( p_intf, &p_intf->p_sys->status_lock );
318     p_intf->p_sys->i_last_state = PLAYLIST_STOPPED;
319
320     /* Non-buffered stdout */
321     setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
322
323     p_intf->pf_run = Run;
324
325 #ifdef WIN32
326     p_intf->p_sys->b_quiet = config_GetInt( p_intf, "rc-quiet" );
327     if( !p_intf->p_sys->b_quiet ) { CONSOLE_INTRO_MSG; }
328 #else
329     CONSOLE_INTRO_MSG;
330 #endif
331
332     msg_rc( _("Remote control interface initialized. Type `help' for help.") );
333     return VLC_SUCCESS;
334 }
335
336 /*****************************************************************************
337  * Deactivate: uninitialize and cleanup
338  *****************************************************************************/
339 static void Deactivate( vlc_object_t *p_this )
340 {
341     intf_thread_t *p_intf = (intf_thread_t*)p_this;
342
343     net_ListenClose( p_intf->p_sys->pi_socket_listen );
344     if( p_intf->p_sys->i_socket != -1 )
345         net_Close( p_intf->p_sys->i_socket );
346     if( p_intf->p_sys->psz_unix_path != NULL )
347     {
348 #if defined(AF_LOCAL) && !defined(WIN32)
349         unlink( p_intf->p_sys->psz_unix_path );
350 #endif
351         free( p_intf->p_sys->psz_unix_path );
352     }
353     vlc_mutex_destroy( &p_intf->p_sys->status_lock );
354     free( p_intf->p_sys );
355 }
356
357 /*****************************************************************************
358  * RegisterCallbacks: Register callbacks to dynamic variables
359  *****************************************************************************/
360 static void RegisterCallbacks( intf_thread_t *p_intf )
361 {
362     /* Register commands that will be cleaned up upon object destruction */
363 #define ADD( name, type, target )                                   \
364     var_Create( p_intf, name, VLC_VAR_ ## type | VLC_VAR_ISCOMMAND ); \
365     var_AddCallback( p_intf, name, target, NULL );
366     ADD( "quit", VOID, Quit )
367     ADD( "intf", STRING, Intf )
368
369     ADD( "add", STRING, Playlist )
370     ADD( "repeat", STRING, Playlist )
371     ADD( "loop", STRING, Playlist )
372     ADD( "enqueue", STRING, Playlist )
373     ADD( "playlist", VOID, Playlist )
374     ADD( "sort", VOID, Playlist )
375     ADD( "play", VOID, Playlist )
376     ADD( "stop", VOID, Playlist )
377     ADD( "clear", VOID, Playlist )
378     ADD( "prev", VOID, Playlist )
379     ADD( "next", VOID, Playlist )
380     ADD( "goto", INTEGER, Playlist )
381     ADD( "status", INTEGER, Playlist )
382
383     /* OSD menu commands */
384     ADD(  "menu", STRING, Menu )
385
386     /* DVD commands */
387     ADD( "pause", VOID, Input )
388     ADD( "seek", INTEGER, Input )
389     ADD( "title", STRING, Input )
390     ADD( "title_n", VOID, Input )
391     ADD( "title_p", VOID, Input )
392     ADD( "chapter", STRING, Input )
393     ADD( "chapter_n", VOID, Input )
394     ADD( "chapter_p", VOID, Input )
395
396     ADD( "fastforward", VOID, Input )
397     ADD( "rewind", VOID, Input )
398     ADD( "faster", VOID, Input )
399     ADD( "slower", VOID, Input )
400     ADD( "normal", VOID, Input )
401
402     ADD( "atrack", STRING, Input )
403     ADD( "vtrack", STRING, Input )
404     ADD( "strack", STRING, Input )
405
406     /* video commands */
407     ADD( "vratio", STRING, VideoConfig )
408     ADD( "vcrop", STRING, VideoConfig )
409     ADD( "vzoom", STRING, VideoConfig )
410
411     /* audio commands */
412     ADD( "volume", STRING, Volume )
413     ADD( "volup", STRING, VolumeMove )
414     ADD( "voldown", STRING, VolumeMove )
415     ADD( "adev", STRING, AudioConfig )
416     ADD( "achan", STRING, AudioConfig )
417
418 #undef ADD
419 }
420
421 /*****************************************************************************
422  * Run: rc thread
423  *****************************************************************************
424  * This part of the interface is in a separate thread so that we can call
425  * exec() from within it without annoying the rest of the program.
426  *****************************************************************************/
427 static void Run( intf_thread_t *p_intf )
428 {
429     input_thread_t * p_input;
430     playlist_t *     p_playlist;
431
432     char       p_buffer[ MAX_LINE_LENGTH + 1 ];
433     vlc_bool_t b_showpos = config_GetInt( p_intf, "rc-show-pos" );
434     vlc_bool_t b_longhelp = VLC_FALSE;
435
436     int        i_size = 0;
437     int        i_oldpos = 0;
438     int        i_newpos;
439
440     p_buffer[0] = 0;
441     p_input = NULL;
442     p_playlist = NULL;
443
444     /* Register commands that will be cleaned up upon object destruction */
445     RegisterCallbacks( p_intf );
446
447     /* status callbacks */
448     /* Listen to audio volume updates */
449     var_AddCallback( p_intf->p_libvlc, "volume-change", VolumeChanged, p_intf );
450
451 #ifdef WIN32
452     /* Get the file descriptor of the console input */
453     p_intf->p_sys->hConsoleIn = GetStdHandle(STD_INPUT_HANDLE);
454     if( p_intf->p_sys->hConsoleIn == INVALID_HANDLE_VALUE )
455     {
456         msg_Err( p_intf, "couldn't find user input handle" );
457         vlc_object_kill( p_intf );
458     }
459 #endif
460
461     while( !intf_ShouldDie( p_intf ) )
462     {
463         char *psz_cmd, *psz_arg;
464         vlc_bool_t b_complete;
465
466         if( p_intf->p_sys->pi_socket_listen != NULL &&
467             p_intf->p_sys->i_socket == -1 )
468         {
469             p_intf->p_sys->i_socket =
470                 net_Accept( p_intf, p_intf->p_sys->pi_socket_listen,
471                             INTF_IDLE_SLEEP );
472             if( p_intf->p_sys->i_socket == -1 ) continue;
473         }
474
475         b_complete = ReadCommand( p_intf, p_buffer, &i_size );
476
477         /* Manage the input part */
478         if( p_input == NULL )
479         {
480             if( p_playlist )
481             {
482                 p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT,
483                                                        FIND_CHILD );
484             }
485             else
486             {
487                 p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
488                                                    FIND_ANYWHERE );
489                 if( p_input )
490                 {
491                     p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
492                                                            FIND_PARENT );
493                 }
494             }
495             /* New input has been registered */
496             if( p_input )
497             {
498                 if( !p_input->b_dead || !p_input->b_die )
499                 {
500                     char *psz_uri =
501                             input_item_GetURI( input_GetItem( p_input ) );
502                     msg_rc( STATUS_CHANGE "( new input: %s )", psz_uri );
503                     free( psz_uri );
504                     msg_rc( STATUS_CHANGE "( audio volume: %d )",
505                             config_GetInt( p_intf, "volume" ));
506                 }
507                 var_AddCallback( p_input, "state", StateChanged, p_intf );
508                 var_AddCallback( p_input, "rate-faster", RateChanged, p_intf );
509                 var_AddCallback( p_input, "rate-slower", RateChanged, p_intf );
510                 var_AddCallback( p_input, "rate", RateChanged, p_intf );
511                 var_AddCallback( p_input, "time-offset", TimeOffsetChanged,
512                                  p_intf );
513             }
514         }
515         else if( p_input->b_dead )
516         {
517             var_DelCallback( p_input, "state", StateChanged, p_intf );
518             var_DelCallback( p_input, "rate-faster", RateChanged, p_intf );
519             var_DelCallback( p_input, "rate-slower", RateChanged, p_intf );
520             var_DelCallback( p_input, "rate", RateChanged, p_intf );
521             var_DelCallback( p_input, "time-offset", TimeOffsetChanged,
522                              p_intf );
523             vlc_object_release( p_input );
524             p_input = NULL;
525
526             if( p_playlist )
527             {
528                 vlc_mutex_lock( &p_playlist->object_lock );
529                 p_intf->p_sys->i_last_state = (int) PLAYLIST_STOPPED;
530                 msg_rc( STATUS_CHANGE "( stop state: 0 )" );
531                 vlc_mutex_unlock( &p_playlist->object_lock );
532             }
533         }
534
535         if( (p_input != NULL) && !p_input->b_dead && !p_input->b_die &&
536             (p_playlist != NULL) )
537         {
538             vlc_mutex_lock( &p_playlist->object_lock );
539             if( (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
540                 (p_playlist->status.i_status == PLAYLIST_STOPPED) )
541             {
542                 p_intf->p_sys->i_last_state = PLAYLIST_STOPPED;
543                 msg_rc( STATUS_CHANGE "( stop state: 0 )" );
544             }
545             else if(
546                 (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
547                 (p_playlist->status.i_status == PLAYLIST_RUNNING) )
548             {
549                 p_intf->p_sys->i_last_state = p_playlist->status.i_status;
550                 msg_rc( STATUS_CHANGE "( play state: 1 )" );
551             }
552             else if(
553                 (p_intf->p_sys->i_last_state != p_playlist->status.i_status) &&
554                 (p_playlist->status.i_status == PLAYLIST_PAUSED) )
555             {
556                 p_intf->p_sys->i_last_state = p_playlist->status.i_status;
557                 msg_rc( STATUS_CHANGE "( pause state: 2 )" );
558             }
559             vlc_mutex_unlock( &p_playlist->object_lock );
560         }
561
562         if( p_input && b_showpos )
563         {
564             i_newpos = 100 * var_GetFloat( p_input, "position" );
565             if( i_oldpos != i_newpos )
566             {
567                 i_oldpos = i_newpos;
568                 msg_rc( "pos: %d%%", i_newpos );
569             }
570         }
571
572         /* Is there something to do? */
573         if( !b_complete ) continue;
574
575
576         /* Skip heading spaces */
577         psz_cmd = p_buffer;
578         while( *psz_cmd == ' ' )
579         {
580             psz_cmd++;
581         }
582
583         /* Split psz_cmd at the first space and make sure that
584          * psz_arg is valid */
585         psz_arg = strchr( psz_cmd, ' ' );
586         if( psz_arg )
587         {
588             *psz_arg++ = 0;
589             while( *psz_arg == ' ' )
590             {
591                 psz_arg++;
592             }
593         }
594         else
595         {
596             psz_arg = "";
597         }
598
599         /* module specfic commands: @<module name> <command> <args...> */
600         if( *psz_cmd == '@' && *psz_arg )
601         {
602             /* Parse miscellaneous commands */
603             char *psz_alias = psz_cmd + 1;
604             char *psz_mycmd = strdup( psz_arg );
605             char *psz_myarg = strchr( psz_mycmd, ' ' );
606             char *psz_msg;
607
608             if( !psz_myarg )
609             {
610                 msg_rc( "Not enough parameters." );
611             }
612             else
613             {
614                 *psz_myarg = '\0';
615                 psz_myarg ++;
616
617                 var_Command( p_intf, psz_alias, psz_mycmd, psz_myarg,
618                              &psz_msg );
619
620                 if( psz_msg )
621                 {
622                     msg_rc( psz_msg );
623                     free( psz_msg );
624                 }
625             }
626             free( psz_mycmd );
627         }
628         /* If the user typed a registered local command, try it */
629         else if( var_Type( p_intf, psz_cmd ) & VLC_VAR_ISCOMMAND )
630         {
631             vlc_value_t val;
632             int i_ret;
633
634             val.psz_string = psz_arg;
635             i_ret = var_Set( p_intf, psz_cmd, val );
636             msg_rc( "%s: returned %i (%s)",
637                     psz_cmd, i_ret, vlc_error( i_ret ) );
638         }
639         /* Or maybe it's a global command */
640         else if( var_Type( p_intf->p_libvlc, psz_cmd ) & VLC_VAR_ISCOMMAND )
641         {
642             vlc_value_t val;
643             int i_ret;
644
645             val.psz_string = psz_arg;
646             /* FIXME: it's a global command, but we should pass the
647              * local object as an argument, not p_intf->p_libvlc. */
648             i_ret = var_Set( p_intf->p_libvlc, psz_cmd, val );
649             if( i_ret != 0 )
650             {
651                 msg_rc( "%s: returned %i (%s)",
652                          psz_cmd, i_ret, vlc_error( i_ret ) );
653             }
654         }
655         else if( !strcmp( psz_cmd, "logout" ) )
656         {
657             /* Close connection */
658             if( p_intf->p_sys->i_socket != -1 )
659             {
660                 net_Close( p_intf->p_sys->i_socket );
661             }
662             p_intf->p_sys->i_socket = -1;
663         }
664         else if( !strcmp( psz_cmd, "info" ) )
665         {
666             if( p_input )
667             {
668                 int i, j;
669                 vlc_mutex_lock( &input_GetItem(p_input)->lock );
670                 for ( i = 0; i < input_GetItem(p_input)->i_categories; i++ )
671                 {
672                     info_category_t *p_category = input_GetItem(p_input)
673                                                         ->pp_categories[i];
674
675                     msg_rc( "+----[ %s ]", p_category->psz_name );
676                     msg_rc( "| " );
677                     for ( j = 0; j < p_category->i_infos; j++ )
678                     {
679                         info_t *p_info = p_category->pp_infos[j];
680                         msg_rc( "| %s: %s", p_info->psz_name,
681                                 p_info->psz_value );
682                     }
683                     msg_rc( "| " );
684                 }
685                 msg_rc( "+----[ end of stream info ]" );
686                 vlc_mutex_unlock( &input_GetItem(p_input)->lock );
687             }
688             else
689             {
690                 msg_rc( "no input" );
691             }
692         }
693         else if( !strcmp( psz_cmd, "is_playing" ) )
694         {
695             if( ! p_input )
696             {
697                 msg_rc( "0" );
698             }
699             else
700             {
701                 msg_rc( "1" );
702             }
703         }
704         else if( !strcmp( psz_cmd, "get_time" ) )
705         {
706             if( ! p_input )
707             {
708                 msg_rc("0");
709             }
710             else
711             {
712                 vlc_value_t time;
713                 var_Get( p_input, "time", &time );
714                 msg_rc( "%i", time.i_time / 1000000);
715             }
716         }
717         else if( !strcmp( psz_cmd, "get_length" ) )
718         {
719             if( ! p_input )
720             {
721                 msg_rc("0");
722             }
723             else
724             {
725                 vlc_value_t time;
726                 var_Get( p_input, "length", &time );
727                 msg_rc( "%i", time.i_time / 1000000);
728             }
729         }
730         else if( !strcmp( psz_cmd, "get_title" ) )
731         {
732             if( ! p_input )
733             {
734                 msg_rc("");
735             }
736             else
737             {
738                 msg_rc( "%s", input_GetItem(p_input)->psz_name );
739             }
740         }
741         else if( !strcmp( psz_cmd, "longhelp" ) || !strncmp( psz_cmd, "h", 1 )
742                  || !strncmp( psz_cmd, "H", 1 ) || !strncmp( psz_cmd, "?", 1 ) )
743         {
744             if( !strcmp( psz_cmd, "longhelp" ) || !strncmp( psz_cmd, "H", 1 ) )
745                  b_longhelp = VLC_TRUE;
746             else b_longhelp = VLC_FALSE;
747
748             Help( p_intf, b_longhelp );
749         }
750         else if( !strcmp( psz_cmd, "check-updates" ) )
751         {
752             checkUpdates( p_intf, psz_arg );
753         }
754         else if( !strcmp( psz_cmd, "key" ) || !strcmp( psz_cmd, "hotkey" ) )
755         {
756             var_SetInteger( p_intf->p_libvlc, "key-pressed",
757                             config_GetInt( p_intf, psz_arg ) );
758         }
759         else switch( psz_cmd[0] )
760         {
761         case 'f':
762         case 'F':
763             if( p_input )
764             {
765                 vout_thread_t *p_vout;
766                 p_vout = vlc_object_find( p_input,
767                                           VLC_OBJECT_VOUT, FIND_CHILD );
768
769                 if( p_vout )
770                 {
771                     vlc_value_t val;
772                     vlc_bool_t b_update = VLC_FALSE;
773                     var_Get( p_vout, "fullscreen", &val );
774                     val.b_bool = !val.b_bool;
775                     if( !strncmp( psz_arg, "on", 2 )
776                         && ( val.b_bool == VLC_TRUE ) )
777                     {
778                         b_update = VLC_TRUE;
779                         val.b_bool = VLC_TRUE;
780                     }
781                     else if( !strncmp( psz_arg, "off", 3 )
782                              && ( val.b_bool == VLC_FALSE ) )
783                     {
784                         b_update = VLC_TRUE;
785                         val.b_bool = VLC_FALSE;
786                     }
787                     else if( strncmp( psz_arg, "off", 3 )
788                              && strncmp( psz_arg, "on", 2 ) )
789                         b_update = VLC_TRUE;
790                     if( b_update ) var_Set( p_vout, "fullscreen", val );
791                     vlc_object_release( p_vout );
792                 }
793             }
794             break;
795
796         case 's':
797         case 'S':
798             ;
799             break;
800
801         case '\0':
802             /* Ignore empty lines */
803             break;
804
805         default:
806             msg_rc(_("Unknown command `%s'. Type `help' for help."), psz_cmd);
807             break;
808         }
809
810         /* Command processed */
811         i_size = 0; p_buffer[0] = 0;
812     }
813
814     msg_rc( STATUS_CHANGE "( stop state: 0 )" );
815     msg_rc( STATUS_CHANGE "( quit )" );
816
817     if( p_input )
818     {
819         var_DelCallback( p_input, "state", StateChanged, p_intf );
820         var_DelCallback( p_input, "rate-faster", RateChanged, p_intf );
821         var_DelCallback( p_input, "rate-slower", RateChanged, p_intf );
822         var_DelCallback( p_input, "rate", RateChanged, p_intf );
823         var_DelCallback( p_input, "time-offset", TimeOffsetChanged, p_intf );
824         vlc_object_release( p_input );
825         p_input = NULL;
826     }
827
828     if( p_playlist )
829     {
830         vlc_object_release( p_playlist );
831         p_playlist = NULL;
832     }
833
834     var_DelCallback( p_intf->p_libvlc, "volume-change", VolumeChanged, p_intf );
835 }
836
837 static void Help( intf_thread_t *p_intf, vlc_bool_t b_longhelp)
838 {
839     msg_rc(_("+----[ Remote control commands ]"));
840     msg_rc(  "| ");
841     msg_rc(_("| add XYZ  . . . . . . . . . . . . add XYZ to playlist"));
842     msg_rc(_("| enqueue XYZ  . . . . . . . . . queue XYZ to playlist"));
843     msg_rc(_("| playlist . . . . .  show items currently in playlist"));
844     msg_rc(_("| play . . . . . . . . . . . . . . . . . . play stream"));
845     msg_rc(_("| stop . . . . . . . . . . . . . . . . . . stop stream"));
846     msg_rc(_("| next . . . . . . . . . . . . . .  next playlist item"));
847     msg_rc(_("| prev . . . . . . . . . . . .  previous playlist item"));
848     msg_rc(_("| goto . . . . . . . . . . . . . .  goto item at index"));
849     msg_rc(_("| repeat [on|off] . . . .  toggle playlist item repeat"));
850     msg_rc(_("| loop [on|off] . . . . . .  toggle playlist item loop"));
851     msg_rc(_("| clear . . . . . . . . . . . . .   clear the playlist"));
852     msg_rc(_("| status . . . . . . . . . . . current playlist status"));
853     msg_rc(_("| title [X]  . . . . . . set/get title in current item"));
854     msg_rc(_("| title_n  . . . . . . . .  next title in current item"));
855     msg_rc(_("| title_p  . . . . . .  previous title in current item"));
856     msg_rc(_("| chapter [X]  . . . . set/get chapter in current item"));
857     msg_rc(_("| chapter_n  . . . . . .  next chapter in current item"));
858     msg_rc(_("| chapter_p  . . . .  previous chapter in current item"));
859     msg_rc(  "| ");
860     msg_rc(_("| seek X . . . seek in seconds, for instance `seek 12'"));
861     msg_rc(_("| pause  . . . . . . . . . . . . . . . .  toggle pause"));
862     msg_rc(_("| fastforward  . . . . . . . .  .  set to maximum rate"));
863     msg_rc(_("| rewind  . . . . . . . . . . . .  set to minimum rate"));
864     msg_rc(_("| faster . . . . . . . . . .  faster playing of stream"));
865     msg_rc(_("| slower . . . . . . . . . .  slower playing of stream"));
866     msg_rc(_("| normal . . . . . . . . . .  normal playing of stream"));
867     msg_rc(_("| f [on|off] . . . . . . . . . . . . toggle fullscreen"));
868     msg_rc(_("| info . . . . .  information about the current stream"));
869     msg_rc(_("| get_time . . seconds elapsed since stream's beginning"));
870     msg_rc(_("| is_playing . . . .  1 if a stream plays, 0 otherwise"));
871     msg_rc(_("| get_title . . . . .  the title of the current stream"));
872     msg_rc(_("| get_length . . . .  the length of the current stream"));
873     msg_rc(  "| ");
874     msg_rc(_("| volume [X] . . . . . . . . . .  set/get audio volume"));
875     msg_rc(_("| volup [X]  . . . . . . .  raise audio volume X steps"));
876     msg_rc(_("| voldown [X]  . . . . . .  lower audio volume X steps"));
877     msg_rc(_("| adev [X] . . . . . . . . . . .  set/get audio device"));
878     msg_rc(_("| achan [X]. . . . . . . . . .  set/get audio channels"));
879     msg_rc(_("| atrack [X] . . . . . . . . . . . set/get audio track"));
880     msg_rc(_("| vtrack [X] . . . . . . . . . . . set/get video track"));
881     msg_rc(_("| vratio [X]  . . . . . . . set/get video aspect ratio"));
882     msg_rc(_("| vcrop [X]  . . . . . . . . . . .  set/get video crop"));
883     msg_rc(_("| vzoom [X]  . . . . . . . . . . .  set/get video zoom"));
884     msg_rc(_("| strack [X] . . . . . . . . . set/get subtitles track"));
885     msg_rc(_("| key [hotkey name] . . . . . .  simulate hotkey press"));
886     msg_rc(_("| menu . . [on|off|up|down|left|right|select] use menu"));
887     msg_rc(  "| ");
888
889     if (b_longhelp)
890     {
891         msg_rc(_("| @name marq-marquee  STRING  . . overlay STRING in video"));
892         msg_rc(_("| @name marq-x X . . . . . . . . . . . .offset from left"));
893         msg_rc(_("| @name marq-y Y . . . . . . . . . . . . offset from top"));
894         msg_rc(_("| @name marq-position #. . .  .relative position control"));
895         msg_rc(_("| @name marq-color # . . . . . . . . . . font color, RGB"));
896         msg_rc(_("| @name marq-opacity # . . . . . . . . . . . . . opacity"));
897         msg_rc(_("| @name marq-timeout T. . . . . . . . . . timeout, in ms"));
898         msg_rc(_("| @name marq-size # . . . . . . . . font size, in pixels"));
899         msg_rc(  "| ");
900         msg_rc(_("| @name logo-file STRING . . .the overlay file path/name"));
901         msg_rc(_("| @name logo-x X . . . . . . . . . . . .offset from left"));
902         msg_rc(_("| @name logo-y Y . . . . . . . . . . . . offset from top"));
903         msg_rc(_("| @name logo-position #. . . . . . . . relative position"));
904         msg_rc(_("| @name logo-transparency #. . . . . . . . .transparency"));
905         msg_rc(  "| ");
906         msg_rc(_("| @name mosaic-alpha # . . . . . . . . . . . . . . alpha"));
907         msg_rc(_("| @name mosaic-height #. . . . . . . . . . . . . .height"));
908         msg_rc(_("| @name mosaic-width # . . . . . . . . . . . . . . width"));
909         msg_rc(_("| @name mosaic-xoffset # . . . .top left corner position"));
910         msg_rc(_("| @name mosaic-yoffset # . . . .top left corner position"));
911         msg_rc(_("| @name mosaic-offsets x,y(,x,y)*. . . . list of offsets"));
912         msg_rc(_("| @name mosaic-align 0..2,4..6,8..10. . .mosaic alignment"));
913         msg_rc(_("| @name mosaic-vborder # . . . . . . . . vertical border"));
914         msg_rc(_("| @name mosaic-hborder # . . . . . . . horizontal border"));
915         msg_rc(_("| @name mosaic-position {0=auto,1=fixed} . . . .position"));
916         msg_rc(_("| @name mosaic-rows #. . . . . . . . . . .number of rows"));
917         msg_rc(_("| @name mosaic-cols #. . . . . . . . . . .number of cols"));
918         msg_rc(_("| @name mosaic-order id(,id)* . . . . order of pictures "));
919         msg_rc(_("| @name mosaic-keep-aspect-ratio {0,1} . . .aspect ratio"));
920         msg_rc(  "| ");
921         msg_rc(_("| check-updates [newer] [equal] [older]\n"
922                  "|               [undef] [info] [source] [binary] [plugin]"));
923         msg_rc(  "| ");
924     }
925     msg_rc(_("| help . . . . . . . . . . . . . . . this help message"));
926     msg_rc(_("| longhelp . . . . . . . . . . . a longer help message"));
927     msg_rc(_("| logout . . . . . . .  exit (if in socket connection)"));
928     msg_rc(_("| quit . . . . . . . . . . . . . . . . . . .  quit vlc"));
929     msg_rc(  "| ");
930     msg_rc(_("+----[ end of help ]"));
931 }
932
933 /********************************************************************
934  * Status callback routines
935  ********************************************************************/
936 static int TimeOffsetChanged( vlc_object_t *p_this, char const *psz_cmd,
937     vlc_value_t oldval, vlc_value_t newval, void *p_data )
938 {
939     intf_thread_t *p_intf = (intf_thread_t*)p_data;
940     input_thread_t *p_input = NULL;
941
942     vlc_mutex_lock( &p_intf->p_sys->status_lock );
943     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
944     if( p_input )
945     {
946         msg_rc( STATUS_CHANGE "( time-offset: %d )",
947                 var_GetInteger( p_input, "time-offset" ) );
948         vlc_object_release( p_input );
949     }
950     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
951     return VLC_SUCCESS;
952 }
953
954 static int VolumeChanged( vlc_object_t *p_this, char const *psz_cmd,
955     vlc_value_t oldval, vlc_value_t newval, void *p_data )
956 {
957     intf_thread_t *p_intf = (intf_thread_t*)p_data;
958
959     vlc_mutex_lock( &p_intf->p_sys->status_lock );
960     msg_rc( STATUS_CHANGE "( audio volume: %d )",
961             config_GetInt( p_this, "volume") );
962     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
963     return VLC_SUCCESS;
964 }
965
966 static int StateChanged( vlc_object_t *p_this, char const *psz_cmd,
967     vlc_value_t oldval, vlc_value_t newval, void *p_data )
968 {
969     intf_thread_t *p_intf = (intf_thread_t*)p_data;
970     playlist_t    *p_playlist = NULL;
971     input_thread_t *p_input = NULL;
972
973     vlc_mutex_lock( &p_intf->p_sys->status_lock );
974     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
975     if( p_input )
976     {
977         p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST, FIND_PARENT );
978         if( p_playlist )
979         {
980             char cmd[5] = "";
981             switch( p_playlist->status.i_status )
982             {
983             case PLAYLIST_STOPPED:
984                 strncpy( &cmd[0], "stop", 4);
985                 cmd[4] = '\0';
986                 break;
987             case PLAYLIST_RUNNING:
988                 strncpy( &cmd[0], "play", 4);
989                 cmd[4] = '\0';
990                 break;
991             case PLAYLIST_PAUSED:
992                 strncpy( &cmd[0], "pause", 5);
993                 cmd[5] = '\0';
994                 break;
995             } /* var_GetInteger( p_input, "state" )  */
996             msg_rc( STATUS_CHANGE "( %s state: %d )", &cmd[0], newval.i_int );
997             vlc_object_release( p_playlist );
998         }
999         vlc_object_release( p_input );
1000     }
1001     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
1002     return VLC_SUCCESS;
1003 }
1004
1005 static int RateChanged( vlc_object_t *p_this, char const *psz_cmd,
1006     vlc_value_t oldval, vlc_value_t newval, void *p_data )
1007 {
1008     intf_thread_t *p_intf = (intf_thread_t*)p_data;
1009     input_thread_t *p_input = NULL;
1010
1011     vlc_mutex_lock( &p_intf->p_sys->status_lock );
1012     p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1013     if( p_input )
1014     {
1015         msg_rc( STATUS_CHANGE "( new rate: %d )",
1016                 var_GetInteger( p_input, "rate" ) );
1017         vlc_object_release( p_input );
1018     }
1019     vlc_mutex_unlock( &p_intf->p_sys->status_lock );
1020     return VLC_SUCCESS;
1021 }
1022
1023 /********************************************************************
1024  * Command routines
1025  ********************************************************************/
1026 static int Input( vlc_object_t *p_this, char const *psz_cmd,
1027                   vlc_value_t oldval, vlc_value_t newval, void *p_data )
1028 {
1029     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1030     input_thread_t *p_input;
1031     vlc_value_t     val;
1032
1033     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1034     if( !p_input ) return VLC_ENOOBJ;
1035
1036     var_Get( p_input, "state", &val );
1037     if( ( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) ) &&
1038         ( strcmp( psz_cmd, "pause" ) != 0 ) )
1039     {
1040         msg_rc( _("Press menu select or pause to continue.") );
1041         vlc_object_release( p_input );
1042         return VLC_EGENERIC;
1043     }
1044
1045     /* Parse commands that only require an input */
1046     if( !strcmp( psz_cmd, "pause" ) )
1047     {
1048         val.i_int = config_GetInt( p_intf, "key-play-pause" );
1049         var_Set( p_intf->p_libvlc, "key-pressed", val );
1050         vlc_object_release( p_input );
1051         return VLC_SUCCESS;
1052     }
1053     else if( !strcmp( psz_cmd, "seek" ) )
1054     {
1055         if( strlen( newval.psz_string ) > 0 &&
1056             newval.psz_string[strlen( newval.psz_string ) - 1] == '%' )
1057         {
1058             val.f_float = (float)atof( newval.psz_string ) / 100.0;
1059             var_Set( p_input, "position", val );
1060         }
1061         else
1062         {
1063             val.i_time = ((int64_t)atoi( newval.psz_string )) * 1000000;
1064             var_Set( p_input, "time", val );
1065         }
1066         vlc_object_release( p_input );
1067         return VLC_SUCCESS;
1068     }
1069     else if ( !strcmp( psz_cmd, "fastforward" ) )
1070     {
1071         val.i_int = config_GetInt( p_intf, "key-jump+extrashort" );
1072         var_Set( p_intf->p_libvlc, "key-pressed", val );
1073         vlc_object_release( p_input );
1074         return VLC_SUCCESS;
1075     }
1076     else if ( !strcmp( psz_cmd, "rewind" ) )
1077     {
1078         val.i_int = config_GetInt( p_intf, "key-jump-extrashort" );
1079         var_Set( p_intf->p_libvlc, "key-pressed", val );
1080         vlc_object_release( p_input );
1081         return VLC_SUCCESS;
1082     }
1083     else if ( !strcmp( psz_cmd, "faster" ) )
1084     {
1085         val.b_bool = VLC_TRUE;
1086         var_Set( p_input, "rate-faster", val );
1087         vlc_object_release( p_input );
1088         return VLC_SUCCESS;
1089     }
1090     else if ( !strcmp( psz_cmd, "slower" ) )
1091     {
1092         val.b_bool = VLC_TRUE;
1093         var_Set( p_input, "rate-slower", val );
1094         vlc_object_release( p_input );
1095         return VLC_SUCCESS;
1096     }
1097     else if ( !strcmp( psz_cmd, "normal" ) )
1098     {
1099         val.i_int = INPUT_RATE_DEFAULT;
1100         var_Set( p_input, "rate", val );
1101         vlc_object_release( p_input );
1102         return VLC_SUCCESS;
1103     }
1104     else if( !strcmp( psz_cmd, "chapter" ) ||
1105              !strcmp( psz_cmd, "chapter_n" ) ||
1106              !strcmp( psz_cmd, "chapter_p" ) )
1107     {
1108         if( !strcmp( psz_cmd, "chapter" ) )
1109         {
1110             if ( *newval.psz_string )
1111             {
1112                 /* Set. */
1113                 val.i_int = atoi( newval.psz_string );
1114                 var_Set( p_input, "chapter", val );
1115             }
1116             else
1117             {
1118                 vlc_value_t val_list;
1119
1120                 /* Get. */
1121                 var_Get( p_input, "chapter", &val );
1122                 var_Change( p_input, "chapter", VLC_VAR_GETCHOICES,
1123                             &val_list, NULL );
1124                 msg_rc( "Currently playing chapter %d/%d.",
1125                         val.i_int, val_list.p_list->i_count );
1126                 var_Change( p_this, "chapter", VLC_VAR_FREELIST,
1127                             &val_list, NULL );
1128             }
1129         }
1130         else if( !strcmp( psz_cmd, "chapter_n" ) )
1131         {
1132             val.b_bool = VLC_TRUE;
1133             var_Set( p_input, "next-chapter", val );
1134         }
1135         else if( !strcmp( psz_cmd, "chapter_p" ) )
1136         {
1137             val.b_bool = VLC_TRUE;
1138             var_Set( p_input, "prev-chapter", val );
1139         }
1140         vlc_object_release( p_input );
1141         return VLC_SUCCESS;
1142     }
1143     else if( !strcmp( psz_cmd, "title" ) ||
1144              !strcmp( psz_cmd, "title_n" ) ||
1145              !strcmp( psz_cmd, "title_p" ) )
1146     {
1147         if( !strcmp( psz_cmd, "title" ) )
1148         {
1149             if ( *newval.psz_string )
1150             {
1151                 /* Set. */
1152                 val.i_int = atoi( newval.psz_string );
1153                 var_Set( p_input, "title", val );
1154             }
1155             else
1156             {
1157                 vlc_value_t val_list;
1158
1159                 /* Get. */
1160                 var_Get( p_input, "title", &val );
1161                 var_Change( p_input, "title", VLC_VAR_GETCHOICES,
1162                             &val_list, NULL );
1163                 msg_rc( "Currently playing title %d/%d.",
1164                         val.i_int, val_list.p_list->i_count );
1165                 var_Change( p_this, "title", VLC_VAR_FREELIST,
1166                             &val_list, NULL );
1167             }
1168         }
1169         else if( !strcmp( psz_cmd, "title_n" ) )
1170         {
1171             val.b_bool = VLC_TRUE;
1172             var_Set( p_input, "next-title", val );
1173         }
1174         else if( !strcmp( psz_cmd, "title_p" ) )
1175         {
1176             val.b_bool = VLC_TRUE;
1177             var_Set( p_input, "prev-title", val );
1178         }
1179
1180         vlc_object_release( p_input );
1181         return VLC_SUCCESS;
1182     }
1183     else if(    !strcmp( psz_cmd, "atrack" )
1184              || !strcmp( psz_cmd, "vtrack" )
1185              || !strcmp( psz_cmd, "strack" ) )
1186     {
1187         const char *psz_variable;
1188         vlc_value_t val_name;
1189         int i_error;
1190
1191         if( !strcmp( psz_cmd, "atrack" ) )
1192         {
1193             psz_variable = "audio-es";
1194         }
1195         else if( !strcmp( psz_cmd, "vtrack" ) )
1196         {
1197             psz_variable = "video-es";
1198         }
1199         else
1200         {
1201             psz_variable = "spu-es";
1202         }
1203
1204         /* Get the descriptive name of the variable */
1205         var_Change( p_input, psz_variable, VLC_VAR_GETTEXT,
1206                      &val_name, NULL );
1207         if( !val_name.psz_string ) val_name.psz_string = strdup(psz_variable);
1208
1209         if( newval.psz_string && *newval.psz_string )
1210         {
1211             /* set */
1212             vlc_value_t val;
1213             val.i_int = atoi( newval.psz_string );
1214
1215             i_error = var_Set( p_input, psz_variable, val );
1216         }
1217         else
1218         {
1219             /* get */
1220             vlc_value_t val, text;
1221             int i, i_value;
1222
1223             if ( var_Get( p_input, psz_variable, &val ) < 0 )
1224             {
1225                 vlc_object_release( p_input );
1226                 return VLC_EGENERIC;
1227             }
1228             i_value = val.i_int;
1229
1230             if ( var_Change( p_input, psz_variable,
1231                              VLC_VAR_GETLIST, &val, &text ) < 0 )
1232             {
1233                 vlc_object_release( p_input );
1234                 return VLC_EGENERIC;
1235             }
1236
1237             msg_rc( "+----[ %s ]", val_name.psz_string );
1238             for ( i = 0; i < val.p_list->i_count; i++ )
1239             {
1240                 if ( i_value == val.p_list->p_values[i].i_int )
1241                     msg_rc( "| %i - %s *", val.p_list->p_values[i].i_int,
1242                             text.p_list->p_values[i].psz_string );
1243                 else
1244                     msg_rc( "| %i - %s", val.p_list->p_values[i].i_int,
1245                             text.p_list->p_values[i].psz_string );
1246             }
1247             var_Change( p_input, psz_variable, VLC_VAR_FREELIST,
1248                         &val, &text );
1249             msg_rc( "+----[ end of %s ]", val_name.psz_string );
1250
1251             if( val_name.psz_string ) free( val_name.psz_string );
1252
1253             i_error = VLC_SUCCESS;
1254         }
1255         vlc_object_release( p_input );
1256         return i_error;
1257     }
1258
1259     /* Never reached. */
1260     vlc_object_release( p_input );
1261     return VLC_EGENERIC;
1262 }
1263
1264 static int Playlist( vlc_object_t *p_this, char const *psz_cmd,
1265                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
1266 {
1267     vlc_value_t val;
1268
1269     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1270     playlist_t *p_playlist = pl_Yield( p_this );
1271
1272     PL_LOCK;
1273     if( p_playlist->p_input )
1274     {
1275         var_Get( p_playlist->p_input, "state", &val );
1276         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1277         {
1278             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1279             vlc_object_release( p_playlist );
1280             PL_UNLOCK;
1281             return VLC_EGENERIC;
1282         }
1283     }
1284     PL_UNLOCK;
1285
1286     /* Parse commands that require a playlist */
1287     if( !strcmp( psz_cmd, "prev" ) )
1288     {
1289         playlist_Prev( p_playlist );
1290     }
1291     else if( !strcmp( psz_cmd, "next" ) )
1292     {
1293         playlist_Next( p_playlist );
1294     }
1295     else if( !strcmp( psz_cmd, "play" ) )
1296     {
1297         msg_Warn( p_playlist, "play" );
1298         playlist_Play( p_playlist );
1299     }
1300     else if( !strcmp( psz_cmd, "repeat" ) )
1301     {
1302         vlc_bool_t b_update = VLC_TRUE;
1303
1304         var_Get( p_playlist, "repeat", &val );
1305
1306         if( strlen( newval.psz_string ) > 0 )
1307         {
1308             if ( ( !strncmp( newval.psz_string, "on", 2 ) && ( val.b_bool == VLC_TRUE ) ) ||
1309                  ( !strncmp( newval.psz_string, "off", 3 ) && ( val.b_bool == VLC_FALSE ) ) )
1310             {
1311                 b_update = VLC_FALSE;
1312             }
1313         }
1314
1315         if ( b_update )
1316         {
1317             val.b_bool = !val.b_bool;
1318             var_Set( p_playlist, "repeat", val );
1319         }
1320         msg_rc( "Setting repeat to %d", val.b_bool );
1321     }
1322     else if( !strcmp( psz_cmd, "loop" ) )
1323     {
1324         vlc_bool_t b_update = VLC_TRUE;
1325
1326         var_Get( p_playlist, "loop", &val );
1327
1328         if( strlen( newval.psz_string ) > 0 )
1329         {
1330             if ( ( !strncmp( newval.psz_string, "on", 2 ) && ( val.b_bool == VLC_TRUE ) ) ||
1331                  ( !strncmp( newval.psz_string, "off", 3 ) && ( val.b_bool == VLC_FALSE ) ) )
1332             {
1333                 b_update = VLC_FALSE;
1334             }
1335         }
1336
1337         if ( b_update )
1338         {
1339             val.b_bool = !val.b_bool;
1340             var_Set( p_playlist, "loop", val );
1341         }
1342         msg_rc( "Setting loop to %d", val.b_bool );
1343     }
1344     else if (!strcmp( psz_cmd, "goto" ) )
1345     {
1346         msg_rc( _("goto is deprecated" ) );
1347         msg_Err( p_playlist, "goto is deprecated" );
1348     }
1349     else if( !strcmp( psz_cmd, "stop" ) )
1350     {
1351         playlist_Stop( p_playlist );
1352     }
1353     else if( !strcmp( psz_cmd, "clear" ) )
1354     {
1355         playlist_Stop( p_playlist );
1356         playlist_Clear( p_playlist, VLC_FALSE );
1357     }
1358     else if( !strcmp( psz_cmd, "add" ) &&
1359              newval.psz_string && *newval.psz_string )
1360     {
1361         input_item_t *p_item = parse_MRL( p_intf, newval.psz_string );
1362
1363         if( p_item )
1364         {
1365             msg_rc( "Trying to add %s to playlist.", newval.psz_string );
1366             playlist_AddInput( p_playlist, p_item,
1367                      PLAYLIST_GO|PLAYLIST_APPEND, PLAYLIST_END, VLC_TRUE,
1368                      VLC_FALSE );
1369         }
1370     }
1371     else if( !strcmp( psz_cmd, "enqueue" ) &&
1372              newval.psz_string && *newval.psz_string )
1373     {
1374         input_item_t *p_item = parse_MRL( p_intf, newval.psz_string );
1375
1376         if( p_item )
1377         {
1378             msg_rc( "trying to enqueue %s to playlist", newval.psz_string );
1379             playlist_AddInput( p_playlist, p_item,
1380                                PLAYLIST_APPEND, PLAYLIST_END, VLC_TRUE,
1381                                VLC_FALSE);
1382         }
1383     }
1384     else if( !strcmp( psz_cmd, "playlist" ) )
1385     {
1386         msg_Dbg( p_playlist, "Dumping category" );
1387         playlist_NodeDump( p_playlist, p_playlist->p_root_category, 0 );
1388         msg_Dbg( p_playlist, "Dumping Onelevel" );
1389         playlist_NodeDump( p_playlist, p_playlist->p_root_onelevel, 0 );
1390     }
1391     else if( !strcmp( psz_cmd, "sort" ))
1392     {
1393         playlist_RecursiveNodeSort( p_playlist, p_playlist->p_root_onelevel,
1394                                     SORT_ARTIST, ORDER_NORMAL );
1395     }
1396     else if( !strcmp( psz_cmd, "status" ) )
1397     {
1398         if( p_playlist->p_input )
1399         {
1400             /* Replay the current state of the system. */
1401             char *psz_uri =
1402                     input_item_GetURI( input_GetItem( p_playlist->p_input ) );
1403             msg_rc( STATUS_CHANGE "( new input: %s )", psz_uri );
1404             free( psz_uri );
1405             msg_rc( STATUS_CHANGE "( audio volume: %d )",
1406                     config_GetInt( p_intf, "volume" ));
1407
1408             vlc_mutex_lock( &p_playlist->object_lock );
1409             switch( p_playlist->status.i_status )
1410             {
1411                 case PLAYLIST_STOPPED:
1412                     msg_rc( STATUS_CHANGE "( stop state: 0 )" );
1413                     break;
1414                 case PLAYLIST_RUNNING:
1415                     msg_rc( STATUS_CHANGE "( play state: 1 )" );
1416                     break;
1417                 case PLAYLIST_PAUSED:
1418                     msg_rc( STATUS_CHANGE "( pause state: 2 )" );
1419                     break;
1420                 default:
1421                     msg_rc( STATUS_CHANGE "( state unknown )" );
1422                     break;
1423             }
1424             vlc_mutex_unlock( &p_playlist->object_lock );
1425         }
1426     }
1427
1428     /*
1429      * sanity check
1430      */
1431     else
1432     {
1433         msg_rc( "unknown command!" );
1434     }
1435
1436     vlc_object_release( p_playlist );
1437     return VLC_SUCCESS;
1438 }
1439
1440 static int Quit( vlc_object_t *p_this, char const *psz_cmd,
1441                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
1442 {
1443     playlist_t *p_playlist;
1444
1445     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1446     if( p_playlist )
1447     {
1448         playlist_Stop( p_playlist );
1449         vlc_object_release( p_playlist );
1450     }
1451     vlc_object_kill( p_this->p_libvlc );
1452     return VLC_SUCCESS;
1453 }
1454
1455 static int Intf( vlc_object_t *p_this, char const *psz_cmd,
1456                  vlc_value_t oldval, vlc_value_t newval, void *p_data )
1457 {
1458     intf_thread_t *p_newintf = NULL;
1459
1460     p_newintf = intf_Create( p_this->p_libvlc, newval.psz_string, 0, NULL );
1461     if( p_newintf )
1462     {
1463         if( intf_RunThread( p_newintf ) )
1464         {
1465             vlc_object_detach( p_newintf );
1466             intf_Destroy( p_newintf );
1467         }
1468     }
1469
1470     return VLC_SUCCESS;
1471 }
1472
1473 static int Volume( vlc_object_t *p_this, char const *psz_cmd,
1474                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
1475 {
1476     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1477     input_thread_t *p_input = NULL;
1478     int i_error = VLC_EGENERIC;
1479
1480     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1481     if( !p_input )
1482         return VLC_ENOOBJ;
1483
1484     if( p_input )
1485     {
1486         vlc_value_t val;
1487
1488         var_Get( p_input, "state", &val );
1489         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1490         {
1491             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1492             vlc_object_release( p_input );
1493             return VLC_EGENERIC;
1494         }
1495         vlc_object_release( p_input );
1496     }
1497
1498     if ( *newval.psz_string )
1499     {
1500         /* Set. */
1501         audio_volume_t i_volume = atoi( newval.psz_string );
1502         if ( (i_volume > (audio_volume_t)AOUT_VOLUME_MAX) )
1503         {
1504             msg_rc( "Volume must be in the range %d-%d.", AOUT_VOLUME_MIN,
1505                     AOUT_VOLUME_MAX );
1506             i_error = VLC_EBADVAR;
1507         }
1508         else
1509         {
1510             if( i_volume == AOUT_VOLUME_MIN )
1511             {
1512                 vlc_value_t keyval;
1513
1514                 keyval.i_int = config_GetInt( p_intf, "key-vol-mute" );
1515                 var_Set( p_intf->p_libvlc, "key-pressed", keyval );
1516             }
1517             i_error = aout_VolumeSet( p_this, i_volume );
1518             osd_Volume( p_this );
1519             msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1520         }
1521     }
1522     else
1523     {
1524         /* Get. */
1525         audio_volume_t i_volume;
1526         if ( aout_VolumeGet( p_this, &i_volume ) < 0 )
1527         {
1528             i_error = VLC_EGENERIC;
1529         }
1530         else
1531         {
1532             msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1533             i_error = VLC_SUCCESS;
1534         }
1535     }
1536
1537     return i_error;
1538 }
1539
1540 static int VolumeMove( vlc_object_t *p_this, char const *psz_cmd,
1541                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
1542 {
1543     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1544     audio_volume_t i_volume;
1545     input_thread_t *p_input = NULL;
1546     int i_nb_steps = atoi(newval.psz_string);
1547     int i_error = VLC_SUCCESS;
1548     int i_volume_step = 0;
1549
1550     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1551     if( !p_input )
1552         return VLC_ENOOBJ;
1553
1554     if( p_input )
1555     {
1556         vlc_value_t val;
1557
1558         var_Get( p_input, "state", &val );
1559         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )
1560         {
1561             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1562             vlc_object_release( p_input );
1563             return VLC_EGENERIC;
1564         }
1565         vlc_object_release( p_input );
1566     }
1567
1568     i_volume_step = config_GetInt( p_intf->p_libvlc, "volume-step" );
1569     if ( i_nb_steps <= 0 || i_nb_steps > (AOUT_VOLUME_MAX/i_volume_step) )
1570     {
1571         i_nb_steps = 1;
1572     }
1573
1574     if ( !strcmp(psz_cmd, "volup") )
1575     {
1576         if ( aout_VolumeUp( p_this, i_nb_steps, &i_volume ) < 0 )
1577             i_error = VLC_EGENERIC;
1578     }
1579     else
1580     {
1581         if ( aout_VolumeDown( p_this, i_nb_steps, &i_volume ) < 0 )
1582             i_error = VLC_EGENERIC;
1583     }
1584     osd_Volume( p_this );
1585
1586     if ( !i_error ) msg_rc( STATUS_CHANGE "( audio volume: %d )", i_volume );
1587     return i_error;
1588 }
1589
1590
1591 static int VideoConfig( vlc_object_t *p_this, char const *psz_cmd,
1592                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
1593 {
1594     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1595     input_thread_t *p_input = NULL;
1596     vout_thread_t * p_vout;
1597     const char * psz_variable;
1598     vlc_value_t val_name;
1599     int i_error;
1600
1601     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1602     if( !p_input )
1603         return VLC_ENOOBJ;
1604
1605     p_vout = vlc_object_find( p_input, VLC_OBJECT_VOUT, FIND_CHILD );
1606     vlc_object_release( p_input );
1607     if( !p_vout )
1608         return VLC_ENOOBJ;
1609
1610     if( !strcmp( psz_cmd, "vcrop" ) )
1611     {
1612         psz_variable = "crop";
1613     }
1614     else if( !strcmp( psz_cmd, "vratio" ) )
1615     {
1616         psz_variable = "aspect-ratio";
1617     }
1618     else /* if( !strcmp( psz_cmd, "vzoom" ) ) */
1619     {
1620         psz_variable = "zoom";
1621     }
1622
1623
1624     /* Get the descriptive name of the variable */
1625     var_Change( p_vout, psz_variable, VLC_VAR_GETTEXT,
1626                  &val_name, NULL );
1627     if( !val_name.psz_string ) val_name.psz_string = strdup(psz_variable);
1628
1629     if( newval.psz_string && *newval.psz_string )
1630     {
1631         /* set */
1632         if( !strcmp( psz_variable, "zoom" ) )
1633         {
1634             vlc_value_t val;
1635             val.f_float = atof( newval.psz_string );
1636             i_error = var_Set( p_vout, psz_variable, val );
1637         }
1638         else
1639         {
1640             i_error = var_Set( p_vout, psz_variable, newval );
1641         }
1642     }
1643     else
1644     {
1645         /* get */
1646         vlc_value_t val, text;
1647         int i;
1648         float f_value = 0.;
1649         char *psz_value = NULL;
1650
1651         if ( var_Get( p_vout, psz_variable, &val ) < 0 )
1652         {
1653             vlc_object_release( p_vout );
1654             return VLC_EGENERIC;
1655         }
1656         if( !strcmp( psz_variable, "zoom" ) )
1657         {
1658             f_value = val.f_float;
1659         }
1660         else
1661         {
1662             psz_value = strdup( val.psz_string );
1663         }
1664
1665         if ( var_Change( p_vout, psz_variable,
1666                          VLC_VAR_GETLIST, &val, &text ) < 0 )
1667         {
1668             vlc_object_release( p_vout );
1669             return VLC_EGENERIC;
1670         }
1671
1672         msg_rc( "+----[ %s ]", val_name.psz_string );
1673         if( !strcmp( psz_variable, "zoom" ) )
1674         {
1675             for ( i = 0; i < val.p_list->i_count; i++ )
1676             {
1677                 if ( f_value == val.p_list->p_values[i].f_float )
1678                     msg_rc( "| %f - %s *", val.p_list->p_values[i].f_float,
1679                             text.p_list->p_values[i].psz_string );
1680                 else
1681                     msg_rc( "| %f - %s", val.p_list->p_values[i].f_float,
1682                             text.p_list->p_values[i].psz_string );
1683             }
1684         }
1685         else
1686         {
1687             for ( i = 0; i < val.p_list->i_count; i++ )
1688             {
1689                 if ( !strcmp( psz_value, val.p_list->p_values[i].psz_string ) )
1690                     msg_rc( "| %s - %s *", val.p_list->p_values[i].psz_string,
1691                             text.p_list->p_values[i].psz_string );
1692                 else
1693                     msg_rc( "| %s - %s", val.p_list->p_values[i].psz_string,
1694                             text.p_list->p_values[i].psz_string );
1695             }
1696             free( psz_value );
1697         }
1698         var_Change( p_vout, psz_variable, VLC_VAR_FREELIST,
1699                     &val, &text );
1700         msg_rc( "+----[ end of %s ]", val_name.psz_string );
1701
1702         if( val_name.psz_string ) free( val_name.psz_string );
1703
1704         i_error = VLC_SUCCESS;
1705     }
1706     vlc_object_release( p_vout );
1707     return i_error;
1708 }
1709
1710 static int AudioConfig( vlc_object_t *p_this, char const *psz_cmd,
1711                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
1712 {
1713     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1714     input_thread_t *p_input = NULL;
1715     aout_instance_t * p_aout;
1716     const char * psz_variable;
1717     vlc_value_t val_name;
1718     int i_error;
1719
1720     p_input = vlc_object_find( p_this, VLC_OBJECT_INPUT, FIND_ANYWHERE );
1721     if( !p_input )
1722         return VLC_ENOOBJ;
1723
1724     if( p_input )
1725     {
1726         vlc_value_t val;
1727
1728         var_Get( p_input, "state", &val );
1729         if( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) )        {
1730             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1731             vlc_object_release( p_input );
1732             return VLC_EGENERIC;
1733         }
1734         vlc_object_release( p_input );
1735     }
1736
1737     p_aout = vlc_object_find( p_this, VLC_OBJECT_AOUT, FIND_ANYWHERE );
1738     if ( p_aout == NULL ) return VLC_ENOOBJ;
1739
1740     if ( !strcmp( psz_cmd, "adev" ) )
1741     {
1742         psz_variable = "audio-device";
1743     }
1744     else
1745     {
1746         psz_variable = "audio-channels";
1747     }
1748
1749     /* Get the descriptive name of the variable */
1750     var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_GETTEXT,
1751                  &val_name, NULL );
1752     if( !val_name.psz_string ) val_name.psz_string = strdup(psz_variable);
1753
1754     if ( !*newval.psz_string )
1755     {
1756         /* Retrieve all registered ***. */
1757         vlc_value_t val, text;
1758         int i, i_value;
1759
1760         if ( var_Get( (vlc_object_t *)p_aout, psz_variable, &val ) < 0 )
1761         {
1762             vlc_object_release( (vlc_object_t *)p_aout );
1763             return VLC_EGENERIC;
1764         }
1765         i_value = val.i_int;
1766
1767         if ( var_Change( (vlc_object_t *)p_aout, psz_variable,
1768                          VLC_VAR_GETLIST, &val, &text ) < 0 )
1769         {
1770             vlc_object_release( (vlc_object_t *)p_aout );
1771             return VLC_EGENERIC;
1772         }
1773
1774         msg_rc( "+----[ %s ]", val_name.psz_string );
1775         for ( i = 0; i < val.p_list->i_count; i++ )
1776         {
1777             if ( i_value == val.p_list->p_values[i].i_int )
1778                 msg_rc( "| %i - %s *", val.p_list->p_values[i].i_int,
1779                         text.p_list->p_values[i].psz_string );
1780             else
1781                 msg_rc( "| %i - %s", val.p_list->p_values[i].i_int,
1782                         text.p_list->p_values[i].psz_string );
1783         }
1784         var_Change( (vlc_object_t *)p_aout, psz_variable, VLC_VAR_FREELIST,
1785                     &val, &text );
1786         msg_rc( "+----[ end of %s ]", val_name.psz_string );
1787
1788         if( val_name.psz_string ) free( val_name.psz_string );
1789         i_error = VLC_SUCCESS;
1790     }
1791     else
1792     {
1793         vlc_value_t val;
1794         val.i_int = atoi( newval.psz_string );
1795
1796         i_error = var_Set( (vlc_object_t *)p_aout, psz_variable, val );
1797     }
1798     vlc_object_release( (vlc_object_t *)p_aout );
1799
1800     return i_error;
1801 }
1802
1803 /* OSD menu commands */
1804 static int Menu( vlc_object_t *p_this, char const *psz_cmd,
1805     vlc_value_t oldval, vlc_value_t newval, void *p_data )
1806 {
1807     intf_thread_t *p_intf = (intf_thread_t*)p_this;
1808     playlist_t    *p_playlist = NULL;
1809     vlc_value_t val;
1810     int i_error = VLC_EGENERIC;
1811
1812     if ( !*newval.psz_string )
1813     {
1814         msg_rc( _("Please provide one of the following parameters:") );
1815         msg_rc( "[on|off|up|down|left|right|select]" );
1816         return i_error;
1817     }
1818
1819     p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
1820     if( !p_playlist )
1821         return VLC_ENOOBJ;
1822
1823     if( p_playlist->p_input )
1824     {
1825         var_Get( p_playlist->p_input, "state", &val );
1826         if( ( ( val.i_int == PAUSE_S ) || ( val.i_int == PLAYLIST_PAUSED ) ) &&
1827             ( strcmp( newval.psz_string, "select" ) != 0 ) )
1828         {
1829             msg_rc( _("Type 'menu select' or 'pause' to continue.") );
1830             vlc_object_release( p_playlist );
1831             return VLC_EGENERIC;
1832         }
1833     }
1834     vlc_object_release( p_playlist );
1835
1836     val.psz_string = strdup( newval.psz_string );
1837     if( !strcmp( val.psz_string, "on" ) || !strcmp( val.psz_string, "show" ))
1838         osd_MenuShow( p_this );
1839     else if( !strcmp( val.psz_string, "off" ) || !strcmp( val.psz_string, "hide" ) )
1840         osd_MenuHide( p_this );
1841     else if( !strcmp( val.psz_string, "up" ) )
1842         osd_MenuUp( p_this );
1843     else if( !strcmp( val.psz_string, "down" ) )
1844         osd_MenuDown( p_this );
1845     else if( !strcmp( val.psz_string, "left" ) )
1846         osd_MenuPrev( p_this );
1847     else if( !strcmp( val.psz_string, "right" ) )
1848         osd_MenuNext( p_this );
1849     else if( !strcmp( val.psz_string, "select" ) )
1850         osd_MenuActivate( p_this );
1851     else
1852     {
1853         msg_rc( _("Please provide one of the following parameters:") );
1854         msg_rc( "[on|off|up|down|left|right|select]" );
1855         if( val.psz_string ) free( val.psz_string );
1856             return i_error;
1857     }
1858
1859     i_error = VLC_SUCCESS;
1860     if( val.psz_string ) free( val.psz_string );
1861     return i_error;
1862 }
1863
1864 #ifdef WIN32
1865 vlc_bool_t ReadWin32( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
1866 {
1867     INPUT_RECORD input_record;
1868     DWORD i_dw;
1869
1870     /* On Win32, select() only works on socket descriptors */
1871     while( WaitForSingleObject( p_intf->p_sys->hConsoleIn,
1872                                 INTF_IDLE_SLEEP/1000 ) == WAIT_OBJECT_0 )
1873     {
1874         while( !intf_ShouldDie( p_intf ) && *pi_size < MAX_LINE_LENGTH &&
1875                ReadConsoleInput( p_intf->p_sys->hConsoleIn, &input_record,
1876                                  1, &i_dw ) )
1877         {
1878             if( input_record.EventType != KEY_EVENT ||
1879                 !input_record.Event.KeyEvent.bKeyDown ||
1880                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_SHIFT ||
1881                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CONTROL||
1882                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_MENU ||
1883                 input_record.Event.KeyEvent.wVirtualKeyCode == VK_CAPITAL )
1884             {
1885                 /* nothing interesting */
1886                 continue;
1887             }
1888
1889             p_buffer[ *pi_size ] = input_record.Event.KeyEvent.uChar.AsciiChar;
1890
1891             /* Echo out the command */
1892             putc( p_buffer[ *pi_size ], stdout );
1893
1894             /* Handle special keys */
1895             if( p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
1896             {
1897                 putc( '\n', stdout );
1898                 break;
1899             }
1900             switch( p_buffer[ *pi_size ] )
1901             {
1902             case '\b':
1903                 if( *pi_size )
1904                 {
1905                     *pi_size -= 2;
1906                     putc( ' ', stdout );
1907                     putc( '\b', stdout );
1908                 }
1909                 break;
1910             case '\r':
1911                 (*pi_size) --;
1912                 break;
1913             }
1914
1915             (*pi_size)++;
1916         }
1917
1918         if( *pi_size == MAX_LINE_LENGTH ||
1919             p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
1920         {
1921             p_buffer[ *pi_size ] = 0;
1922             return VLC_TRUE;
1923         }
1924     }
1925
1926     return VLC_FALSE;
1927 }
1928 #endif
1929
1930 vlc_bool_t ReadCommand( intf_thread_t *p_intf, char *p_buffer, int *pi_size )
1931 {
1932     int i_read = 0;
1933
1934 #ifdef WIN32
1935     if( p_intf->p_sys->i_socket == -1 && !p_intf->p_sys->b_quiet )
1936         return ReadWin32( p_intf, p_buffer, pi_size );
1937     else if( p_intf->p_sys->i_socket == -1 )
1938     {
1939         msleep( INTF_IDLE_SLEEP );
1940         return VLC_FALSE;
1941     }
1942 #endif
1943
1944     while( !intf_ShouldDie( p_intf ) && *pi_size < MAX_LINE_LENGTH &&
1945            (i_read = net_Read( p_intf, p_intf->p_sys->i_socket == -1 ?
1946                        0 /*STDIN_FILENO*/ : p_intf->p_sys->i_socket, NULL,
1947                   (uint8_t *)p_buffer + *pi_size, 1, VLC_FALSE ) ) > 0 )
1948     {
1949         if( p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
1950             break;
1951
1952         (*pi_size)++;
1953     }
1954
1955     /* Connection closed */
1956     if( i_read <= 0 )
1957     {
1958         if( p_intf->p_sys->i_socket != -1 )
1959         {
1960             net_Close( p_intf->p_sys->i_socket );
1961             p_intf->p_sys->i_socket = -1;
1962         }
1963         else
1964             /* Standard input closed: exit */
1965             vlc_object_kill( p_intf );
1966
1967         p_buffer[ *pi_size ] = 0;
1968         return VLC_TRUE;
1969     }
1970
1971     if( *pi_size == MAX_LINE_LENGTH ||
1972         p_buffer[ *pi_size ] == '\r' || p_buffer[ *pi_size ] == '\n' )
1973     {
1974         p_buffer[ *pi_size ] = 0;
1975         return VLC_TRUE;
1976     }
1977
1978     return VLC_FALSE;
1979 }
1980
1981 /*****************************************************************************
1982  * parse_MRL: build a input item from a full mrl
1983  *****************************************************************************
1984  * MRL format: "simplified-mrl [:option-name[=option-value]]"
1985  * We don't check for '"' or '\'', we just assume that a ':' that follows a
1986  * space is a new option. Should be good enough for our purpose.
1987  *****************************************************************************/
1988 static input_item_t *parse_MRL( intf_thread_t *p_intf, char *psz_mrl )
1989 {
1990 #define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
1991 #define SKIPTRAILINGSPACE( p, d ) \
1992     { char *e=d; while( e > p && (*(e-1)==' ' || *(e-1)=='\t') ){e--;*e=0;} }
1993
1994     input_item_t *p_item = NULL;
1995     char *psz_item = NULL, *psz_item_mrl = NULL, *psz_orig;
1996     char **ppsz_options = NULL;
1997     int i, i_options = 0;
1998
1999     if( !psz_mrl ) return 0;
2000
2001     psz_mrl = psz_orig = strdup( psz_mrl );
2002     while( *psz_mrl )
2003     {
2004         SKIPSPACE( psz_mrl );
2005         psz_item = psz_mrl;
2006
2007         for( ; *psz_mrl; psz_mrl++ )
2008         {
2009             if( (*psz_mrl == ' ' || *psz_mrl == '\t') && psz_mrl[1] == ':' )
2010             {
2011                 /* We have a complete item */
2012                 break;
2013             }
2014             if( (*psz_mrl == ' ' || *psz_mrl == '\t') &&
2015                 (psz_mrl[1] == '"' || psz_mrl[1] == '\'') && psz_mrl[2] == ':')
2016             {
2017                 /* We have a complete item */
2018                 break;
2019             }
2020         }
2021
2022         if( *psz_mrl ) { *psz_mrl = 0; psz_mrl++; }
2023         SKIPTRAILINGSPACE( psz_item, psz_item + strlen( psz_item ) );
2024
2025         /* Remove '"' and '\'' if necessary */
2026         if( *psz_item == '"' && psz_item[strlen(psz_item)-1] == '"' )
2027         { psz_item++; psz_item[strlen(psz_item)-1] = 0; }
2028         if( *psz_item == '\'' && psz_item[strlen(psz_item)-1] == '\'' )
2029         { psz_item++; psz_item[strlen(psz_item)-1] = 0; }
2030
2031         if( !psz_item_mrl ) psz_item_mrl = psz_item;
2032         else if( *psz_item )
2033         {
2034             i_options++;
2035             ppsz_options = realloc( ppsz_options, i_options * sizeof(char *) );
2036             ppsz_options[i_options - 1] = &psz_item[1];
2037         }
2038
2039         if( *psz_mrl ) SKIPSPACE( psz_mrl );
2040     }
2041
2042     /* Now create a playlist item */
2043     if( psz_item_mrl )
2044     {
2045         p_item = input_ItemNew( p_intf, psz_item_mrl, NULL );
2046         for( i = 0; i < i_options; i++ )
2047         {
2048             input_ItemAddOption( p_item, ppsz_options[i] );
2049         }
2050     }
2051
2052     if( i_options ) free( ppsz_options );
2053     free( psz_orig );
2054
2055     return p_item;
2056 }
2057
2058 /*****************************************************************************
2059  * checkUpdates : check for updates
2060  ****************************************************************************/
2061 static void checkUpdates( intf_thread_t *p_intf, char *psz_arg )
2062 {
2063     update_iterator_t *p_uit;
2064     update_t *p_u = update_New( p_intf );
2065     if( p_u == NULL ) return;
2066     p_uit = update_iterator_New( p_u );
2067     if( p_uit )
2068     {
2069         int s = 0, t = 0;
2070
2071         if( strstr( psz_arg, "newer" ) )
2072             s |= UPDATE_RELEASE_STATUS_NEWER;
2073         if( strstr( psz_arg, "equal" ) )
2074             s |= UPDATE_RELEASE_STATUS_EQUAL;
2075         if( strstr( psz_arg, "older" ) )
2076             s |= UPDATE_RELEASE_STATUS_OLDER;
2077         if( s ) p_uit->i_rs = s;
2078         else p_uit->i_rs = UPDATE_RELEASE_STATUS_NEWER;
2079
2080         if( strstr( psz_arg, "undef" ) )
2081             t |= UPDATE_FILE_TYPE_UNDEF;
2082         if( strstr( psz_arg, "info" ) )
2083             t |= UPDATE_FILE_TYPE_INFO;
2084         if( strstr( psz_arg, "source" ) )
2085             t |= UPDATE_FILE_TYPE_SOURCE;
2086         if( strstr( psz_arg, "binary" ) )
2087             t |= UPDATE_FILE_TYPE_BINARY;
2088         if( strstr( psz_arg, "plugin" ) )
2089             t |= UPDATE_FILE_TYPE_PLUGIN;
2090         if( t ) p_uit->i_t = t;
2091
2092         update_Check( p_u, VLC_FALSE );
2093         update_iterator_Action( p_uit, UPDATE_MIRROR );
2094         msg_rc( "\nUsing mirror: %s (%s) [%s]",
2095                 p_uit->mirror.psz_name,
2096                 p_uit->mirror.psz_location,
2097                 p_uit->mirror.psz_type );
2098         while( (s = update_iterator_Action( p_uit, UPDATE_FILE )) != UPDATE_FAIL )
2099         {
2100             char *psz_tmp;
2101             if( s & UPDATE_RELEASE )
2102             {
2103                 switch( p_uit->release.i_status )
2104                 {
2105                     case UPDATE_RELEASE_STATUS_OLDER:
2106                         psz_tmp = strdup( "older" );
2107                         break;
2108                     case UPDATE_RELEASE_STATUS_EQUAL:
2109                         psz_tmp = strdup( "equal" );
2110                         break;
2111                     case UPDATE_RELEASE_STATUS_NEWER:
2112                         psz_tmp = strdup( "newer" );
2113                         break;
2114                     default:
2115                         psz_tmp = strdup( "?!?" );
2116                         break;
2117                 }
2118                 msg_rc( "\n+----[ VLC %s %s (%s) ] ",
2119                         p_uit->release.psz_version,
2120                         p_uit->release.psz_svn_revision,
2121                         psz_tmp );
2122                 free( psz_tmp );
2123             }
2124             switch( p_uit->file.i_type )
2125             {
2126                 case UPDATE_FILE_TYPE_UNDEF:
2127                     psz_tmp = strdup( "undef" );
2128                     break;
2129                 case UPDATE_FILE_TYPE_INFO:
2130                     psz_tmp = strdup( "info" );
2131                     break;
2132                 case UPDATE_FILE_TYPE_SOURCE:
2133                     psz_tmp = strdup( "source" );
2134                     break;
2135                 case UPDATE_FILE_TYPE_BINARY:
2136                     psz_tmp = strdup( "binary" );
2137                     break;
2138                 case UPDATE_FILE_TYPE_PLUGIN:
2139                     psz_tmp = strdup( "plugin" );
2140                     break;
2141                 default:
2142                     psz_tmp = strdup( "?!?" );
2143                     break;
2144             }
2145             msg_rc( "| %s (%s)", p_uit->file.psz_description, psz_tmp );
2146             free( psz_tmp );
2147             if( p_uit->file.l_size )
2148             {
2149                 if( p_uit->file.l_size > 1024 * 1024 * 1024 )
2150                     asprintf( &psz_tmp, "(%ld GB)",
2151                               p_uit->file.l_size / (1024*1024*1024) );
2152                 if( p_uit->file.l_size > 1024 * 1024 )
2153                     asprintf( &psz_tmp, "(%ld MB)",
2154                               p_uit->file.l_size / (1024*1024) );
2155                 else if( p_uit->file.l_size > 1024 )
2156                     asprintf( &psz_tmp, "(%ld kB)",
2157                               p_uit->file.l_size / 1024 );
2158                 else
2159                     asprintf( &psz_tmp, "(%ld B)", p_uit->file.l_size );
2160             }
2161             else
2162             {
2163                 psz_tmp = strdup( "" );
2164             }
2165             msg_rc( "| %s %s", p_uit->file.psz_url, psz_tmp );
2166             msg_rc( "+----" );
2167             free( psz_tmp );
2168         }
2169         msg_rc( "" );
2170         update_iterator_Delete( p_uit );
2171     }
2172     update_Delete( p_u );
2173 }