* ./debian/rules: moved the gtk_main and gnome_main plugins to the gvlc
[vlc.git] / modules / control / rc / rc.c
1 /*****************************************************************************
2  * rc.c : remote control stdin/stdout plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2001 VideoLAN
5  * $Id: rc.c,v 1.5 2002/09/30 11:05:37 sam Exp $
6  *
7  * Authors: Peter Surda <shurdeek@panorama.sth.ac.at>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  * 
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>                                      /* malloc(), free() */
28 #include <string.h>
29
30 #include <errno.h>                                                 /* ENOMEM */
31 #include <stdio.h>
32 #include <ctype.h>
33 #include <signal.h>
34
35 #include <vlc/vlc.h>
36 #include <vlc/intf.h>
37 #include <vlc/vout.h>
38
39 #ifdef HAVE_UNISTD_H
40 #    include <unistd.h>
41 #endif
42
43 #ifdef HAVE_SYS_TIME_H
44 #    include <sys/time.h>
45 #endif
46 #include <sys/types.h>
47
48 #if defined( WIN32 )
49 #include <winsock2.h>                                            /* select() */
50 #endif
51
52 #define MAX_LINE_LENGTH 256
53
54 /*****************************************************************************
55  * Local prototypes
56  *****************************************************************************/
57 static int  Activate     ( vlc_object_t * );
58 static void Run          ( intf_thread_t *p_intf );
59
60 /*****************************************************************************
61  * Module descriptor
62  *****************************************************************************/
63 #define POS_TEXT N_("show stream position")
64 #define POS_LONGTEXT N_("Show the current position in seconds within the stream from time to time.")
65
66 #define TTY_TEXT N_("fake TTY")
67 #define TTY_LONGTEXT N_("Force the rc plugin to use stdin as if it was a TTY.")
68
69 vlc_module_begin();
70     add_category_hint( N_("Remote control"), NULL );
71     add_bool( "rc-show-pos", 0, NULL, POS_TEXT, POS_LONGTEXT );
72     add_bool( "fake-tty", 0, NULL, TTY_TEXT, TTY_LONGTEXT );
73     set_description( _("remote control interface module") );
74     set_capability( "interface", 20 );
75     set_callbacks( Activate, NULL );
76 vlc_module_end();
77
78 /*****************************************************************************
79  * Activate: initialize and create stuff
80  *****************************************************************************/
81 static int Activate( vlc_object_t *p_this )
82 {
83     intf_thread_t *p_intf = (intf_thread_t*)p_this;
84
85 #ifdef HAVE_ISATTY
86     /* Check that stdin is a TTY */
87     if( !config_GetInt( p_intf, "fake-tty" ) && !isatty( 0 ) )
88     {
89         msg_Warn( p_intf, "fd 0 is not a TTY" );
90         return 1;
91     }
92 #endif
93
94     /* Non-buffered stdout */
95     setvbuf( stdout, (char *)NULL, _IOLBF, 0 );
96
97     p_intf->pf_run = Run;
98
99 #ifdef WIN32
100     AllocConsole();
101     freopen( "CONOUT$", "w", stdout );
102     freopen( "CONOUT$", "w", stderr );
103     freopen( "CONIN$", "r", stdin );
104     printf( VERSION_MESSAGE "\n" );
105 #endif
106
107     printf( "remote control interface initialized, `h' for help\n" );
108     return 0;
109 }
110
111 /*****************************************************************************
112  * Run: rc thread
113  *****************************************************************************
114  * This part of the interface is in a separate thread so that we can call
115  * exec() from within it without annoying the rest of the program.
116  *****************************************************************************/
117 static void Run( intf_thread_t *p_intf )
118 {
119     input_thread_t * p_input;
120     playlist_t *     p_playlist;
121
122     char       p_buffer[ MAX_LINE_LENGTH + 1 ];
123     vlc_bool_t b_complete = 0;
124     vlc_bool_t b_showpos = config_GetInt( p_intf, "rc-show-pos" );
125     input_info_category_t * p_category;
126     input_info_t * p_info;
127
128     int        i_dummy;
129     off_t      i_oldpos = 0;
130     off_t      i_newpos;
131     fd_set     fds;                                        /* stdin changed? */
132     struct timeval tv;                                   /* how long to wait */
133
134     double     f_ratio = 1;
135
136     p_input = NULL;
137     p_playlist = NULL;
138
139     while( !p_intf->b_die )
140     {
141         b_complete = 0;
142
143         /* Check stdin */
144         tv.tv_sec = 0;
145         tv.tv_usec = 50000;
146         FD_ZERO( &fds );
147         FD_SET( STDIN_FILENO, &fds );
148
149         i_dummy = select( 32, &fds, NULL, NULL, &tv );
150         if( i_dummy > 0 )
151         {
152             int i_size = 0;
153
154             while( !p_intf->b_die
155                     && i_size < MAX_LINE_LENGTH
156                     && read( STDIN_FILENO, p_buffer + i_size, 1 ) > 0
157                     && p_buffer[ i_size ] != '\r'
158                     && p_buffer[ i_size ] != '\n' )
159             {
160                 i_size++;
161             }
162
163             if( i_size == MAX_LINE_LENGTH
164                  || p_buffer[ i_size ] == '\r'
165                  || p_buffer[ i_size ] == '\n' )
166             {
167                 p_buffer[ i_size ] = 0;
168                 b_complete = 1;
169             }
170         }
171
172         /* Manage the input part */
173         if( p_input == NULL )
174         {
175             if( p_playlist )
176             {
177                 p_input = vlc_object_find( p_playlist, VLC_OBJECT_INPUT,
178                                                        FIND_CHILD );
179             }
180             else
181             {
182                 p_input = vlc_object_find( p_intf, VLC_OBJECT_INPUT,
183                                                    FIND_ANYWHERE );
184                 //if( p_input )
185                 {
186                     p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
187                                                            FIND_PARENT );
188                 }
189             }
190         }
191         else if( p_input->b_dead )
192         {
193             vlc_object_release( p_input );
194             p_input = NULL;
195         }
196
197         if( p_input && b_showpos )
198         {
199             /* Get position */
200             vlc_mutex_lock( &p_input->stream.stream_lock );
201             if( !p_input->b_die && p_input->stream.i_mux_rate )
202             {
203 #define A p_input->stream.p_selected_area
204                 f_ratio = 1.0 / ( 50 * p_input->stream.i_mux_rate );
205                 i_newpos = A->i_tell * f_ratio;
206
207                 if( i_oldpos != i_newpos )
208                 {
209                     i_oldpos = i_newpos;
210                     printf( "pos: %li s / %li s\n", (long int)i_newpos,
211                             (long int)(f_ratio * A->i_size) );
212                 }
213 #undef S
214             }
215             vlc_mutex_unlock( &p_input->stream.stream_lock );
216         }
217
218         /* Is there something to do? */
219         if( b_complete == 1 )
220         {
221             char *p_cmd = p_buffer;
222             char *p_tmp;
223
224             if( !strcmp( p_cmd, "quit" ) )
225             {
226                 p_intf->p_vlc->b_die = VLC_TRUE;
227             }
228             else if( !strcmp( p_cmd, "segfault" ) )
229             {
230                 raise( SIGSEGV );
231             }
232             else if( !strcmp( p_cmd, "prev" ) )
233             {
234                 if( p_playlist ) playlist_Prev( p_playlist );
235             }
236             else if( !strcmp( p_cmd, "next" ) )
237             {
238                 if( p_playlist ) playlist_Next( p_playlist );
239             }
240             else if( !strcmp( p_cmd, "play" ) )
241             {
242                 if( p_playlist ) playlist_Play( p_playlist );
243             }
244             else if( !strcmp( p_cmd, "stop" ) )
245             {
246                 if( p_playlist ) playlist_Stop( p_playlist );
247             }
248             else if( !strcmp( p_cmd, "pause" ) )
249             {
250                 if( p_input ) input_SetStatus( p_input, INPUT_STATUS_PAUSE );
251             }
252             else if( !strcmp( p_cmd, "tree" ) )
253             {
254                 vlc_dumpstructure( p_intf->p_vlc );
255             }
256             else if( !strcmp( p_cmd, "list" ) )
257             {
258                 vlc_liststructure( p_intf->p_vlc );
259             }
260             else if( !strncmp( p_cmd, "set ", 4 ) )
261             {
262 //                vlc_set_r( p_intf->p_vlc, p_cmd + 4, strstr( p_cmd + 4, " " ) );
263                 p_tmp = strstr( p_cmd + 4, " " );
264                 p_tmp[0] = '\0';
265                 config_PutPsz( p_intf->p_vlc, p_cmd + 4, p_tmp + 1 );
266                 config_PutInt( p_intf->p_vlc, p_cmd + 4, atoi(p_tmp + 1) );
267             }
268             else if( !strncmp( p_cmd, "intf ", 5 ) )
269             {
270                 intf_thread_t *p_newintf;
271                 char *psz_oldmodule = config_GetPsz( p_intf->p_vlc, "intf" );
272
273                 config_PutPsz( p_intf->p_vlc, "intf", p_cmd + 5 );
274                 p_newintf = intf_Create( p_intf->p_vlc );
275                 config_PutPsz( p_intf->p_vlc, "intf", psz_oldmodule );
276
277                 if( psz_oldmodule )
278                 {
279                     free( psz_oldmodule );
280                 }
281
282                 if( p_newintf )
283                 {
284                     p_newintf->b_block = VLC_FALSE;
285                     if( intf_RunThread( p_newintf ) )
286                     {
287                         vlc_object_detach( p_newintf );
288                         intf_Destroy( p_newintf );
289                     }
290                 }
291             }
292             else if( !strcmp( p_cmd, "info" ) )
293             {
294                 if ( p_input )
295                 {
296                     vlc_mutex_lock( &p_input->stream.stream_lock );
297                     p_category = p_input->stream.p_info;
298                     while ( p_category )
299                     {
300                         printf( "+----[ %s ]\n", p_category->psz_name );
301                         printf( "| \n" );
302                         p_info = p_category->p_info;
303                         while ( p_info )
304                         {
305                             printf( "| %s: %s\n", p_info->psz_name,
306                                     p_info->psz_value );
307                             p_info = p_info->p_next;
308                         }
309                         p_category = p_category->p_next;
310                         printf( "| \n" );
311                     }
312                     printf( "+----[ end of stream info ]\n" );
313                     vlc_mutex_unlock( &p_input->stream.stream_lock );
314                 }
315                 else
316                 {
317                     printf( "no input\n" );
318                 }
319             }
320             else switch( p_cmd[0] )
321             {
322             case 'a':
323             case 'A':
324                 if( p_cmd[1] == ' ' && p_playlist )
325                 {
326                     playlist_Add( p_playlist, p_cmd + 2,
327                                   PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
328                 }
329                 break;
330
331             case 'f':
332             case 'F':
333                 if( p_input )
334                 {
335                     vout_thread_t *p_vout;
336                     p_vout = vlc_object_find( p_input,
337                                               VLC_OBJECT_VOUT, FIND_CHILD );
338
339                     if( p_vout )
340                     {
341                         p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
342                         vlc_object_release( p_vout );
343                     }
344                 }
345                 break;
346
347             case 's':
348             case 'S':
349                 ;
350                 break;
351
352             case 'r':
353             case 'R':
354                 if( p_input )
355                 {
356                     for( i_dummy = 1;
357                          i_dummy < MAX_LINE_LENGTH && p_cmd[ i_dummy ] >= '0'
358                                                    && p_cmd[ i_dummy ] <= '9';
359                          i_dummy++ )
360                     {
361                         ;
362                     }
363
364                     p_cmd[ i_dummy ] = 0;
365                     input_Seek( p_input, (off_t)atoi( p_cmd + 1 ),
366                                 INPUT_SEEK_SECONDS | INPUT_SEEK_SET );
367                     /* rcreseek(f_cpos); */
368                 }
369                 break;
370
371             case '?':
372             case 'h':
373             case 'H':
374                 printf("+----[ remote control commands ]\n");
375                 printf("| \n");
376                 printf("| a XYZ  . . . . . . . . . . . add XYZ to playlist\n");
377                 printf("| play . . . . . . . . . . . . . . . . play stream\n");
378                 printf("| stop . . . . . . . . . . . . . . . . stop stream\n");
379                 printf("| next . . . . . . . . . . . .  next playlist item\n");
380                 printf("| prev . . . . . . . . . .  previous playlist item\n");
381                 printf("| \n");
382                 printf("| r X  . . . seek in seconds, for instance `r 3.5'\n");
383                 printf("| pause  . . . . . . . . . . . . . .  toggle pause\n");
384                 printf("| f  . . . . . . . . . . . . . . toggle fullscreen\n");
385                 printf("| info . . .  information about the current stream\n");
386                 printf("| \n");
387                 printf("| help . . . . . . . . . . . . . this help message\n");
388                 printf("| quit . . . . . . . . . . . . . . . . .  quit vlc\n");
389                 printf("| \n");
390                 printf("+----[ end of help ]\n");
391                 break;
392             case '\0':
393                 /* Ignore empty lines */
394                 break;
395             default:
396                 printf( "unknown command `%s', type `help' for help\n", p_cmd );
397                 break;
398             }
399         }
400
401         msleep( INTF_IDLE_SLEEP );
402     }
403
404     if( p_input )
405     {
406         vlc_object_release( p_input );
407         p_input = NULL;
408     }
409
410     if( p_playlist )
411     {
412         vlc_object_release( p_playlist );
413         p_playlist = NULL;
414     }
415 }
416