?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
audiotrack: simplify native rate handling
[vlc.git] / src / input / vlmshell.c
blobd30df1f08a1f73b9bb0001588f8d8ef9546ca202
1 /*****************************************************************************
2 * vlmshell.c: VLM interface plugin
3 *****************************************************************************
4 * Copyright (C) 2000-2005 VLC authors and VideoLAN
5 * $Id$
6 *
7 * Authors: Simon Latapie <garf@videolan.org>
8 * Laurent Aimar <fenrir@videolan.org>
9 * Gildas Bazin <gbazin@videolan.org>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU Lesser General Public License as published by
13 * the Free Software Foundation; either version 2.1 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public License
22 * along with this program; if not, write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
25
26 /*****************************************************************************
27 * Preamble
28 *****************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34
35 #include <stdio.h>
36 #include <ctype.h> /* tolower() */
37 #include <assert.h>
38
39 #include <vlc_vlm.h>
40
41 #ifdef ENABLE_VLM
42
43 #include <time.h> /* ctime() */
44 #include <limits.h>
45 #include <fcntl.h>
46 #include <sys/stat.h>
47
48 #include <vlc_input.h>
49 #include "input_internal.h"
50 #include <vlc_stream.h>
51 #include "vlm_internal.h"
52 #include <vlc_charset.h>
53 #include <vlc_fs.h>
54 #include <vlc_sout.h>
55 #include "../stream_output/stream_output.h"
56 #include "../libvlc.h"
57
58 /*****************************************************************************
59 * Local prototypes.
60 *****************************************************************************/
61
62 /* */
63 static vlm_message_t *vlm_Show( vlm_t *, vlm_media_sys_t *, vlm_schedule_sys_t *, const char * );
64
65 static vlm_schedule_sys_t *vlm_ScheduleSearch( vlm_t *, const char * );
66
67 static char *Save( vlm_t * );
68 static int Load( vlm_t *, char * );
69
70 static vlm_schedule_sys_t *vlm_ScheduleNew( vlm_t *vlm, const char *psz_name );
71 static int vlm_ScheduleSetup( vlm_schedule_sys_t *schedule, const char *psz_cmd,
72 const char *psz_value );
73
74 /* */
75 static vlm_media_sys_t *vlm_MediaSearch( vlm_t *, const char *);
76
77 static const char quotes[] = "\"'";
78 /**
79 * FindCommandEnd: look for the end of a possibly quoted string
80 * @return NULL on mal-formatted string,
81 * pointer past the last character otherwise.
82 */
83 static const char *FindCommandEnd( const char *psz_sent )
84 {
85 unsigned char c, quote = 0;
86
87 while( (c = *psz_sent) != '\0' )
88 {
89 if( !quote )
90 {
91 if( strchr(quotes,c) ) // opening quote
92 quote = c;
93 else if( isspace(c) ) // non-escaped space
94 return psz_sent;
95 else if( c == '\\' )
96 {
97 psz_sent++; // skip escaped character
98 if( *psz_sent == '\0' )
99 return psz_sent;
100 }
101 }
102 else
103 {
104 if( c == quote ) // non-escaped matching quote
105 quote = 0;
106 else if( (quote == '"') && (c == '\\') )
107 {
108 psz_sent++; // skip escaped character
109 if (*psz_sent == '\0')
110 return NULL; // error, closing quote missing
111 }
112 }
113 psz_sent++;
114 }
115
116 // error (NULL) if we could not find a matching quote
117 return quote ? NULL : psz_sent;
118 }
119
120
121 /**
122 * Unescape a nul-terminated string.
123 * Note that in and out can be identical.
124 *
125 * @param out output buffer (at least <strlen (in) + 1> characters long)
126 * @param in nul-terminated string to be unescaped
127 *
128 * @return 0 on success, -1 on error.
129 */
130 static int Unescape( char *out, const char *in )
131 {
132 unsigned char c, quote = 0;
133 bool param = false;
134
135 while( (c = *in++) != '\0' )
136 {
137 // Don't escape the end of the string if we find a '#'
138 // that's the beginning of a vlc command
139 // TODO: find a better solution
140 if( ( c == '#' && !quote ) || param )
141 {
142 param = true;
143 *out++ = c;
144 continue;
145 }
146
147 if( !quote )
148 {
149 if (strchr(quotes,c)) // opening quote
150 {
151 quote = c;
152 continue;
153 }
154 else if( c == '\\' )
155 {
156 switch (c = *in++)
157 {
158 case '"':
159 case '\'':
160 case '\\':
161 *out++ = c;
162 continue;
163
164 case '\0':
165 *out = '\0';
166 return 0;
167 }
168 if( isspace(c) )
169 {
170 *out++ = c;
171 continue;
172 }
173 /* None of the special cases - copy the backslash */
174 *out++ = '\\';
175 }
176 }
177 else
178 {
179 if( c == quote ) // non-escaped matching quote
180 {
181 quote = 0;
182 continue;
183 }
184 if( (quote == '"') && (c == '\\') )
185 {
186 switch( c = *in++ )
187 {
188 case '"':
189 case '\\':
190 *out++ = c;
191 continue;
192
193 case '\0': // should never happen
194 *out = '\0';
195 return -1;
196 }
197 /* None of the special cases - copy the backslash */
198 *out++ = '\\';
199 }
200 }
201 *out++ = c;
202 }
203
204 *out = '\0';
205 return 0;
206 }
207
208
209 /*****************************************************************************
210 * ExecuteCommand: The main state machine
211 *****************************************************************************
212 * Execute a command which ends with '\0' (string)
213 *****************************************************************************/
214 static int ExecuteSyntaxError( const char *psz_cmd, vlm_message_t **pp_status )
215 {
216 *pp_status = vlm_MessageNew( psz_cmd, "Wrong command syntax" );
217 return VLC_EGENERIC;
218 }
219
220 static bool ExecuteIsMedia( vlm_t *p_vlm, const char *psz_name )
221 {
222 int64_t id;
223
224 if( !psz_name || vlm_ControlInternal( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) )
225 return false;
226 return true;
227 }
228 static bool ExecuteIsSchedule( vlm_t *p_vlm, const char *psz_name )
229 {
230 if( !psz_name || !vlm_ScheduleSearch( p_vlm, psz_name ) )
231 return false;
232 return true;
233 }
234
235 static int ExecuteDel( vlm_t *p_vlm, const char *psz_name, vlm_message_t **pp_status )
236 {
237 vlm_media_sys_t *p_media;
238 vlm_schedule_sys_t *p_schedule;
239
240 p_media = vlm_MediaSearch( p_vlm, psz_name );
241 p_schedule = vlm_ScheduleSearch( p_vlm, psz_name );
242
243 if( p_schedule != NULL )
244 {
245 vlm_ScheduleDelete( p_vlm, p_schedule );
246 }
247 else if( p_media != NULL )
248 {
249 vlm_ControlInternal( p_vlm, VLM_DEL_MEDIA, p_media->cfg.id );
250 }
251 else if( !strcmp(psz_name, "media") )
252 {
253 vlm_ControlInternal( p_vlm, VLM_CLEAR_MEDIAS );
254 }
255 else if( !strcmp(psz_name, "schedule") )
256 {
257 vlm_ControlInternal( p_vlm, VLM_CLEAR_SCHEDULES );
258 }
259 else if( !strcmp(psz_name, "all") )
260 {
261 vlm_ControlInternal( p_vlm, VLM_CLEAR_MEDIAS );
262 vlm_ControlInternal( p_vlm, VLM_CLEAR_SCHEDULES );
263 }
264 else
265 {
266 *pp_status = vlm_MessageNew( "del", "%s: media unknown", psz_name );
267 return VLC_EGENERIC;
268 }
269
270 *pp_status = vlm_MessageSimpleNew( "del" );
271 return VLC_SUCCESS;
272 }
273
274 static int ExecuteShow( vlm_t *p_vlm, const char *psz_name, vlm_message_t **pp_status )
275 {
276 vlm_media_sys_t *p_media;
277 vlm_schedule_sys_t *p_schedule;
278
279 if( !psz_name )
280 {
281 *pp_status = vlm_Show( p_vlm, NULL, NULL, NULL );
282 return VLC_SUCCESS;
283 }
284
285 p_media = vlm_MediaSearch( p_vlm, psz_name );
286 p_schedule = vlm_ScheduleSearch( p_vlm, psz_name );
287
288 if( p_schedule != NULL )
289 *pp_status = vlm_Show( p_vlm, NULL, p_schedule, NULL );
290 else if( p_media != NULL )
291 *pp_status = vlm_Show( p_vlm, p_media, NULL, NULL );
292 else
293 *pp_status = vlm_Show( p_vlm, NULL, NULL, psz_name );
294
295 return VLC_SUCCESS;
296 }
297
298 static int ExecuteHelp( vlm_message_t **pp_status )
299 {
300 vlm_message_t *message_child;
301
302 #define MessageAdd( a ) \
303 vlm_MessageAdd( *pp_status, vlm_MessageSimpleNew( a ) );
304 #define MessageAddChild( a ) \
305 vlm_MessageAdd( message_child, vlm_MessageSimpleNew( a ) );
306
307 *pp_status = vlm_MessageSimpleNew( "help" );
308
309 message_child = MessageAdd( "Commands Syntax:" );
310 MessageAddChild( "new (name) vod|broadcast|schedule [properties]" );
311 MessageAddChild( "setup (name) (properties)" );
312 MessageAddChild( "show [(name)|media|schedule]" );
313 MessageAddChild( "del (name)|all|media|schedule" );
314 MessageAddChild( "control (name) [instance_name] (command)" );
315 MessageAddChild( "save (config_file)" );
316 MessageAddChild( "export" );
317 MessageAddChild( "load (config_file)" );
318
319 message_child = MessageAdd( "Media Proprieties Syntax:" );
320 MessageAddChild( "input (input_name)" );
321 MessageAddChild( "inputdel (input_name)|all" );
322 MessageAddChild( "inputdeln input_number" );
323 MessageAddChild( "output (output_name)" );
324 MessageAddChild( "option (option_name)[=value]" );
325 MessageAddChild( "enabled|disabled" );
326 MessageAddChild( "loop|unloop (broadcast only)" );
327 MessageAddChild( "mux (mux_name)" );
328
329 message_child = MessageAdd( "Schedule Proprieties Syntax:" );
330 MessageAddChild( "enabled|disabled" );
331 MessageAddChild( "append (command_until_rest_of_the_line)" );
332 MessageAddChild( "date (year)/(month)/(day)-(hour):(minutes):"
333 "(seconds)|now" );
334 MessageAddChild( "period (years_aka_12_months)/(months_aka_30_days)/"
335 "(days)-(hours):(minutes):(seconds)" );
336 MessageAddChild( "repeat (number_of_repetitions)" );
337
338 message_child = MessageAdd( "Control Commands Syntax:" );
339 MessageAddChild( "play [input_number]" );
340 MessageAddChild( "pause" );
341 MessageAddChild( "stop" );
342 MessageAddChild( "seek [+-](percentage) | [+-](seconds)s | [+-](milliseconds)ms" );
343
344 return VLC_SUCCESS;
345 }
346
347 static int ExecuteControl( vlm_t *p_vlm, const char *psz_name, const int i_arg, char ** ppsz_arg, vlm_message_t **pp_status )
348 {
349 vlm_media_sys_t *p_media;
350 const char *psz_control = NULL;
351 const char *psz_instance = NULL;
352 const char *psz_argument = NULL;
353 int i_index;
354 int i_result;
355
356 if( !ExecuteIsMedia( p_vlm, psz_name ) )
357 {
358 *pp_status = vlm_MessageNew( "control", "%s: media unknown", psz_name );
359 return VLC_EGENERIC;
360 }
361
362 assert( i_arg > 0 );
363
364 #define IS(txt) ( !strcmp( ppsz_arg[i_index], (txt) ) )
365 i_index = 0;
366 if( !IS("play") && !IS("stop") && !IS("pause") && !IS("seek") )
367 {
368 i_index = 1;
369 psz_instance = ppsz_arg[0];
370
371 if( i_index >= i_arg || ( !IS("play") && !IS("stop") && !IS("pause") && !IS("seek") ) )
372 return ExecuteSyntaxError( "control", pp_status );
373 }
374 #undef IS
375 psz_control = ppsz_arg[i_index];
376
377 if( i_index+1 < i_arg )
378 psz_argument = ppsz_arg[i_index+1];
379
380 p_media = vlm_MediaSearch( p_vlm, psz_name );
381 assert( p_media );
382
383 if( !strcmp( psz_control, "play" ) )
384 {
385 int i_input_index = 0;
386 int i;
387
388 if( ( psz_argument && sscanf(psz_argument, "%d", &i) == 1 ) && i > 0 && i-1 < p_media->cfg.i_input )
389 {
390 i_input_index = i-1;
391 }
392 else if( psz_argument )
393 {
394 int j;
395 vlm_media_t *p_cfg = &p_media->cfg;
396 for ( j=0; j < p_cfg->i_input; j++)
397 {
398 if( !strcmp( p_cfg->ppsz_input[j], psz_argument ) )
399 {
400 i_input_index = j;
401 break;
402 }
403 }
404 }
405
406 if( p_media->cfg.b_vod )
407 i_result = vlm_ControlInternal( p_vlm, VLM_START_MEDIA_VOD_INSTANCE, p_media->cfg.id, psz_instance, i_input_index, NULL ); // we should get here now
408 else
409 i_result = vlm_ControlInternal( p_vlm, VLM_START_MEDIA_BROADCAST_INSTANCE, p_media->cfg.id, psz_instance, i_input_index );
410 }
411 else if( !strcmp( psz_control, "seek" ) )
412 {
413 if( psz_argument )
414 {
415 bool b_relative;
416 if( psz_argument[0] == '+' || psz_argument[0] == '-' )
417 b_relative = true;
418 else
419 b_relative = false;
420
421 if( strstr( psz_argument, "ms" ) || strstr( psz_argument, "s" ) )
422 {
423 /* Time (ms or s) */
424 int64_t i_new_time;
425
426 if( strstr( psz_argument, "ms" ) )
427 i_new_time = 1000 * (int64_t)atoi( psz_argument );
428 else
429 i_new_time = 1000000 * (int64_t)atoi( psz_argument );
430
431 if( b_relative )
432 {
433 int64_t i_time = 0;
434 vlm_ControlInternal( p_vlm, VLM_GET_MEDIA_INSTANCE_TIME, p_media->cfg.id, psz_instance, &i_time );
435 i_new_time += i_time;
436 }
437 if( i_new_time < 0 )
438 i_new_time = 0;
439 i_result = vlm_ControlInternal( p_vlm, VLM_SET_MEDIA_INSTANCE_TIME, p_media->cfg.id, psz_instance, i_new_time );
440 }
441 else
442 {
443 /* Percent */
444 double d_new_position = us_atof( psz_argument ) / 100.0;
445
446 if( b_relative )
447 {
448 double d_position = 0.0;
449
450 vlm_ControlInternal( p_vlm, VLM_GET_MEDIA_INSTANCE_POSITION, p_media->cfg.id, psz_instance, &d_position );
451 d_new_position += d_position;
452 }
453 if( d_new_position < 0.0 )
454 d_new_position = 0.0;
455 else if( d_new_position > 1.0 )
456 d_new_position = 1.0;
457 i_result = vlm_ControlInternal( p_vlm, VLM_SET_MEDIA_INSTANCE_POSITION, p_media->cfg.id, psz_instance, d_new_position );
458 }
459 }
460 else
461 {
462 i_result = VLC_EGENERIC;
463 }
464 }
465 else if( !strcmp( psz_control, "stop" ) )
466 {
467 i_result = vlm_ControlInternal( p_vlm, VLM_STOP_MEDIA_INSTANCE, p_media->cfg.id, psz_instance );
468 }
469 else if( !strcmp( psz_control, "pause" ) )
470 {
471 i_result = vlm_ControlInternal( p_vlm, VLM_PAUSE_MEDIA_INSTANCE, p_media->cfg.id, psz_instance );
472 }
473 else
474 {
475 i_result = VLC_EGENERIC;
476 }
477
478 if( i_result )
479 {
480 *pp_status = vlm_MessageNew( "control", "unknown error" );
481 return VLC_SUCCESS;
482 }
483 *pp_status = vlm_MessageSimpleNew( "control" );
484 return VLC_SUCCESS;
485 }
486
487 static int ExecuteExport( vlm_t *p_vlm, vlm_message_t **pp_status )
488 {
489 char *psz_export = Save( p_vlm );
490
491 *pp_status = vlm_MessageNew( "export", "%s", psz_export );
492 free( psz_export );
493 return VLC_SUCCESS;
494 }
495
496 static int ExecuteSave( vlm_t *p_vlm, const char *psz_file, vlm_message_t **pp_status )
497 {
498 FILE *f = vlc_fopen( psz_file, "wt" );
499 char *psz_save = NULL;
500
501 if( !f )
502 goto error;
503
504 psz_save = Save( p_vlm );
505 if( psz_save == NULL )
506 goto error;
507 if( fputs( psz_save, f ) == EOF )
508 goto error;;
509 if( fclose( f ) )
510 {
511 f = NULL;
512 goto error;
513 }
514
515 free( psz_save );
516
517 *pp_status = vlm_MessageSimpleNew( "save" );
518 return VLC_SUCCESS;
519
520 error:
521 free( psz_save );
522 if( f )
523 fclose( f );
524 *pp_status = vlm_MessageNew( "save", "Unable to save to file");
525 return VLC_EGENERIC;
526 }
527
528 static int ExecuteLoad( vlm_t *p_vlm, const char *psz_path, vlm_message_t **pp_status )
529 {
530 int fd = vlc_open( psz_path, O_RDONLY|O_NONBLOCK );
531 if( fd == -1 )
532 {
533 *pp_status = vlm_MessageNew( "load", "Unable to load from file" );
534 return VLC_EGENERIC;
535 }
536
537 struct stat st;
538 char *psz_buffer = NULL;
539
540 if( fstat( fd, &st ) || !S_ISREG( st.st_mode )
541 || st.st_size >= SSIZE_MAX
542 || ((psz_buffer = malloc( st.st_size + 1 )) == NULL)
543 || read( fd, psz_buffer, st.st_size ) < (ssize_t)st.st_size )
544 {
545 free( psz_buffer );
546 vlc_close( fd );
547
548 *pp_status = vlm_MessageNew( "load", "Read file error" );
549 return VLC_EGENERIC;
550 }
551
552 vlc_close( fd );
553
554 psz_buffer[st.st_size] = '\0';
555
556 if( Load( p_vlm, psz_buffer ) )
557 {
558 free( psz_buffer );
559
560 *pp_status = vlm_MessageNew( "load", "Error while loading file" );
561 return VLC_EGENERIC;
562 }
563
564 free( psz_buffer );
565
566 *pp_status = vlm_MessageSimpleNew( "load" );
567 return VLC_SUCCESS;
568 }
569
570 static int ExecuteScheduleProperty( vlm_t *p_vlm, vlm_schedule_sys_t *p_schedule, bool b_new,
571 const int i_property, char *ppsz_property[], vlm_message_t **pp_status )
572 {
573 const char *psz_cmd = b_new ? "new" : "setup";
574 int i;
575
576 for( i = 0; i < i_property; i++ )
577 {
578 if( !strcmp( ppsz_property[i], "enabled" ) ||
579 !strcmp( ppsz_property[i], "disabled" ) )
580 {
581 if ( vlm_ScheduleSetup( p_schedule, ppsz_property[i], NULL ) )
582 goto error;
583 }
584 else if( !strcmp( ppsz_property[i], "append" ) )
585 {
586 char *psz_line, *psz_realloc;
587 int j, i_ret = VLC_SUCCESS;
588 /* Beware: everything behind append is considered as
589 * command line */
590
591 if( ++i >= i_property )
592 break;
593
594 psz_line = strdup( ppsz_property[i] );
595 if( unlikely(psz_line == NULL) )
596 goto error;
597
598 for( j = i+1; j < i_property; j++ )
599 {
600 psz_realloc = realloc( psz_line,
601 strlen(psz_line) + strlen(ppsz_property[j]) + 1 + 1 );
602 if( likely(psz_realloc) )
603 {
604 psz_line = psz_realloc;
605 strcat( psz_line, " " );
606 strcat( psz_line, ppsz_property[j] );
607 }
608 else
609 {
610 i_ret = VLC_ENOMEM;
611 break;
612 }
613 }
614
615 if( i_ret == VLC_SUCCESS )
616 i_ret = vlm_ScheduleSetup( p_schedule, "append", psz_line );
617 free( psz_line );
618
619 if( i_ret )
620 goto error;
621 break;
622 }
623 else
624 {
625 if( i + 1 >= i_property )
626 {
627 if( b_new )
628 vlm_ScheduleDelete( p_vlm, p_schedule );
629 return ExecuteSyntaxError( psz_cmd, pp_status );
630 }
631
632 if( vlm_ScheduleSetup( p_schedule, ppsz_property[i], ppsz_property[i+1] ) )
633 goto error;
634 i++;
635 }
636 }
637 *pp_status = vlm_MessageSimpleNew( psz_cmd );
638
639 vlc_mutex_lock( &p_vlm->lock_manage );
640 p_vlm->input_state_changed = true;
641 vlc_cond_signal( &p_vlm->wait_manage );
642 vlc_mutex_unlock( &p_vlm->lock_manage );
643
644 return VLC_SUCCESS;
645
646 error:
647 *pp_status = vlm_MessageNew( psz_cmd, "Error while setting the property '%s' to the schedule",
648 ppsz_property[i] );
649 return VLC_EGENERIC;
650 }
651
652 static int ExecuteMediaProperty( vlm_t *p_vlm, int64_t id, bool b_new,
653 const int i_property, char *ppsz_property[], vlm_message_t **pp_status )
654 {
655 const char *psz_cmd = b_new ? "new" : "setup";
656 vlm_media_t *p_cfg = NULL;
657 int i_result;
658 int i;
659
660 #undef ERROR
661 #undef MISSING
662 #define ERROR( txt ) do { *pp_status = vlm_MessageNew( psz_cmd, txt); goto error; } while(0)
663 if( vlm_ControlInternal( p_vlm, VLM_GET_MEDIA, id, &p_cfg ) )
664 ERROR( "unknown media" );
665
666 #define MISSING(cmd) do { if( !psz_value ) ERROR( "missing argument for " cmd ); } while(0)
667 for( i = 0; i < i_property; i++ )
668 {
669 const char *psz_option = ppsz_property[i];
670 const char *psz_value = i+1 < i_property ? ppsz_property[i+1] : NULL;
671
672 if( !strcmp( psz_option, "enabled" ) )
673 {
674 p_cfg->b_enabled = true;
675 }
676 else if( !strcmp( psz_option, "disabled" ) )
677 {
678 p_cfg->b_enabled = false;
679 }
680 else if( !strcmp( psz_option, "input" ) )
681 {
682 MISSING( "input" );
683 TAB_APPEND( p_cfg->i_input, p_cfg->ppsz_input, strdup(psz_value) );
684 i++;
685 }
686 else if( !strcmp( psz_option, "inputdel" ) && psz_value && !strcmp( psz_value, "all" ) )
687 {
688 while( p_cfg->i_input > 0 )
689 TAB_REMOVE( p_cfg->i_input, p_cfg->ppsz_input, p_cfg->ppsz_input[0] );
690 i++;
691 }
692 else if( !strcmp( psz_option, "inputdel" ) )
693 {
694 int j;
695
696 MISSING( "inputdel" );
697
698 for( j = 0; j < p_cfg->i_input; j++ )
699 {
700 if( !strcmp( p_cfg->ppsz_input[j], psz_value ) )
701 {
702 TAB_REMOVE( p_cfg->i_input, p_cfg->ppsz_input, p_cfg->ppsz_input[j] );
703 break;
704 }
705 }
706 i++;
707 }
708 else if( !strcmp( psz_option, "inputdeln" ) )
709 {
710 MISSING( "inputdeln" );
711
712 int idx = atoi( psz_value );
713 if( idx > 0 && idx <= p_cfg->i_input )
714 TAB_REMOVE( p_cfg->i_input, p_cfg->ppsz_input, p_cfg->ppsz_input[idx-1] );
715 i++;
716 }
717 else if( !strcmp( psz_option, "output" ) )
718 {
719 MISSING( "output" );
720
721 free( p_cfg->psz_output );
722 p_cfg->psz_output = *psz_value ? strdup( psz_value ) : NULL;
723 i++;
724 }
725 else if( !strcmp( psz_option, "option" ) )
726 {
727 MISSING( "option" );
728
729 TAB_APPEND( p_cfg->i_option, p_cfg->ppsz_option, strdup( psz_value ) );
730 i++;
731 }
732 else if( !strcmp( psz_option, "loop" ) )
733 {
734 if( p_cfg->b_vod )
735 ERROR( "invalid loop option for vod" );
736 p_cfg->broadcast.b_loop = true;
737 }
738 else if( !strcmp( psz_option, "unloop" ) )
739 {
740 if( p_cfg->b_vod )
741 ERROR( "invalid unloop option for vod" );
742 p_cfg->broadcast.b_loop = false;
743 }
744 else if( !strcmp( psz_option, "mux" ) )
745 {
746 MISSING( "mux" );
747 if( !p_cfg->b_vod )
748 ERROR( "invalid mux option for broadcast" );
749
750 free( p_cfg->vod.psz_mux );
751 p_cfg->vod.psz_mux = *psz_value ? strdup( psz_value ) : NULL;
752 i++;
753 }
754 else
755 {
756 fprintf( stderr, "PROP: name=%s unknown\n", psz_option );
757 ERROR( "Wrong command syntax" );
758 }
759 }
760 #undef MISSING
761 #undef ERROR
762
763 /* */
764 i_result = vlm_ControlInternal( p_vlm, VLM_CHANGE_MEDIA, p_cfg );
765 vlm_media_Delete( p_cfg );
766
767 *pp_status = vlm_MessageSimpleNew( psz_cmd );
768 return i_result;
769
770 error:
771 if( p_cfg )
772 {
773 if( b_new )
774 vlm_ControlInternal( p_vlm, VLM_DEL_MEDIA, p_cfg->id );
775 vlm_media_Delete( p_cfg );
776 }
777 return VLC_EGENERIC;
778 }
779
780 static int ExecuteNew( vlm_t *p_vlm, const char *psz_name, const char *psz_type, const int i_property, char *ppsz_property[], vlm_message_t **pp_status )
781 {
782 /* Check name */
783 if( !strcmp( psz_name, "all" ) || !strcmp( psz_name, "media" ) || !strcmp( psz_name, "schedule" ) )
784 {
785 *pp_status = vlm_MessageNew( "new", "\"all\", \"media\" and \"schedule\" are reserved names" );
786 return VLC_EGENERIC;
787 }
788 if( ExecuteIsMedia( p_vlm, psz_name ) || ExecuteIsSchedule( p_vlm, psz_name ) )
789 {
790 *pp_status = vlm_MessageNew( "new", "%s: Name already in use", psz_name );
791 return VLC_EGENERIC;
792 }
793 /* */
794 if( !strcmp( psz_type, "schedule" ) )
795 {
796 vlm_schedule_sys_t *p_schedule = vlm_ScheduleNew( p_vlm, psz_name );
797 if( !p_schedule )
798 {
799 *pp_status = vlm_MessageNew( "new", "could not create schedule" );
800 return VLC_EGENERIC;
801 }
802 return ExecuteScheduleProperty( p_vlm, p_schedule, true, i_property, ppsz_property, pp_status );
803 }
804 else if( !strcmp( psz_type, "vod" ) || !strcmp( psz_type, "broadcast" ) )
805 {
806 vlm_media_t cfg;
807 int64_t id;
808
809 vlm_media_Init( &cfg );
810 cfg.psz_name = strdup( psz_name );
811 cfg.b_vod = !strcmp( psz_type, "vod" );
812
813 if( vlm_ControlInternal( p_vlm, VLM_ADD_MEDIA, &cfg, &id ) )
814 {
815 vlm_media_Clean( &cfg );
816 *pp_status = vlm_MessageNew( "new", "could not create media" );
817 return VLC_EGENERIC;
818 }
819 vlm_media_Clean( &cfg );
820 return ExecuteMediaProperty( p_vlm, id, true, i_property, ppsz_property, pp_status );
821 }
822 else
823 {
824 *pp_status = vlm_MessageNew( "new", "%s: Choose between vod, broadcast or schedule", psz_type );
825 return VLC_EGENERIC;
826 }
827 }
828
829 static int ExecuteSetup( vlm_t *p_vlm, const char *psz_name, const int i_property, char *ppsz_property[], vlm_message_t **pp_status )
830 {
831 if( ExecuteIsSchedule( p_vlm, psz_name ) )
832 {
833 vlm_schedule_sys_t *p_schedule = vlm_ScheduleSearch( p_vlm, psz_name );
834 return ExecuteScheduleProperty( p_vlm, p_schedule, false, i_property, ppsz_property, pp_status );
835 }
836 else if( ExecuteIsMedia( p_vlm, psz_name ) )
837 {
838 int64_t id;
839 if( vlm_ControlInternal( p_vlm, VLM_GET_MEDIA_ID, psz_name, &id ) )
840 goto error;
841 return ExecuteMediaProperty( p_vlm, id, false, i_property, ppsz_property, pp_status );
842 }
843
844 error:
845 *pp_status = vlm_MessageNew( "setup", "%s unknown", psz_name );
846 return VLC_EGENERIC;
847 }
848
849 int ExecuteCommand( vlm_t *p_vlm, const char *psz_command,
850 vlm_message_t **pp_message )
851 {
852 size_t i_command = 0;
853 size_t i_command_len = strlen( psz_command );
854 char *buf = malloc( i_command_len + 1 ), *psz_buf = buf;
855 size_t i_ppsz_command_len = (3 + (i_command_len + 1) / 2);
856 char **ppsz_command = malloc( i_ppsz_command_len * sizeof(char *) );
857 vlm_message_t *p_message = NULL;
858 int i_ret = 0;
859
860 if( !psz_buf || !ppsz_command )
861 {
862 p_message = vlm_MessageNew( "Memory error",
863 "allocation failed for command of length %zu",
864 i_command_len );
865 goto error;
866 }
867
868 /* First, parse the line and cut it */
869 while( *psz_command != '\0' )
870 {
871 const char *psz_temp;
872
873 if(isspace ((unsigned char)*psz_command))
874 {
875 psz_command++;
876 continue;
877 }
878
879 /* support for comments */
880 if( i_command == 0 && *psz_command == '#')
881 {
882 p_message = vlm_MessageSimpleNew( "" );
883 goto success;
884 }
885
886 psz_temp = FindCommandEnd( psz_command );
887
888 if( psz_temp == NULL )
889 {
890 p_message = vlm_MessageNew( "Incomplete command", "%s", psz_command );
891 goto error;
892 }
893
894 assert (i_command < i_ppsz_command_len);
895
896 ppsz_command[i_command] = psz_buf;
897 memcpy (psz_buf, psz_command, psz_temp - psz_command);
898 psz_buf[psz_temp - psz_command] = '\0';
899
900 Unescape (psz_buf, psz_buf);
901
902 i_command++;
903 psz_buf += psz_temp - psz_command + 1;
904 psz_command = psz_temp;
905
906 assert (buf + i_command_len + 1 >= psz_buf);
907 }
908
909 /*
910 * And then Interpret it
911 */
912
913 #define IF_EXECUTE( name, check, cmd ) if( !strcmp(ppsz_command[0], name ) ) { if( (check) ) goto syntax_error; if( (cmd) ) goto error; goto success; }
914 if( i_command == 0 )
915 {
916 p_message = vlm_MessageSimpleNew( "" );
917 goto success;
918 }
919 else IF_EXECUTE( "del", (i_command != 2), ExecuteDel(p_vlm, ppsz_command[1], &p_message) )
920 else IF_EXECUTE( "show", (i_command > 2), ExecuteShow(p_vlm, i_command > 1 ? ppsz_command[1] : NULL, &p_message) )
921 else IF_EXECUTE( "help", (i_command != 1), ExecuteHelp( &p_message ) )
922 else IF_EXECUTE( "control", (i_command < 3), ExecuteControl(p_vlm, ppsz_command[1], i_command - 2, &ppsz_command[2], &p_message) )
923 else IF_EXECUTE( "save", (i_command != 2), ExecuteSave(p_vlm, ppsz_command[1], &p_message) )
924 else IF_EXECUTE( "export", (i_command != 1), ExecuteExport(p_vlm, &p_message) )
925 else IF_EXECUTE( "load", (i_command != 2), ExecuteLoad(p_vlm, ppsz_command[1], &p_message) )
926 else IF_EXECUTE( "new", (i_command < 3), ExecuteNew(p_vlm, ppsz_command[1], ppsz_command[2], i_command-3, &ppsz_command[3], &p_message) )
927 else IF_EXECUTE( "setup", (i_command < 2), ExecuteSetup(p_vlm, ppsz_command[1], i_command-2, &ppsz_command[2], &p_message) )
928 else
929 {
930 p_message = vlm_MessageNew( ppsz_command[0], "Unknown VLM command" );
931 goto error;
932 }
933 #undef IF_EXECUTE
934
935 success:
936 *pp_message = p_message;
937 free( buf );
938 free( ppsz_command );
939 return VLC_SUCCESS;
940
941 syntax_error:
942 i_ret = ExecuteSyntaxError( ppsz_command[0], pp_message );
943 free( buf );
944 free( ppsz_command );
945 return i_ret;
946
947 error:
948 *pp_message = p_message;
949 free( buf );
950 free( ppsz_command );
951 return VLC_EGENERIC;
952 }
953
954 /*****************************************************************************
955 * Media handling
956 *****************************************************************************/
957 vlm_media_sys_t *vlm_MediaSearch( vlm_t *vlm, const char *psz_name )
958 {
959 int i;
960
961 for( i = 0; i < vlm->i_media; i++ )
962 {
963 if( strcmp( psz_name, vlm->media[i]->cfg.psz_name ) == 0 )
964 return vlm->media[i];
965 }
966
967 return NULL;
968 }
969
970 /*****************************************************************************
971 * Schedule handling
972 *****************************************************************************/
973 static vlm_schedule_sys_t *vlm_ScheduleNew( vlm_t *vlm, const char *psz_name )
974 {
975 if( !psz_name )
976 return NULL;
977
978 vlm_schedule_sys_t *p_sched = malloc( sizeof( vlm_schedule_sys_t ) );
979 if( !p_sched )
980 return NULL;
981
982 p_sched->psz_name = strdup( psz_name );
983 p_sched->b_enabled = false;
984 p_sched->i_command = 0;
985 p_sched->command = NULL;
986 p_sched->date = 0;
987 p_sched->period = 0;
988 p_sched->i_repeat = -1;
989
990 TAB_APPEND( vlm->i_schedule, vlm->schedule, p_sched );
991
992 return p_sched;
993 }
994
995 /* for now, simple delete. After, del with options (last arg) */
996 void vlm_ScheduleDelete( vlm_t *vlm, vlm_schedule_sys_t *sched )
997 {
998 int i;
999 if( sched == NULL ) return;
1000
1001 TAB_REMOVE( vlm->i_schedule, vlm->schedule, sched );
1002
1003 if( vlm->i_schedule == 0 ) free( vlm->schedule );
1004 free( sched->psz_name );
1005
1006 for ( i = 0; i < sched->i_command; i++ )
1007 free( sched->command[i] );
1008 free( sched->command );
1009 free( sched );
1010 }
1011
1012 static vlm_schedule_sys_t *vlm_ScheduleSearch( vlm_t *vlm, const char *psz_name )
1013 {
1014 int i;
1015
1016 for( i = 0; i < vlm->i_schedule; i++ )
1017 {
1018 if( strcmp( psz_name, vlm->schedule[i]->psz_name ) == 0 )
1019 {
1020 return vlm->schedule[i];
1021 }
1022 }
1023
1024 return NULL;
1025 }
1026
1027 /* Ok, setup schedule command will be able to support only one (argument value) at a time */
1028 static int vlm_ScheduleSetup( vlm_schedule_sys_t *schedule, const char *psz_cmd,
1029 const char *psz_value )
1030 {
1031 if( !strcmp( psz_cmd, "enabled" ) )
1032 {
1033 schedule->b_enabled = true;
1034 }
1035 else if( !strcmp( psz_cmd, "disabled" ) )
1036 {
1037 schedule->b_enabled = false;
1038 }
1039 else if( !strcmp( psz_cmd, "date" ) )
1040 {
1041 struct tm time;
1042 const char *p;
1043
1044 time.tm_sec = 0; /* seconds */
1045 time.tm_min = 0; /* minutes */
1046 time.tm_hour = 0; /* hours */
1047 time.tm_mday = 0; /* day of the month */
1048 time.tm_mon = 0; /* month */
1049 time.tm_year = 0; /* year */
1050 time.tm_wday = 0; /* day of the week */
1051 time.tm_yday = 0; /* day in the year */
1052 time.tm_isdst = -1; /* daylight saving time */
1053
1054 /* date should be year/month/day-hour:minutes:seconds */
1055 p = strchr( psz_value, '-' );
1056
1057 if( !strcmp( psz_value, "now" ) )
1058 {
1059 schedule->date = 0;
1060 }
1061 else if(p == NULL)
1062 {
1063 return 1;
1064 }
1065 else
1066 {
1067 unsigned i,j,k;
1068
1069 switch( sscanf( p + 1, "%u:%u:%u", &i, &j, &k ) )
1070 {
1071 case 1:
1072 time.tm_sec = i;
1073 break;
1074 case 2:
1075 time.tm_min = i;
1076 time.tm_sec = j;
1077 break;
1078 case 3:
1079 time.tm_hour = i;
1080 time.tm_min = j;
1081 time.tm_sec = k;
1082 break;
1083 default:
1084 return 1;
1085 }
1086
1087 switch( sscanf( psz_value, "%d/%d/%d", &i, &j, &k ) )
1088 {
1089 case 1:
1090 time.tm_mday = i;
1091 break;
1092 case 2:
1093 time.tm_mon = i - 1;
1094 time.tm_mday = j;
1095 break;
1096 case 3:
1097 time.tm_year = i - 1900;
1098 time.tm_mon = j - 1;
1099 time.tm_mday = k;
1100 break;
1101 default:
1102 return 1;
1103 }
1104
1105 schedule->date = mktime(&time);
1106 }
1107 }
1108 else if( !strcmp( psz_cmd, "period" ) )
1109 {
1110 struct tm time;
1111 const char *p;
1112 const char *psz_time = NULL, *psz_date = NULL;
1113 unsigned i,j,k;
1114
1115 /* First, if date or period are modified, repeat should be equal to -1 */
1116 schedule->i_repeat = -1;
1117
1118 time.tm_sec = 0; /* seconds */
1119 time.tm_min = 0; /* minutes */
1120 time.tm_hour = 0; /* hours */
1121 time.tm_mday = 0; /* day of the month */
1122 time.tm_mon = 0; /* month */
1123 time.tm_year = 0; /* year */
1124 time.tm_wday = 0; /* day of the week */
1125 time.tm_yday = 0; /* day in the year */
1126 time.tm_isdst = -1; /* daylight saving time */
1127
1128 /* date should be year/month/day-hour:minutes:seconds */
1129 p = strchr( psz_value, '-' );
1130 if( p )
1131 {
1132 psz_date = psz_value;
1133 psz_time = p + 1;
1134 }
1135 else
1136 {
1137 psz_time = psz_value;
1138 }
1139
1140 switch( sscanf( psz_time, "%u:%u:%u", &i, &j, &k ) )
1141 {
1142 case 1:
1143 time.tm_sec = i;
1144 break;
1145 case 2:
1146 time.tm_min = i;
1147 time.tm_sec = j;
1148 break;
1149 case 3:
1150 time.tm_hour = i;
1151 time.tm_min = j;
1152 time.tm_sec = k;
1153 break;
1154 default:
1155 return 1;
1156 }
1157 if( psz_date )
1158 {
1159 switch( sscanf( psz_date, "%u/%u/%u", &i, &j, &k ) )
1160 {
1161 case 1:
1162 time.tm_mday = i;
1163 break;
1164 case 2:
1165 time.tm_mon = i;
1166 time.tm_mday = j;
1167 break;
1168 case 3:
1169 time.tm_year = i;
1170 time.tm_mon = j;
1171 time.tm_mday = k;
1172 break;
1173 default:
1174 return 1;
1175 }
1176 }
1177
1178 /* ok, that's stupid... who is going to schedule streams every 42 years ? */
1179 schedule->period = ((((time.tm_year * 12 + time.tm_mon) * 30
1180 + time.tm_mday) * 24 + time.tm_hour) * 60 + time.tm_min) * 60
1181 + time.tm_sec;
1182 }
1183 else if( !strcmp( psz_cmd, "repeat" ) )
1184 {
1185 int i;
1186
1187 if( sscanf( psz_value, "%d", &i ) == 1 )
1188 {
1189 schedule->i_repeat = i;
1190 }
1191 else
1192 {
1193 return 1;
1194 }
1195 }
1196 else if( !strcmp( psz_cmd, "append" ) )
1197 {
1198 char *command = strdup( psz_value );
1199
1200 TAB_APPEND( schedule->i_command, schedule->command, command );
1201 }
1202 else
1203 {
1204 return 1;
1205 }
1206
1207 return 0;
1208 }
1209
1210 /*****************************************************************************
1211 * Message handling functions
1212 *****************************************************************************/
1213 vlm_message_t *vlm_MessageSimpleNew( const char *psz_name )
1214 {
1215 if( !psz_name ) return NULL;
1216
1217 vlm_message_t *p_message = malloc( sizeof(*p_message) );
1218 if( !p_message )
1219 return NULL;
1220
1221 p_message->psz_name = strdup( psz_name );
1222 if( !p_message->psz_name )
1223 {
1224 free( p_message );
1225 return NULL;
1226 }
1227 p_message->psz_value = NULL;
1228 p_message->i_child = 0;
1229 p_message->child = NULL;
1230
1231 return p_message;
1232 }
1233
1234 vlm_message_t *vlm_MessageNew( const char *psz_name,
1235 const char *psz_format, ... )
1236 {
1237 vlm_message_t *p_message = vlm_MessageSimpleNew( psz_name );
1238 va_list args;
1239
1240 if( !p_message )
1241 return NULL;
1242
1243 assert( psz_format );
1244 va_start( args, psz_format );
1245 if( vasprintf( &p_message->psz_value, psz_format, args ) == -1 )
1246 p_message->psz_value = NULL;
1247 va_end( args );
1248
1249 if( !p_message->psz_value )
1250 {
1251 vlm_MessageDelete( p_message );
1252 return NULL;
1253 }
1254 return p_message;
1255 }
1256
1257 void vlm_MessageDelete( vlm_message_t *p_message )
1258 {
1259 free( p_message->psz_name );
1260 free( p_message->psz_value );
1261 while( p_message->i_child-- )
1262 vlm_MessageDelete( p_message->child[p_message->i_child] );
1263 free( p_message->child );
1264 free( p_message );
1265 }
1266
1267 /* Add a child */
1268 vlm_message_t *vlm_MessageAdd( vlm_message_t *p_message,
1269 vlm_message_t *p_child )
1270 {
1271 if( p_message == NULL ) return NULL;
1272
1273 if( p_child )
1274 {
1275 TAB_APPEND( p_message->i_child, p_message->child, p_child );
1276 }
1277
1278 return p_child;
1279 }
1280
1281 /*****************************************************************************
1282 * Misc utility functions
1283 *****************************************************************************/
1284 static vlm_message_t *vlm_ShowMedia( vlm_media_sys_t *p_media )
1285 {
1286 vlm_media_t *p_cfg = &p_media->cfg;
1287 vlm_message_t *p_msg;
1288 vlm_message_t *p_msg_sub;
1289 int i;
1290
1291 p_msg = vlm_MessageSimpleNew( p_cfg->psz_name );
1292 vlm_MessageAdd( p_msg,
1293 vlm_MessageNew( "type", p_cfg->b_vod ? "vod" : "broadcast" ) );
1294 vlm_MessageAdd( p_msg,
1295 vlm_MessageNew( "enabled", p_cfg->b_enabled ? "yes" : "no" ) );
1296
1297 if( p_cfg->b_vod )
1298 vlm_MessageAdd( p_msg,
1299 vlm_MessageNew( "mux", "%s", p_cfg->vod.psz_mux ) );
1300 else
1301 vlm_MessageAdd( p_msg,
1302 vlm_MessageNew( "loop", p_cfg->broadcast.b_loop ? "yes" : "no" ) );
1303
1304 p_msg_sub = vlm_MessageAdd( p_msg, vlm_MessageSimpleNew( "inputs" ) );
1305 for( i = 0; i < p_cfg->i_input; i++ )
1306 {
1307 char *psz_tmp;
1308 if( asprintf( &psz_tmp, "%d", i+1 ) != -1 )
1309 {
1310 vlm_MessageAdd( p_msg_sub,
1311 vlm_MessageNew( psz_tmp, "%s", p_cfg->ppsz_input[i] ) );
1312 free( psz_tmp );
1313 }
1314 }
1315
1316 vlm_MessageAdd( p_msg,
1317 vlm_MessageNew( "output", "%s", p_cfg->psz_output ? p_cfg->psz_output : "" ) );
1318
1319 p_msg_sub = vlm_MessageAdd( p_msg, vlm_MessageSimpleNew( "options" ) );
1320 for( i = 0; i < p_cfg->i_option; i++ )
1321 vlm_MessageAdd( p_msg_sub, vlm_MessageSimpleNew( p_cfg->ppsz_option[i] ) );
1322
1323 p_msg_sub = vlm_MessageAdd( p_msg, vlm_MessageSimpleNew( "instances" ) );
1324 for( i = 0; i < p_media->i_instance; i++ )
1325 {
1326 vlm_media_instance_sys_t *p_instance = p_media->instance[i];
1327 vlc_value_t val;
1328 vlm_message_t *p_msg_instance;
1329
1330 val.i_int = END_S;
1331 if( p_instance->p_input )
1332 var_Get( p_instance->p_input, "state", &val );
1333
1334 p_msg_instance = vlm_MessageAdd( p_msg_sub, vlm_MessageSimpleNew( "instance" ) );
1335
1336 vlm_MessageAdd( p_msg_instance,
1337 vlm_MessageNew( "name" , "%s", p_instance->psz_name ? p_instance->psz_name : "default" ) );
1338 vlm_MessageAdd( p_msg_instance,
1339 vlm_MessageNew( "state",
1340 val.i_int == PLAYING_S ? "playing" :
1341 val.i_int == PAUSE_S ? "paused" :
1342 "stopped" ) );
1343
1344 /* FIXME should not do that this way */
1345 if( p_instance->p_input )
1346 {
1347 #define APPEND_INPUT_INFO( key, format, type ) \
1348 vlm_MessageAdd( p_msg_instance, vlm_MessageNew( key, format, \
1349 var_Get ## type( p_instance->p_input, key ) ) )
1350 APPEND_INPUT_INFO( "position", "%f", Float );
1351 APPEND_INPUT_INFO( "time", "%"PRId64, Integer );
1352 APPEND_INPUT_INFO( "length", "%"PRId64, Integer );
1353 APPEND_INPUT_INFO( "rate", "%f", Float );
1354 APPEND_INPUT_INFO( "title", "%"PRId64, Integer );
1355 APPEND_INPUT_INFO( "chapter", "%"PRId64, Integer );
1356 APPEND_INPUT_INFO( "can-seek", "%d", Bool );
1357 }
1358 #undef APPEND_INPUT_INFO
1359 vlm_MessageAdd( p_msg_instance, vlm_MessageNew( "playlistindex",
1360 "%d", p_instance->i_index + 1 ) );
1361 }
1362 return p_msg;
1363 }
1364
1365 static vlm_message_t *vlm_Show( vlm_t *vlm, vlm_media_sys_t *media,
1366 vlm_schedule_sys_t *schedule,
1367 const char *psz_filter )
1368 {
1369 if( media != NULL )
1370 {
1371 vlm_message_t *p_msg = vlm_MessageSimpleNew( "show" );
1372 if( p_msg )
1373 vlm_MessageAdd( p_msg, vlm_ShowMedia( media ) );
1374 return p_msg;
1375 }
1376
1377 else if( schedule != NULL )
1378 {
1379 int i;
1380 vlm_message_t *msg;
1381 vlm_message_t *msg_schedule;
1382 vlm_message_t *msg_child;
1383 char buffer[100];
1384
1385 msg = vlm_MessageSimpleNew( "show" );
1386 msg_schedule =
1387 vlm_MessageAdd( msg, vlm_MessageSimpleNew( schedule->psz_name ) );
1388
1389 vlm_MessageAdd( msg_schedule, vlm_MessageNew("type", "schedule") );
1390
1391 vlm_MessageAdd( msg_schedule,
1392 vlm_MessageNew( "enabled", schedule->b_enabled ?
1393 "yes" : "no" ) );
1394
1395 if( schedule->date != 0 )
1396 {
1397 struct tm date;
1398
1399 localtime_r( &schedule->date, &date);
1400 vlm_MessageAdd( msg_schedule,
1401 vlm_MessageNew( "date", "%d/%d/%d-%d:%d:%d",
1402 date.tm_year + 1900, date.tm_mon + 1,
1403 date.tm_mday, date.tm_hour, date.tm_min,
1404 date.tm_sec ) );
1405 }
1406 else
1407 vlm_MessageAdd( msg_schedule, vlm_MessageNew("date", "now") );
1408
1409 if( schedule->period != 0 )
1410 {
1411 div_t d;
1412 struct tm date;
1413
1414 d = div(schedule->period, 60);
1415 date.tm_sec = d.rem;
1416 d = div(d.quot, 60);
1417 date.tm_min = d.rem;
1418 d = div(d.quot, 24);
1419 date.tm_hour = d.rem;
1420 /* okay, okay, months are not always 30 days long */
1421 d = div(d.quot, 30);
1422 date.tm_mday = d.rem;
1423 d = div(d.quot, 12);
1424 date.tm_mon = d.rem;
1425 date.tm_year = d.quot;
1426
1427 sprintf( buffer, "%d/%d/%d-%d:%d:%d", date.tm_year, date.tm_mon,
1428 date.tm_mday, date.tm_hour, date.tm_min, date.tm_sec);
1429
1430 vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", "%s", buffer) );
1431 }
1432 else
1433 vlm_MessageAdd( msg_schedule, vlm_MessageNew("period", "0") );
1434
1435 sprintf( buffer, "%d", schedule->i_repeat );
1436 vlm_MessageAdd( msg_schedule, vlm_MessageNew( "repeat", "%s", buffer ) );
1437
1438 msg_child =
1439 vlm_MessageAdd( msg_schedule, vlm_MessageSimpleNew("commands" ) );
1440
1441 for( i = 0; i < schedule->i_command; i++ )
1442 {
1443 vlm_MessageAdd( msg_child,
1444 vlm_MessageSimpleNew( schedule->command[i] ) );
1445 }
1446
1447 return msg;
1448
1449 }
1450
1451 else if( psz_filter && !strcmp( psz_filter, "media" ) )
1452 {
1453 vlm_message_t *p_msg;
1454 vlm_message_t *p_msg_child;
1455 int i_vod = 0, i_broadcast = 0;
1456
1457 for( int i = 0; i < vlm->i_media; i++ )
1458 {
1459 if( vlm->media[i]->cfg.b_vod )
1460 i_vod++;
1461 else
1462 i_broadcast++;
1463 }
1464
1465 p_msg = vlm_MessageSimpleNew( "show" );
1466 p_msg_child = vlm_MessageAdd( p_msg, vlm_MessageNew( "media",
1467 "( %d broadcast - %d vod )", i_broadcast,
1468 i_vod ) );
1469
1470 for( int i = 0; i < vlm->i_media; i++ )
1471 vlm_MessageAdd( p_msg_child, vlm_ShowMedia( vlm->media[i] ) );
1472
1473 return p_msg;
1474 }
1475
1476 else if( psz_filter && !strcmp( psz_filter, "schedule" ) )
1477 {
1478 int i;
1479 vlm_message_t *msg;
1480 vlm_message_t *msg_child;
1481
1482 msg = vlm_MessageSimpleNew( "show" );
1483 msg_child = vlm_MessageAdd( msg, vlm_MessageSimpleNew( "schedule" ) );
1484
1485 for( i = 0; i < vlm->i_schedule; i++ )
1486 {
1487 vlm_schedule_sys_t *s = vlm->schedule[i];
1488 vlm_message_t *msg_schedule;
1489 time_t now, next_date;
1490
1491 msg_schedule = vlm_MessageAdd( msg_child,
1492 vlm_MessageSimpleNew( s->psz_name ) );
1493 vlm_MessageAdd( msg_schedule,
1494 vlm_MessageNew( "enabled", s->b_enabled ?
1495 "yes" : "no" ) );
1496
1497 /* calculate next date */
1498 time(&now);
1499 next_date = s->date;
1500
1501 if( s->period != 0 )
1502 {
1503 int j = 0;
1504 while( ((s->date + j * s->period) <= now) &&
1505 ( s->i_repeat > j || s->i_repeat < 0 ) )
1506 {
1507 j++;
1508 }
1509
1510 next_date = s->date + j * s->period;
1511 }
1512
1513 if( next_date > now )
1514 {
1515 struct tm tm;
1516 char psz_date[32];
1517
1518 strftime( psz_date, sizeof(psz_date), "%Y-%m-%d %H:%M:%S (%a)",
1519 localtime_r( &next_date, &tm ) );
1520 vlm_MessageAdd( msg_schedule,
1521 vlm_MessageNew( "next launch", "%s", psz_date ) );
1522 }
1523 }
1524
1525 return msg;
1526 }
1527
1528 else if( ( psz_filter == NULL ) && ( media == NULL ) && ( schedule == NULL ) )
1529 {
1530 vlm_message_t *show1 = vlm_Show( vlm, NULL, NULL, "media" );
1531 vlm_message_t *show2 = vlm_Show( vlm, NULL, NULL, "schedule" );
1532
1533 vlm_MessageAdd( show1, show2->child[0] );
1534
1535 /* We must destroy the parent node "show" of show2
1536 * and not the children */
1537 free( show2->psz_name );
1538 free( show2 );
1539
1540 return show1;
1541 }
1542
1543 else
1544 {
1545 return vlm_MessageSimpleNew( "show" );
1546 }
1547 }
1548
1549 /*****************************************************************************
1550 * Config handling functions
1551 *****************************************************************************/
1552 static int Load( vlm_t *vlm, char *file )
1553 {
1554 char *pf = file;
1555 int i_line = 1;
1556
1557 while( *pf != '\0' )
1558 {
1559 vlm_message_t *message = NULL;
1560 int i_end = 0;
1561
1562 while( pf[i_end] != '\n' && pf[i_end] != '\0' && pf[i_end] != '\r' )
1563 {
1564 i_end++;
1565 }
1566
1567 if( pf[i_end] == '\r' || pf[i_end] == '\n' )
1568 {
1569 pf[i_end] = '\0';
1570 i_end++;
1571 if( pf[i_end] == '\n' ) i_end++;
1572 }
1573
1574 if( *pf && ExecuteCommand( vlm, pf, &message ) )
1575 {
1576 if( message )
1577 {
1578 if( message->psz_value )
1579 msg_Err( vlm, "Load error on line %d: %s: %s",
1580 i_line, message->psz_name, message->psz_value );
1581 vlm_MessageDelete( message );
1582 }
1583 return 1;
1584 }
1585 if( message ) vlm_MessageDelete( message );
1586
1587 pf += i_end;
1588 i_line++;
1589 }
1590
1591 return 0;
1592 }
1593
1594 static char *Save( vlm_t *vlm )
1595 {
1596 char *save = NULL;
1597 char psz_header[] = "\n"
1598 "# VLC media player VLM command batch\n"
1599 "# http://www.videolan.org/vlc/\n\n" ;
1600 char *p;
1601 int i,j;
1602 int i_length = strlen( psz_header );
1603
1604 for( i = 0; i < vlm->i_media; i++ )
1605 {
1606 vlm_media_sys_t *media = vlm->media[i];
1607 vlm_media_t *p_cfg = &media->cfg;
1608
1609 if( p_cfg->b_vod )
1610 i_length += strlen( "new * vod " ) + strlen(p_cfg->psz_name);
1611 else
1612 i_length += strlen( "new * broadcast " ) + strlen(p_cfg->psz_name);
1613
1614 if( p_cfg->b_enabled )
1615 i_length += strlen( "enabled" );
1616 else
1617 i_length += strlen( "disabled" );
1618
1619 if( !p_cfg->b_vod && p_cfg->broadcast.b_loop )
1620 i_length += strlen( " loop\n" );
1621 else
1622 i_length += strlen( "\n" );
1623
1624 for( j = 0; j < p_cfg->i_input; j++ )
1625 i_length += strlen( "setup * input \"\"\n" ) + strlen( p_cfg->psz_name ) + strlen( p_cfg->ppsz_input[j] );
1626
1627 if( p_cfg->psz_output != NULL )
1628 i_length += strlen( "setup * output \n" ) + strlen(p_cfg->psz_name) + strlen(p_cfg->psz_output);
1629
1630 for( j = 0; j < p_cfg->i_option; j++ )
1631 i_length += strlen("setup * option \n") + strlen(p_cfg->psz_name) + strlen(p_cfg->ppsz_option[j]);
1632
1633 if( p_cfg->b_vod && p_cfg->vod.psz_mux )
1634 i_length += strlen("setup * mux \n") + strlen(p_cfg->psz_name) + strlen(p_cfg->vod.psz_mux);
1635 }
1636
1637 for( i = 0; i < vlm->i_schedule; i++ )
1638 {
1639 vlm_schedule_sys_t *schedule = vlm->schedule[i];
1640
1641 i_length += strlen( "new schedule " ) + strlen( schedule->psz_name );
1642
1643 if( schedule->b_enabled )
1644 {
1645 i_length += strlen( "date //-:: enabled\n" ) + 14;
1646 }
1647 else
1648 {
1649 i_length += strlen( "date //-:: disabled\n" ) + 14;
1650 }
1651
1652
1653 if( schedule->period != 0 )
1654 {
1655 i_length += strlen( "setup " ) + strlen( schedule->psz_name ) +
1656 strlen( "period //-::\n" ) + 14;
1657 }
1658
1659 if( schedule->i_repeat >= 0 )
1660 {
1661 char buffer[12];
1662
1663 sprintf( buffer, "%d", schedule->i_repeat );
1664 i_length += strlen( "setup repeat \n" ) +
1665 strlen( schedule->psz_name ) + strlen( buffer );
1666 }
1667 else
1668 {
1669 i_length++;
1670 }
1671
1672 for( j = 0; j < schedule->i_command; j++ )
1673 {
1674 i_length += strlen( "setup append \n" ) +
1675 strlen( schedule->psz_name ) + strlen( schedule->command[j] );
1676 }
1677
1678 }
1679
1680 /* Don't forget the '\0' */
1681 i_length++;
1682 /* now we have the length of save */
1683
1684 p = save = malloc( i_length );
1685 if( !save ) return NULL;
1686 *save = '\0';
1687
1688 p += sprintf( p, "%s", psz_header );
1689
1690 /* finally we can write in it */
1691 for( i = 0; i < vlm->i_media; i++ )
1692 {
1693 vlm_media_sys_t *media = vlm->media[i];
1694 vlm_media_t *p_cfg = &media->cfg;
1695
1696 if( p_cfg->b_vod )
1697 p += sprintf( p, "new %s vod ", p_cfg->psz_name );
1698 else
1699 p += sprintf( p, "new %s broadcast ", p_cfg->psz_name );
1700
1701 if( p_cfg->b_enabled )
1702 p += sprintf( p, "enabled" );
1703 else
1704 p += sprintf( p, "disabled" );
1705
1706 if( !p_cfg->b_vod && p_cfg->broadcast.b_loop )
1707 p += sprintf( p, " loop\n" );
1708 else
1709 p += sprintf( p, "\n" );
1710
1711 for( j = 0; j < p_cfg->i_input; j++ )
1712 p += sprintf( p, "setup %s input \"%s\"\n", p_cfg->psz_name, p_cfg->ppsz_input[j] );
1713
1714 if( p_cfg->psz_output )
1715 p += sprintf( p, "setup %s output %s\n", p_cfg->psz_name, p_cfg->psz_output );
1716
1717 for( j = 0; j < p_cfg->i_option; j++ )
1718 p += sprintf( p, "setup %s option %s\n", p_cfg->psz_name, p_cfg->ppsz_option[j] );
1719
1720 if( p_cfg->b_vod && p_cfg->vod.psz_mux )
1721 p += sprintf( p, "setup %s mux %s\n", p_cfg->psz_name, p_cfg->vod.psz_mux );
1722 }
1723
1724 /* and now, the schedule scripts */
1725 for( i = 0; i < vlm->i_schedule; i++ )
1726 {
1727 vlm_schedule_sys_t *schedule = vlm->schedule[i];
1728 struct tm date;
1729
1730 localtime_r( &schedule->date, &date);
1731 p += sprintf( p, "new %s schedule ", schedule->psz_name);
1732
1733 if( schedule->b_enabled )
1734 {
1735 p += sprintf( p, "date %d/%d/%d-%d:%d:%d enabled\n",
1736 date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
1737 date.tm_hour, date.tm_min, date.tm_sec );
1738 }
1739 else
1740 {
1741 p += sprintf( p, "date %d/%d/%d-%d:%d:%d disabled\n",
1742 date.tm_year + 1900, date.tm_mon + 1, date.tm_mday,
1743 date.tm_hour, date.tm_min, date.tm_sec);
1744 }
1745
1746 if( schedule->period != 0 )
1747 {
1748 div_t d;
1749
1750 p += sprintf( p, "setup %s ", schedule->psz_name );
1751
1752 d = div(schedule->period, 60);
1753 date.tm_sec = d.rem;
1754 d = div(d.quot, 60);
1755 date.tm_min = d.rem;
1756 d = div(d.quot, 24);
1757 date.tm_hour = d.rem;
1758 d = div(d.quot, 30);
1759 date.tm_mday = d.rem;
1760 /* okay, okay, months are not always 30 days long */
1761 d = div(d.quot, 12);
1762 date.tm_mon = d.rem;
1763 date.tm_year = d.quot;
1764
1765 p += sprintf( p, "period %d/%d/%d-%d:%d:%d\n",
1766 date.tm_year, date.tm_mon, date.tm_mday,
1767 date.tm_hour, date.tm_min, date.tm_sec);
1768 }
1769
1770 if( schedule->i_repeat >= 0 )
1771 {
1772 p += sprintf( p, "setup %s repeat %d\n",
1773 schedule->psz_name, schedule->i_repeat );
1774 }
1775 else
1776 {
1777 p += sprintf( p, "\n" );
1778 }
1779
1780 for( j = 0; j < schedule->i_command; j++ )
1781 {
1782 p += sprintf( p, "setup %s append %s\n",
1783 schedule->psz_name, schedule->command[j] );
1784 }
1785
1786 }
1787
1788 return save;
1789 }
1790
1791 #endif /* ENABLE_VLM */
VLC Development tree mirror