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