1 /*****************************************************************************
2 * vlm.c: VLM interface plugin
3 *****************************************************************************
4 * Copyright (C) 2000-2005 the VideoLAN team
7 * Authors: Simon Latapie <garf@videolan.org>
8 * Laurent Aimar <fenrir@videolan.org>
9 * Gildas Bazin <gbazin@videolan.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
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 General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24 *****************************************************************************/
26 /*****************************************************************************
28 *****************************************************************************/
33 #include <vlc_common.h>
36 #include <ctype.h> /* tolower() */
42 # include <sys/time.h> /* gettimeofday() */
46 #include <sys/time.h> /* gettimeofday() */
50 # include <time.h> /* ctime() */
51 # include <sys/timeb.h> /* ftime() */
54 #include <vlc_input.h>
55 #include "input_internal.h"
56 #include <vlc_stream.h>
57 #include "vlm_internal.h"
59 #include <vlc_charset.h>
61 #include "../stream_output/stream_output.h"
62 #include "../libvlc.h"
64 /*****************************************************************************
66 *****************************************************************************/
68 static void vlm_Destructor( vlm_t *p_vlm );
69 static void* Manage( void * );
70 static int vlm_MediaVodControl( void *, vod_media_t *, const char *, int, va_list );
72 /*****************************************************************************
74 *****************************************************************************/
75 vlm_t *__vlm_New ( vlc_object_t *p_this )
78 vlm_t *p_vlm = NULL, **pp_vlm = &(libvlc_priv (p_this->p_libvlc)->p_vlm);
80 static const char vlm_object_name[] = "vlm daemon";
82 /* Avoid multiple creation */
83 if( var_Create( p_this->p_libvlc, "vlm_mutex", VLC_VAR_MUTEX ) ||
84 var_Get( p_this->p_libvlc, "vlm_mutex", &lockval ) )
87 vlc_mutex_lock( lockval.p_address );
91 { /* VLM already exists */
92 vlc_object_hold( p_vlm );
93 vlc_mutex_unlock( lockval.p_address );
97 msg_Dbg( p_this, "creating VLM" );
99 p_vlm = vlc_custom_create( p_this, sizeof( *p_vlm ), VLC_OBJECT_GENERIC,
103 vlc_mutex_unlock( lockval.p_address );
107 vlc_mutex_init( &p_vlm->lock );
109 TAB_INIT( p_vlm->i_media, p_vlm->media );
110 TAB_INIT( p_vlm->i_schedule, p_vlm->schedule );
113 vlc_object_attach( p_vlm, p_this->p_libvlc );
115 if( vlc_clone( &p_vlm->thread, Manage, p_vlm, VLC_THREAD_PRIORITY_LOW ) )
117 vlc_mutex_destroy( &p_vlm->lock );
118 vlc_object_release( p_vlm );
122 /* Load our configuration file */
123 psz_vlmconf = var_CreateGetString( p_vlm, "vlm-conf" );
124 if( psz_vlmconf && *psz_vlmconf )
126 vlm_message_t *p_message = NULL;
127 char *psz_buffer = NULL;
129 msg_Dbg( p_this, "loading VLM configuration" );
130 if( asprintf(&psz_buffer, "load %s", psz_vlmconf ) != -1 )
132 msg_Dbg( p_this, "%s", psz_buffer );
133 if( vlm_ExecuteCommand( p_vlm, psz_buffer, &p_message ) )
134 msg_Warn( p_this, "error while loading the configuration file" );
136 vlm_MessageDelete( p_message );
142 vlc_object_set_destructor( p_vlm, (vlc_destructor_t)vlm_Destructor );
143 *pp_vlm = p_vlm; /* for future reference */
144 vlc_mutex_unlock( lockval.p_address );
149 /*****************************************************************************
151 *****************************************************************************/
152 void vlm_Delete( vlm_t *p_vlm )
156 /* vlm_Delete() is serialized against itself, and against vlm_New().
157 * This way, vlm_Destructor () (called from vlc_objet_release() above)
158 * is serialized against setting libvlc_priv->p_vlm from vlm_New(). */
159 var_Get( p_vlm->p_libvlc, "vlm_mutex", &lockval );
160 vlc_mutex_lock( lockval.p_address );
161 vlc_object_release( p_vlm );
162 vlc_mutex_unlock( lockval.p_address );
165 /*****************************************************************************
167 *****************************************************************************/
168 static void vlm_Destructor( vlm_t *p_vlm )
170 libvlc_priv (p_vlm->p_libvlc)->p_vlm = NULL;
172 vlm_ControlInternal( p_vlm, VLM_CLEAR_MEDIAS );
173 TAB_CLEAN( p_vlm->i_media, p_vlm->media );
175 vlm_ControlInternal( p_vlm, VLM_CLEAR_SCHEDULES );
176 TAB_CLEAN( p_vlm->schedule, p_vlm->schedule );
178 vlc_object_kill( p_vlm );
179 /*vlc_cancel( p_vlm->thread ); */
180 vlc_join( p_vlm->thread, NULL );
181 vlc_mutex_destroy( &p_vlm->lock );
184 /*****************************************************************************
185 * vlm_ExecuteCommand:
186 *****************************************************************************/
187 int vlm_ExecuteCommand( vlm_t *p_vlm, const char *psz_command,
188 vlm_message_t **pp_message)
192 vlc_mutex_lock( &p_vlm->lock );
193 i_result = ExecuteCommand( p_vlm, psz_command, pp_message );
194 vlc_mutex_unlock( &p_vlm->lock );
200 int64_t vlm_Date(void)
202 #if defined (WIN32) && !defined (UNDER_CE)
205 return ((int64_t)tm.time) * 1000000 + ((int64_t)tm.millitm) * 1000;
207 struct timeval tv_date;
209 /* gettimeofday() cannot fail given &tv_date is a valid address */
210 (void)gettimeofday( &tv_date, NULL );
211 return (mtime_t) tv_date.tv_sec * 1000000 + (mtime_t) tv_date.tv_usec;
216 /*****************************************************************************
218 *****************************************************************************/
219 static int vlm_MediaVodControl( void *p_private, vod_media_t *p_vod_media,
220 const char *psz_id, int i_query, va_list args )
222 vlm_t *vlm = (vlm_t *)p_private;
227 if( !p_private || !p_vod_media )
230 vlc_mutex_lock( &vlm->lock );
233 for( i = 0, id = -1; i < vlm->i_media; i++ )
235 if( p_vod_media == vlm->media[i]->vod.p_media )
237 id = vlm->media[i]->cfg.id;
243 vlc_mutex_unlock( &vlm->lock );
250 psz = (const char *)va_arg( args, const char * );
251 i_ret = vlm_ControlInternal( vlm, VLM_START_MEDIA_VOD_INSTANCE, id, psz_id, 0, psz );
254 case VOD_MEDIA_PAUSE:
255 i_ret = vlm_ControlInternal( vlm, VLM_PAUSE_MEDIA_INSTANCE, id, psz_id );
259 i_ret = vlm_ControlInternal( vlm, VLM_STOP_MEDIA_INSTANCE, id, psz_id );
264 double d_position = (double)va_arg( args, double );
265 i_ret = vlm_ControlInternal( vlm, VLM_SET_MEDIA_INSTANCE_POSITION, id, psz_id, d_position/100.0 );
269 case VOD_MEDIA_REWIND:
271 double d_scale = (double)va_arg( args, double );
274 vlm_ControlInternal( vlm, VLM_GET_MEDIA_INSTANCE_POSITION, id, psz_id, &d_position );
275 d_position -= (d_scale / 1000.0);
276 if( d_position < 0.0 )
278 i_ret = vlm_ControlInternal( vlm, VLM_SET_MEDIA_INSTANCE_POSITION, id, psz_id, d_position );
282 case VOD_MEDIA_FORWARD:
284 double d_scale = (double)va_arg( args, double );
287 vlm_ControlInternal( vlm, VLM_GET_MEDIA_INSTANCE_POSITION, id, psz_id, &d_position );
288 d_position += (d_scale / 1000.0);
289 if( d_position > 1.0 )
291 i_ret = vlm_ControlInternal( vlm, VLM_SET_MEDIA_INSTANCE_POSITION, id, psz_id, d_position );
296 i_ret = VLC_EGENERIC;
300 vlc_mutex_unlock( &vlm->lock );
306 /*****************************************************************************
308 *****************************************************************************/
309 static void* Manage( void* p_object )
311 vlm_t *vlm = (vlm_t*)p_object;
316 int canc = vlc_savecancel ();
317 i_lastcheck = vlm_Date();
321 char **ppsz_scheduled_commands = NULL;
322 int i_scheduled_commands = 0;
324 vlc_mutex_lock( &vlm->lock );
326 /* destroy the inputs that wants to die, and launch the next input */
327 for( i = 0; i < vlm->i_media; i++ )
329 vlm_media_sys_t *p_media = vlm->media[i];
331 for( j = 0; j < p_media->i_instance; )
333 vlm_media_instance_sys_t *p_instance = p_media->instance[j];
335 if( p_instance->p_input && ( p_instance->p_input->b_eof || p_instance->p_input->b_error ) )
337 int i_new_input_index;
340 i_new_input_index = p_instance->i_index + 1;
341 if( !p_media->cfg.b_vod && p_media->cfg.broadcast.b_loop && i_new_input_index >= p_media->cfg.i_input )
342 i_new_input_index = 0;
344 /* FIXME implement multiple input with VOD */
345 if( p_media->cfg.b_vod || i_new_input_index >= p_media->cfg.i_input )
346 vlm_ControlInternal( vlm, VLM_STOP_MEDIA_INSTANCE, p_media->cfg.id, p_instance->psz_name );
348 vlm_ControlInternal( vlm, VLM_START_MEDIA_BROADCAST_INSTANCE, p_media->cfg.id, p_instance->psz_name, i_new_input_index );
362 for( i = 0; i < vlm->i_schedule; i++ )
364 mtime_t i_real_date = vlm->schedule[i]->i_date;
366 if( vlm->schedule[i]->b_enabled == true )
368 if( vlm->schedule[i]->i_date == 0 ) // now !
370 vlm->schedule[i]->i_date = (i_time / 1000000) * 1000000 ;
371 i_real_date = i_time;
373 else if( vlm->schedule[i]->i_period != 0 )
376 while( vlm->schedule[i]->i_date + j *
377 vlm->schedule[i]->i_period <= i_lastcheck &&
378 ( vlm->schedule[i]->i_repeat > j ||
379 vlm->schedule[i]->i_repeat == -1 ) )
384 i_real_date = vlm->schedule[i]->i_date + j *
385 vlm->schedule[i]->i_period;
388 if( i_real_date <= i_time && i_real_date > i_lastcheck )
390 for( j = 0; j < vlm->schedule[i]->i_command; j++ )
392 TAB_APPEND( i_scheduled_commands,
393 ppsz_scheduled_commands,
394 strdup(vlm->schedule[i]->command[j] ) );
399 while( i_scheduled_commands )
401 vlm_message_t *message = NULL;
402 char *psz_command = ppsz_scheduled_commands[0];
403 ExecuteCommand( vlm, psz_command,&message );
405 /* for now, drop the message */
406 vlm_MessageDelete( message );
407 TAB_REMOVE( i_scheduled_commands,
408 ppsz_scheduled_commands,
413 i_lastcheck = i_time;
415 vlc_mutex_unlock( &vlm->lock );
420 vlc_restorecancel (canc);
431 int i_connection_count;
432 int i_connection_active;
441 } vlm_media_status_t;
445 static vlm_media_sys_t *vlm_ControlMediaGetById( vlm_t *p_vlm, int64_t id )
449 for( i = 0; i < p_vlm->i_media; i++ )
451 if( p_vlm->media[i]->cfg.id == id )
452 return p_vlm->media[i];
456 static vlm_media_sys_t *vlm_ControlMediaGetByName( vlm_t *p_vlm, const char *psz_name )
460 for( i = 0; i < p_vlm->i_media; i++ )
462 if( !strcmp( p_vlm->media[i]->cfg.psz_name, psz_name ) )
463 return p_vlm->media[i];
467 static int vlm_MediaDescriptionCheck( vlm_t *p_vlm, vlm_media_t *p_cfg )
471 if( !p_cfg || !p_cfg->psz_name ||
472 !strcmp( p_cfg->psz_name, "all" ) || !strcmp( p_cfg->psz_name, "media" ) || !strcmp( p_cfg->psz_name, "schedule" ) )
475 for( i = 0; i < p_vlm->i_media; i++ )
477 if( p_vlm->media[i]->cfg.id == p_cfg->id )
479 if( !strcmp( p_vlm->media[i]->cfg.psz_name, p_cfg->psz_name ) )
486 /* Called after a media description is changed/added */
487 static int vlm_OnMediaUpdate( vlm_t *p_vlm, vlm_media_sys_t *p_media )
489 vlm_media_t *p_cfg = &p_media->cfg;
490 /* Check if we need to create/delete a vod media */
493 if( !p_cfg->b_enabled && p_media->vod.p_media )
495 p_vlm->p_vod->pf_media_del( p_vlm->p_vod, p_media->vod.p_media );
496 p_media->vod.p_media = NULL;
498 else if( p_cfg->b_enabled && !p_media->vod.p_media && p_cfg->i_input )
500 /* Pre-parse the input */
501 input_thread_t *p_input;
507 vlc_gc_decref( p_media->vod.p_item );
508 p_media->vod.p_item = input_item_New( p_vlm, p_cfg->ppsz_input[0],
511 if( p_cfg->psz_output )
513 if( asprintf( &psz_output, "%s:description", p_cfg->psz_output ) == -1 )
517 psz_output = strdup( "#description" );
519 if( psz_output && asprintf( &psz_dup, "sout=%s", psz_output ) != -1 )
521 input_item_AddOption( p_media->vod.p_item, psz_dup, VLC_INPUT_OPTION_TRUSTED );
526 for( i = 0; i < p_cfg->i_option; i++ )
527 input_item_AddOption( p_media->vod.p_item,
528 p_cfg->ppsz_option[i], VLC_INPUT_OPTION_TRUSTED );
530 if( asprintf( &psz_header, _("Media: %s"), p_cfg->psz_name ) == -1 )
533 if( (p_input = input_CreateThreadExtended( p_vlm, p_media->vod.p_item, psz_header, NULL ) ) )
535 while( !p_input->b_eof && !p_input->b_error )
538 input_StopThread( p_input );
539 vlc_thread_join( p_input );
540 vlc_object_release( p_input );
544 if( p_cfg->vod.psz_mux )
547 es_format_t es, *p_es = &es;
550 sprintf( fourcc, "%4.4s", p_cfg->vod.psz_mux );
551 fourcc[0] = tolower(fourcc[0]); fourcc[1] = tolower(fourcc[1]);
552 fourcc[2] = tolower(fourcc[2]); fourcc[3] = tolower(fourcc[3]);
554 /* XXX: Don't do it that way, but properly use a new input item ref. */
555 item = *p_media->vod.p_item;
558 es_format_Init( &es, VIDEO_ES, *((int *)fourcc) );
560 p_media->vod.p_media =
561 p_vlm->p_vod->pf_media_new( p_vlm->p_vod, p_cfg->psz_name, &item );
565 p_media->vod.p_media =
566 p_vlm->p_vod->pf_media_new( p_vlm->p_vod, p_cfg->psz_name, p_media->vod.p_item );
572 /* TODO start media if needed */
575 /* TODO add support of var vlm_media_broadcast/vlm_media_vod */
579 static int vlm_ControlMediaChange( vlm_t *p_vlm, vlm_media_t *p_cfg )
581 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, p_cfg->id );
584 if( !p_media || vlm_MediaDescriptionCheck( p_vlm, p_cfg ) )
586 if( ( p_media->cfg.b_vod && !p_cfg->b_vod ) || ( !p_media->cfg.b_vod && p_cfg->b_vod ) )
591 /* TODO check what are the changes being done (stop instance if needed) */
594 vlm_media_Clean( &p_media->cfg );
595 vlm_media_Copy( &p_media->cfg, p_cfg );
597 return vlm_OnMediaUpdate( p_vlm, p_media );
600 static int vlm_ControlMediaAdd( vlm_t *p_vlm, vlm_media_t *p_cfg, int64_t *p_id )
602 vlm_media_sys_t *p_media;
604 if( vlm_MediaDescriptionCheck( p_vlm, p_cfg ) || vlm_ControlMediaGetByName( p_vlm, p_cfg->psz_name ) )
606 msg_Err( p_vlm, "invalid media description" );
609 /* Check if we need to load the VOD server */
610 if( p_cfg->b_vod && !p_vlm->i_vod )
612 p_vlm->p_vod = vlc_custom_create( VLC_OBJECT(p_vlm), sizeof( vod_t ),
613 VLC_OBJECT_GENERIC, "vod server" );
614 vlc_object_attach( p_vlm->p_vod, p_vlm );
615 p_vlm->p_vod->p_module = module_need( p_vlm->p_vod, "vod server", NULL, false );
616 if( !p_vlm->p_vod->p_module )
618 msg_Err( p_vlm, "cannot find vod server" );
619 vlc_object_detach( p_vlm->p_vod );
620 vlc_object_release( p_vlm->p_vod );
625 p_vlm->p_vod->p_data = p_vlm;
626 p_vlm->p_vod->pf_media_control = vlm_MediaVodControl;
629 p_media = calloc( 1, sizeof( vlm_media_sys_t ) );
636 vlm_media_Copy( &p_media->cfg, p_cfg );
637 p_media->cfg.id = p_vlm->i_id++;
638 /* FIXME do we do something here if enabled is true ? */
640 p_media->vod.p_item = input_item_New( p_vlm, NULL, NULL );
642 p_media->vod.p_media = NULL;
643 TAB_INIT( p_media->i_instance, p_media->instance );
646 TAB_APPEND( p_vlm->i_media, p_vlm->media, p_media );
649 *p_id = p_media->cfg.id;
651 return vlm_OnMediaUpdate( p_vlm, p_media );
654 static int vlm_ControlMediaDel( vlm_t *p_vlm, int64_t id )
656 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
661 while( p_media->i_instance > 0 )
662 vlm_ControlInternal( p_vlm, VLM_STOP_MEDIA_INSTANCE, id, p_media->instance[0]->psz_name );
664 if( p_media->cfg.b_vod )
666 p_media->cfg.b_enabled = false;
667 vlm_OnMediaUpdate( p_vlm, p_media );
671 vlm_media_Clean( &p_media->cfg );
673 vlc_gc_decref( p_media->vod.p_item );
675 TAB_REMOVE( p_vlm->i_media, p_vlm->media, p_media );
679 /* Check if we need to unload the VOD server */
680 if( p_vlm->p_vod && p_vlm->i_vod <= 0 )
682 module_unneed( p_vlm->p_vod, p_vlm->p_vod->p_module );
683 vlc_object_detach( p_vlm->p_vod );
684 vlc_object_release( p_vlm->p_vod );
690 static int vlm_ControlMediaGets( vlm_t *p_vlm, vlm_media_t ***ppp_dsc, int *pi_dsc )
692 vlm_media_t **pp_dsc;
696 TAB_INIT( i_dsc, pp_dsc );
697 for( i = 0; i < p_vlm->i_media; i++ )
699 vlm_media_t *p_dsc = vlm_media_Duplicate( &p_vlm->media[i]->cfg );
700 TAB_APPEND( i_dsc, pp_dsc, p_dsc );
708 static int vlm_ControlMediaClear( vlm_t *p_vlm )
710 while( p_vlm->i_media > 0 )
711 vlm_ControlMediaDel( p_vlm, p_vlm->media[0]->cfg.id );
715 static int vlm_ControlMediaGet( vlm_t *p_vlm, int64_t id, vlm_media_t **pp_dsc )
717 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
721 *pp_dsc = vlm_media_Duplicate( &p_media->cfg );
724 static int vlm_ControlMediaGetId( vlm_t *p_vlm, const char *psz_name, int64_t *p_id )
726 vlm_media_sys_t *p_media = vlm_ControlMediaGetByName( p_vlm, psz_name );
730 *p_id = p_media->cfg.id;
734 static vlm_media_instance_sys_t *vlm_ControlMediaInstanceGetByName( vlm_media_sys_t *p_media, const char *psz_id )
738 for( i = 0; i < p_media->i_instance; i++ )
740 const char *psz = p_media->instance[i]->psz_name;
741 if( ( psz == NULL && psz_id == NULL ) ||
742 ( psz && psz_id && !strcmp( psz, psz_id ) ) )
743 return p_media->instance[i];
747 static vlm_media_instance_sys_t *vlm_MediaInstanceNew( vlm_t *p_vlm, const char *psz_name )
749 vlm_media_instance_sys_t *p_instance = calloc( 1, sizeof(vlm_media_instance_sys_t) );
753 p_instance->psz_name = NULL;
755 p_instance->psz_name = strdup( psz_name );
757 p_instance->p_item = input_item_New( p_vlm, NULL, NULL );
759 p_instance->i_index = 0;
760 p_instance->b_sout_keep = false;
761 p_instance->p_input = NULL;
762 p_instance->p_input_resource = NULL;
766 static void vlm_MediaInstanceDelete( vlm_media_instance_sys_t *p_instance )
768 input_thread_t *p_input = p_instance->p_input;
771 input_resource_t *p_resource;
773 input_StopThread( p_input );
774 vlc_thread_join( p_input );
776 p_resource = input_DetachResource( p_input );
777 input_resource_Delete( p_resource );
779 vlc_object_release( p_input );
781 if( p_instance->p_input_resource )
782 input_resource_Delete( p_instance->p_input_resource );
784 vlc_gc_decref( p_instance->p_item );
785 free( p_instance->psz_name );
790 static int vlm_ControlMediaInstanceStart( vlm_t *p_vlm, int64_t id, const char *psz_id, int i_input_index, const char *psz_vod_output )
792 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
793 vlm_media_instance_sys_t *p_instance;
796 if( !p_media || !p_media->cfg.b_enabled || p_media->cfg.i_input <= 0 )
799 /* TODO support multiple input for VOD with sout-keep ? */
801 if( ( p_media->cfg.b_vod && !psz_vod_output ) || ( !p_media->cfg.b_vod && psz_vod_output ) )
804 if( i_input_index < 0 || i_input_index >= p_media->cfg.i_input )
807 p_instance = vlm_ControlMediaInstanceGetByName( p_media, psz_id );
810 vlm_media_t *p_cfg = &p_media->cfg;
813 p_instance = vlm_MediaInstanceNew( p_vlm, psz_id );
817 if( p_cfg->psz_output != NULL || psz_vod_output != NULL )
820 if( asprintf( &psz_buffer, "sout=%s%s%s",
821 p_cfg->psz_output ? p_cfg->psz_output : "",
822 (p_cfg->psz_output && psz_vod_output) ? ":" : psz_vod_output ? "#" : "",
823 psz_vod_output ? psz_vod_output : "" ) != -1 )
825 input_item_AddOption( p_instance->p_item, psz_buffer, VLC_INPUT_OPTION_TRUSTED );
830 for( i = 0; i < p_cfg->i_option; i++ )
832 if( !strcmp( p_cfg->ppsz_option[i], "sout-keep" ) )
833 p_instance->b_sout_keep = true;
834 else if( !strcmp( p_cfg->ppsz_option[i], "nosout-keep" ) || !strcmp( p_cfg->ppsz_option[i], "no-sout-keep" ) )
835 p_instance->b_sout_keep = false;
837 input_item_AddOption( p_instance->p_item, p_cfg->ppsz_option[i], VLC_INPUT_OPTION_TRUSTED );
839 TAB_APPEND( p_media->i_instance, p_media->instance, p_instance );
842 /* Stop old instance */
843 input_thread_t *p_input = p_instance->p_input;
846 if( p_instance->i_index == i_input_index &&
847 !p_input->b_eof && !p_input->b_error )
849 if( var_GetInteger( p_input, "state" ) == PAUSE_S )
850 var_SetInteger( p_input, "state", PLAYING_S );
854 input_StopThread( p_input );
855 vlc_thread_join( p_input );
857 p_instance->p_input_resource = input_DetachResource( p_input );
859 vlc_object_release( p_input );
861 if( !p_instance->b_sout_keep )
862 input_resource_TerminateSout( p_instance->p_input_resource );
863 input_resource_TerminateVout( p_instance->p_input_resource );
867 p_instance->i_index = i_input_index;
868 input_item_SetURI( p_instance->p_item, p_media->cfg.ppsz_input[p_instance->i_index] ) ;
870 if( asprintf( &psz_log, _("Media: %s"), p_media->cfg.psz_name ) != -1 )
872 p_instance->p_input = input_CreateThreadExtended( p_vlm, p_instance->p_item,
873 psz_log, p_instance->p_input_resource );
874 p_instance->p_input_resource = NULL;
876 if( !p_instance->p_input )
878 TAB_REMOVE( p_media->i_instance, p_media->instance, p_instance );
879 vlm_MediaInstanceDelete( p_instance );
887 static int vlm_ControlMediaInstanceStop( vlm_t *p_vlm, int64_t id, const char *psz_id )
889 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
890 vlm_media_instance_sys_t *p_instance;
895 p_instance = vlm_ControlMediaInstanceGetByName( p_media, psz_id );
899 TAB_REMOVE( p_media->i_instance, p_media->instance, p_instance );
901 vlm_MediaInstanceDelete( p_instance );
905 static int vlm_ControlMediaInstancePause( vlm_t *p_vlm, int64_t id, const char *psz_id )
907 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
908 vlm_media_instance_sys_t *p_instance;
914 p_instance = vlm_ControlMediaInstanceGetByName( p_media, psz_id );
915 if( !p_instance || !p_instance->p_input )
918 /* Toggle pause state */
919 i_state = var_GetInteger( p_instance->p_input, "state" );
920 if( i_state == PAUSE_S )
921 var_SetInteger( p_instance->p_input, "state", PLAYING_S );
922 else if( i_state == PLAYING_S )
923 var_SetInteger( p_instance->p_input, "state", PAUSE_S );
926 static int vlm_ControlMediaInstanceGetTimePosition( vlm_t *p_vlm, int64_t id, const char *psz_id, int64_t *pi_time, double *pd_position )
928 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
929 vlm_media_instance_sys_t *p_instance;
934 p_instance = vlm_ControlMediaInstanceGetByName( p_media, psz_id );
935 if( !p_instance || !p_instance->p_input )
939 *pi_time = var_GetTime( p_instance->p_input, "time" );
941 *pd_position = var_GetFloat( p_instance->p_input, "position" );
944 static int vlm_ControlMediaInstanceSetTimePosition( vlm_t *p_vlm, int64_t id, const char *psz_id, int64_t i_time, double d_position )
946 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
947 vlm_media_instance_sys_t *p_instance;
952 p_instance = vlm_ControlMediaInstanceGetByName( p_media, psz_id );
953 if( !p_instance || !p_instance->p_input )
957 return var_SetTime( p_instance->p_input, "time", i_time );
958 else if( d_position >= 0 && d_position <= 100 )
959 return var_SetFloat( p_instance->p_input, "position", d_position );
963 static int vlm_ControlMediaInstanceGets( vlm_t *p_vlm, int64_t id, vlm_media_instance_t ***ppp_idsc, int *pi_instance )
965 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
966 vlm_media_instance_t **pp_idsc;
973 TAB_INIT( i_idsc, pp_idsc );
974 for( i = 0; i < p_media->i_instance; i++ )
976 vlm_media_instance_sys_t *p_instance = p_media->instance[i];
977 vlm_media_instance_t *p_idsc = vlm_media_instance_New();
979 if( p_instance->psz_name )
980 p_idsc->psz_name = strdup( p_instance->psz_name );
981 if( p_instance->p_input )
983 p_idsc->i_time = var_GetTime( p_instance->p_input, "time" );
984 p_idsc->i_length = var_GetTime( p_instance->p_input, "length" );
985 p_idsc->d_position = var_GetFloat( p_instance->p_input, "position" );
986 if( var_GetInteger( p_instance->p_input, "state" ) == PAUSE_S )
987 p_idsc->b_paused = true;
988 p_idsc->i_rate = var_GetInteger( p_instance->p_input, "rate" );
991 TAB_APPEND( i_idsc, pp_idsc, p_idsc );
994 *pi_instance = i_idsc;
998 static int vlm_ControlMediaInstanceClear( vlm_t *p_vlm, int64_t id )
1000 vlm_media_sys_t *p_media = vlm_ControlMediaGetById( p_vlm, id );
1003 return VLC_EGENERIC;
1005 while( p_media->i_instance > 0 )
1006 vlm_ControlMediaInstanceStop( p_vlm, id, p_media->instance[0]->psz_name );
1011 static int vlm_ControlScheduleClear( vlm_t *p_vlm )
1013 while( p_vlm->i_schedule > 0 )
1014 vlm_ScheduleDelete( p_vlm, p_vlm->schedule[0] );
1019 static int vlm_vaControlInternal( vlm_t *p_vlm, int i_query, va_list args )
1022 vlm_media_t **pp_dsc;
1023 vlm_media_t ***ppp_dsc;
1024 vlm_media_instance_t ***ppp_idsc;
1026 const char *psz_vod;
1040 case VLM_GET_MEDIAS:
1041 ppp_dsc = (vlm_media_t ***)va_arg( args, vlm_media_t *** );
1042 pi_int = (int *)va_arg( args, int * );
1043 return vlm_ControlMediaGets( p_vlm, ppp_dsc, pi_int );
1045 case VLM_CLEAR_MEDIAS:
1046 return vlm_ControlMediaClear( p_vlm );
1048 case VLM_CHANGE_MEDIA:
1049 p_dsc = (vlm_media_t*)va_arg( args, vlm_media_t * );
1050 return vlm_ControlMediaChange( p_vlm, p_dsc );
1053 p_dsc = (vlm_media_t*)va_arg( args, vlm_media_t * );
1054 p_id = (int64_t*)va_arg( args, int64_t * );
1055 return vlm_ControlMediaAdd( p_vlm, p_dsc, p_id );
1058 id = (int64_t)va_arg( args, int64_t );
1059 return vlm_ControlMediaDel( p_vlm, id );
1062 id = (int64_t)va_arg( args, int64_t );
1063 pp_dsc = (vlm_media_t **)va_arg( args, vlm_media_t ** );
1064 return vlm_ControlMediaGet( p_vlm, id, pp_dsc );
1066 case VLM_GET_MEDIA_ID:
1067 psz_id = (const char*)va_arg( args, const char * );
1068 p_id = (int64_t*)va_arg( args, int64_t * );
1069 return vlm_ControlMediaGetId( p_vlm, psz_id, p_id );
1072 /* Media instance control */
1073 case VLM_GET_MEDIA_INSTANCES:
1074 id = (int64_t)va_arg( args, int64_t );
1075 ppp_idsc = (vlm_media_instance_t ***)va_arg( args, vlm_media_instance_t *** );
1076 pi_int = (int *)va_arg( args, int *);
1077 return vlm_ControlMediaInstanceGets( p_vlm, id, ppp_idsc, pi_int );
1079 case VLM_CLEAR_MEDIA_INSTANCES:
1080 id = (int64_t)va_arg( args, int64_t );
1081 return vlm_ControlMediaInstanceClear( p_vlm, id );
1084 case VLM_START_MEDIA_BROADCAST_INSTANCE:
1085 id = (int64_t)va_arg( args, int64_t );
1086 psz_id = (const char*)va_arg( args, const char* );
1087 i_int = (int)va_arg( args, int );
1088 return vlm_ControlMediaInstanceStart( p_vlm, id, psz_id, i_int, NULL );
1090 case VLM_START_MEDIA_VOD_INSTANCE:
1091 id = (int64_t)va_arg( args, int64_t );
1092 psz_id = (const char*)va_arg( args, const char* );
1093 i_int = (int)va_arg( args, int );
1094 psz_vod = (const char*)va_arg( args, const char* );
1096 return VLC_EGENERIC;
1097 return vlm_ControlMediaInstanceStart( p_vlm, id, psz_id, i_int, psz_vod );
1099 case VLM_STOP_MEDIA_INSTANCE:
1100 id = (int64_t)va_arg( args, int64_t );
1101 psz_id = (const char*)va_arg( args, const char* );
1102 return vlm_ControlMediaInstanceStop( p_vlm, id, psz_id );
1104 case VLM_PAUSE_MEDIA_INSTANCE:
1105 id = (int64_t)va_arg( args, int64_t );
1106 psz_id = (const char*)va_arg( args, const char* );
1107 return vlm_ControlMediaInstancePause( p_vlm, id, psz_id );
1109 case VLM_GET_MEDIA_INSTANCE_TIME:
1110 id = (int64_t)va_arg( args, int64_t );
1111 psz_id = (const char*)va_arg( args, const char* );
1112 pi_i64 = (int64_t*)va_arg( args, int64_t * );
1113 return vlm_ControlMediaInstanceGetTimePosition( p_vlm, id, psz_id, pi_i64, NULL );
1114 case VLM_GET_MEDIA_INSTANCE_POSITION:
1115 id = (int64_t)va_arg( args, int64_t );
1116 psz_id = (const char*)va_arg( args, const char* );
1117 pd_double = (double*)va_arg( args, double* );
1118 return vlm_ControlMediaInstanceGetTimePosition( p_vlm, id, psz_id, NULL, pd_double );
1120 case VLM_SET_MEDIA_INSTANCE_TIME:
1121 id = (int64_t)va_arg( args, int64_t );
1122 psz_id = (const char*)va_arg( args, const char* );
1123 i_i64 = (int64_t)va_arg( args, int64_t);
1124 return vlm_ControlMediaInstanceSetTimePosition( p_vlm, id, psz_id, i_i64, -1 );
1125 case VLM_SET_MEDIA_INSTANCE_POSITION:
1126 id = (int64_t)va_arg( args, int64_t );
1127 psz_id = (const char*)va_arg( args, const char* );
1128 d_double = (double)va_arg( args, double );
1129 return vlm_ControlMediaInstanceSetTimePosition( p_vlm, id, psz_id, -1, d_double );
1131 case VLM_CLEAR_SCHEDULES:
1132 return vlm_ControlScheduleClear( p_vlm );
1135 msg_Err( p_vlm, "unknown VLM query" );
1136 return VLC_EGENERIC;
1140 int vlm_ControlInternal( vlm_t *p_vlm, int i_query, ... )
1145 va_start( args, i_query );
1146 i_result = vlm_vaControlInternal( p_vlm, i_query, args );
1152 int vlm_Control( vlm_t *p_vlm, int i_query, ... )
1157 va_start( args, i_query );
1159 vlc_mutex_lock( &p_vlm->lock );
1160 i_result = vlm_vaControlInternal( p_vlm, i_query, args );
1161 vlc_mutex_unlock( &p_vlm->lock );