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