X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Finput%2Finput.c;h=af6ee7ada96d97fa7c8e44f4384bf41132021e6c;hb=b2efc40a9581d828f969a86b098eed7d376cecad;hp=5c631479b2b3022eda7efebf839530b887f69b9c;hpb=aa4b437134fac4d57a8b04f91631a283f215d8b1;p=vlc diff --git a/src/input/input.c b/src/input/input.c index 5c631479b2..af6ee7ada9 100644 --- a/src/input/input.c +++ b/src/input/input.c @@ -36,6 +36,13 @@ #include #include "input_internal.h" +#include "event.h" +#include "es_out.h" +#include "es_out_timeshift.h" +#include "access.h" +#include "demux.h" +#include "stream.h" +#include "item.h" #include #include "../stream_output/stream_output.h" @@ -54,8 +61,8 @@ *****************************************************************************/ static void Destructor( input_thread_t * p_input ); -static void* Run ( vlc_object_t *p_this ); -static void* RunAndDestroy ( vlc_object_t *p_this ); +static void *Run ( vlc_object_t *p_this ); +static void *RunAndDestroy ( vlc_object_t *p_this ); static input_thread_t * Create ( vlc_object_t *, input_item_t *, const char *, bool, sout_instance_t * ); @@ -64,14 +71,17 @@ static void WaitDie ( input_thread_t *p_input ); static void End ( input_thread_t *p_input ); static void MainLoop( input_thread_t *p_input ); +static void ObjectKillChildrens( input_thread_t *, vlc_object_t * ); + static inline int ControlPopNoLock( input_thread_t *, int *, vlc_value_t *, mtime_t i_deadline ); static void ControlReduce( input_thread_t * ); static bool Control( input_thread_t *, int, vlc_value_t ); -static int UpdateFromAccess( input_thread_t * ); -static int UpdateFromDemux( input_thread_t * ); +static int UpdateTitleSeekpointFromAccess( input_thread_t * ); +static void UpdateGenericFromAccess( input_thread_t * ); -static void UpdateItemLength( input_thread_t *, int64_t i_length ); +static int UpdateTitleSeekpointFromDemux( input_thread_t * ); +static void UpdateGenericFromDemux( input_thread_t * ); static void MRLSections( input_thread_t *, char *, int *, int *, int *, int *); @@ -79,6 +89,8 @@ static input_source_t *InputSourceNew( input_thread_t *); static int InputSourceInit( input_thread_t *, input_source_t *, const char *, const char *psz_forced_demux ); static void InputSourceClean( input_source_t * ); +static void InputSourceMeta( input_thread_t *, input_source_t *, vlc_meta_t * ); + /* TODO */ //static void InputGetAttachments( input_thread_t *, input_source_t * ); static void SlaveDemux( input_thread_t *p_input ); @@ -86,45 +98,22 @@ static void SlaveSeek( input_thread_t *p_input ); static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta ); static void InputUpdateMeta( input_thread_t *p_input, vlc_meta_t *p_meta ); -static char *InputGetExtraFiles( input_thread_t *p_input, - const char *psz_access, const char *psz_path ); +static void InputGetExtraFiles( input_thread_t *p_input, + int *pi_list, char ***pppsz_list, + const char *psz_access, const char *psz_path ); -static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_demux ); -static void AccessMeta( input_thread_t * p_input, vlc_meta_t *p_meta ); static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment, int i_new, input_attachment_t **pp_new ); static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_forced ); +static void input_ChangeState( input_thread_t *p_input, int i_state ); /* TODO fix name */ + /***************************************************************************** * This function creates a new input, and returns a pointer * to its description. On error, it returns NULL. * - * Variables for _public_ use: - * * Get and Set: - * - state - * - rate,rate-slower, rate-faster - * - position, position-offset - * - time, time-offset - * - title,title-next,title-prev - * - chapter,chapter-next, chapter-prev - * - program, audio-es, video-es, spu-es - * - audio-delay, spu-delay - * - bookmark - * * Get only: - * - length - * - bookmarks - * - seekable (if you can seek, it doesn't say if 'bar display' has be shown - * or not, for that check position != 0.0) - * - can-pause - * - can-record (if a stream can be recorded while playing) - * - teletext-es to get the index of spu track that is teletext --1 if no teletext) - * * For intf callback upon changes: - * - intf-change - * - intf-change-vout for when a vout is created or destroyed - * - rate-change for when playback rate changes - * TODO explain when Callback is called - * TODO complete this list (?) + * XXX Do not forget to update vlc_input.h if you add new variables. *****************************************************************************/ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, const char *psz_header, bool b_quick, @@ -156,8 +145,9 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, stats_TimerStart( p_input, psz_timer_name, STATS_TIMER_INPUT_LAUNCHING ); - MALLOC_NULL( p_input->p, input_thread_private_t ); - memset( p_input->p, 0, sizeof( input_thread_private_t ) ); + p_input->p = calloc( 1, sizeof( input_thread_private_t ) ); + if( !p_input->p ) + return NULL; /* One "randomly" selected input thread is responsible for computing * the global stats. Check if there is already someone doing this */ @@ -173,35 +163,33 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, p_input->b_preparsing = b_quick; p_input->psz_header = psz_header ? strdup( psz_header ) : NULL; - /* Init events */ - vlc_event_manager_t * p_em = &p_input->p->event_manager; - vlc_event_manager_init_with_vlc_object( p_em, p_input ); - vlc_event_manager_register_event_type( p_em, vlc_InputStateChanged ); - vlc_event_manager_register_event_type( p_em, vlc_InputSelectedStreamChanged ); - /* Init Common fields */ p_input->b_eof = false; p_input->b_can_pace_control = true; p_input->p->i_start = 0; - p_input->i_time = 0; + p_input->i_time = 0; p_input->p->i_stop = 0; - p_input->p->i_run = 0; + p_input->p->i_run = 0; p_input->p->i_title = 0; - p_input->p->title = NULL; + p_input->p->title = NULL; p_input->p->i_title_offset = p_input->p->i_seekpoint_offset = 0; p_input->i_state = INIT_S; - p_input->p->i_rate = INPUT_RATE_DEFAULT; + p_input->p->i_rate = INPUT_RATE_DEFAULT; p_input->p->b_recording = false; - TAB_INIT( p_input->p->i_bookmark, p_input->p->bookmark ); + memset( &p_input->p->bookmark, 0, sizeof(p_input->p->bookmark) ); + TAB_INIT( p_input->p->i_bookmark, p_input->p->pp_bookmark ); TAB_INIT( p_input->p->i_attachment, p_input->p->attachment ); + p_input->p->p_es_out_display = NULL; p_input->p->p_es_out = NULL; - p_input->p->p_sout = NULL; + p_input->p->p_sout = NULL; p_input->p->b_out_pace_control = false; p_input->i_pts_delay = 0; + p_input->p->i_cr_average = 0; - /* Init Input fields */ vlc_gc_incref( p_item ); /* Released in Destructor() */ - p_input->p->input.p_item = p_item; + p_input->p->p_item = p_item; + + /* Init Input fields */ p_input->p->input.p_access = NULL; p_input->p->input.p_stream = NULL; p_input->p->input.p_demux = NULL; @@ -213,7 +201,6 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, p_input->p->input.b_can_rate_control = true; p_input->p->input.b_rescale_ts = true; p_input->p->input.b_eof = false; - p_input->p->input.i_cr_average = 0; vlc_mutex_lock( &p_item->lock ); @@ -245,7 +232,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, input_ControlVarInit( p_input ); /* */ - p_input->p->input.i_cr_average = var_GetInteger( p_input, "cr-average" ); + p_input->p->i_cr_average = var_GetInteger( p_input, "cr-average" ); if( !p_input->b_preparsing ) { @@ -257,7 +244,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, psz_parser = val.psz_string; while( (psz_start = strchr( psz_parser, '{' ) ) ) { - seekpoint_t *p_seekpoint = vlc_seekpoint_New(); + seekpoint_t *p_seekpoint; char backup; psz_start++; psz_end = strchr( psz_start, '}' ); @@ -266,6 +253,8 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, backup = *psz_parser; *psz_parser = 0; *psz_end = ','; + + p_seekpoint = vlc_seekpoint_New(); while( (psz_end = strchr( psz_start, ',' ) ) ) { *psz_end = 0; @@ -297,6 +286,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, /* Remove 'Now playing' info as it is probably outdated */ input_item_SetNowPlaying( p_item, NULL ); + input_SendEventMeta( p_input ); /* */ if( p_input->b_preparsing ) @@ -324,20 +314,18 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, static void Destructor( input_thread_t * p_input ) { #ifndef NDEBUG - char * psz_name = input_item_GetName( p_input->p->input.p_item ); + char * psz_name = input_item_GetName( p_input->p->p_item ); msg_Dbg( p_input, "Destroying the input for '%s'", psz_name); free( psz_name ); #endif - vlc_event_manager_fini( &p_input->p->event_manager ); - stats_TimerDump( p_input, STATS_TIMER_INPUT_LAUNCHING ); stats_TimerClean( p_input, STATS_TIMER_INPUT_LAUNCHING ); #ifdef ENABLE_SOUT if( p_input->p->p_sout ) sout_DeleteInstance( p_input->p->p_sout ); #endif - vlc_gc_decref( p_input->p->input.p_item ); + vlc_gc_decref( p_input->p->p_item ); vlc_mutex_destroy( &p_input->p->counters.counters_lock ); @@ -453,6 +441,40 @@ int __input_Preparse( vlc_object_t *p_parent, input_item_t *p_item ) * * \param the input thread to stop */ +void input_StopThread( input_thread_t *p_input ) +{ + /* Set die for input and ALL of this childrens (even (grand-)grand-childrens) + * It is needed here even if it is done in INPUT_CONTROL_SET_DIE handler to + * unlock the control loop */ + ObjectKillChildrens( p_input, VLC_OBJECT(p_input) ); + + input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL ); +} + +sout_instance_t *input_DetachSout( input_thread_t *p_input ) +{ + assert( p_input->b_dead ); + sout_instance_t *p_sout = p_input->p->p_sout; + vlc_object_detach( p_sout ); + p_input->p->p_sout = NULL; + return p_sout; +} + +/** + * Get the item from an input thread + * FIXME it does not increase ref count of the item. + * if it is used after p_input is destroyed nothing prevent it from + * being freed. + */ +input_item_t *input_GetItem( input_thread_t *p_input ) +{ + assert( p_input && p_input->p ); + return p_input->p->p_item; +} + +/***************************************************************************** + * ObjectKillChildrens + *****************************************************************************/ static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj ) { vlc_list_t *p_list; @@ -470,30 +492,13 @@ static void ObjectKillChildrens( input_thread_t *p_input, vlc_object_t *p_obj ) ObjectKillChildrens( p_input, p_list->p_values[i].p_object ); vlc_list_release( p_list ); } -void input_StopThread( input_thread_t *p_input ) -{ - /* Set die for input and ALL of this childrens (even (grand-)grand-childrens) - * It is needed here even if it is done in INPUT_CONTROL_SET_DIE handler to - * unlock the control loop */ - ObjectKillChildrens( p_input, VLC_OBJECT(p_input) ); - - input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL ); -} - -sout_instance_t * input_DetachSout( input_thread_t *p_input ) -{ - sout_instance_t *p_sout = p_input->p->p_sout; - vlc_object_detach( p_sout ); - p_input->p->p_sout = NULL; - return p_sout; -} /***************************************************************************** * Run: main thread loop * This is the "normal" thread that spawns the input processing chain, * reads the stream, cleans up and waits *****************************************************************************/ -static void* Run( vlc_object_t *p_this ) +static void *Run( vlc_object_t *p_this ) { input_thread_t *p_input = (input_thread_t *)p_this; const int canc = vlc_savecancel(); @@ -515,7 +520,9 @@ static void* Run( vlc_object_t *p_this ) End( p_input ); exit: - p_input->b_dead = true; + /* Tell we're dead */ + input_SendEventDead( p_input ); + vlc_restorecancel( canc ); return NULL; } @@ -525,7 +532,7 @@ exit: * This is the "just forget me" thread that spawns the input processing chain, * reads the stream, cleans up and releases memory *****************************************************************************/ -static void* RunAndDestroy( vlc_object_t *p_this ) +static void *RunAndDestroy( vlc_object_t *p_this ) { input_thread_t *p_input = (input_thread_t *)p_this; const int canc = vlc_savecancel(); @@ -563,23 +570,28 @@ static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, mtime_t *p ( p_input->p->i_run > 0 && *pi_start_mdate+p_input->p->i_run < mdate() ) ) i_ret = 0; /* EOF */ else - i_ret = p_input->p->input.p_demux->pf_demux(p_input->p->input.p_demux); + i_ret = demux_Demux( p_input->p->input.p_demux ); if( i_ret > 0 ) { - /* TODO */ - if( p_input->p->input.b_title_demux && - p_input->p->input.p_demux->info.i_update ) + if( p_input->p->input.p_demux->info.i_update ) { - i_ret = UpdateFromDemux( p_input ); - *pb_changed = true; + if( p_input->p->input.b_title_demux ) + { + i_ret = UpdateTitleSeekpointFromDemux( p_input ); + *pb_changed = true; + } + UpdateGenericFromDemux( p_input ); } - else if( !p_input->p->input.b_title_demux && - p_input->p->input.p_access && - p_input->p->input.p_access->info.i_update ) + else if( p_input->p->input.p_access && + p_input->p->input.p_access->info.i_update ) { - i_ret = UpdateFromAccess( p_input ); - *pb_changed = true; + if( !p_input->p->input.b_title_demux ) + { + i_ret = UpdateTitleSeekpointFromAccess( p_input ); + *pb_changed = true; + } + UpdateGenericFromAccess( p_input ); } } @@ -656,39 +668,32 @@ static void MainLoopDemux( input_thread_t *p_input, bool *pb_changed, mtime_t *p */ static void MainLoopInterface( input_thread_t *p_input ) { - vlc_value_t val; - double f_pos; - int64_t i_time, i_length; + double f_position = 0.0; + mtime_t i_time = 0; + mtime_t i_length = 0; /* update input status variables */ - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_POSITION, &f_pos ) ) - { - val.f_float = (float)f_pos; - var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL ); - } - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_TIME, &i_time ) ) - { - p_input->i_time = i_time; - val.i_time = i_time; - var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL ); - } - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_LENGTH, &i_length ) ) - { - vlc_value_t old_val; - var_Get( p_input, "length", &old_val ); - val.i_time = i_length; - var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL ); - - if( old_val.i_time != val.i_time ) - { - UpdateItemLength( p_input, i_length ); - } - } - - var_SetBool( p_input, "intf-change", true ); + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_POSITION, &f_position ) ) + f_position = 0.0; + + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_TIME, &i_time ) ) + i_time = 0; + p_input->i_time = i_time; + + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_LENGTH, &i_length ) ) + i_length = 0; + + es_out_SetTimes( p_input->p->p_es_out, f_position, i_time, i_length ); + + /* update current bookmark */ + vlc_mutex_lock( &p_input->p->p_item->lock ); + p_input->p->bookmark.i_time_offset = i_time; + if( p_input->p->input.p_stream ) + p_input->p->bookmark.i_byte_offset = stream_Tell( p_input->p->input.p_stream ); + vlc_mutex_unlock( &p_input->p->p_item->lock ); } /** @@ -697,13 +702,14 @@ static void MainLoopInterface( input_thread_t *p_input ) */ static void MainLoopStatistic( input_thread_t *p_input ) { - stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats ); + stats_ComputeInputStats( p_input, p_input->p->p_item->p_stats ); /* Are we the thread responsible for computing global stats ? */ if( libvlc_priv( p_input->p_libvlc )->p_stats_computer == p_input ) { stats_ComputeGlobalStats( p_input->p_libvlc, p_input->p_libvlc->p_stats ); } + input_SendEventStatistics( p_input ); } /** @@ -719,7 +725,7 @@ static void MainLoop( input_thread_t *p_input ) /* Start the timer */ stats_TimerStop( p_input, STATS_TIMER_INPUT_LAUNCHING ); - while( !p_input->b_die && !p_input->b_error && !p_input->p->input.b_eof ) + while( vlc_object_alive( p_input ) && !p_input->b_error ) { bool b_force_update; int i_type; @@ -727,20 +733,40 @@ static void MainLoop( input_thread_t *p_input ) mtime_t i_current; mtime_t i_deadline; mtime_t i_wakeup; + bool b_paused; /* Demux data */ b_force_update = false; i_wakeup = 0; - if( p_input->i_state != PAUSE_S ) + /* FIXME if p_input->i_state == PAUSE_S the access/access_demux + * is paused -> this may cause problem with some of them + * The same problem can be seen when seeking while paused */ + b_paused = p_input->i_state == PAUSE_S && + !es_out_GetBuffering( p_input->p->p_es_out ); + + if( !b_paused ) { - MainLoopDemux( p_input, &b_force_update, &i_start_mdate ); - i_wakeup = input_EsOutGetWakeup( p_input->p->p_es_out ); + if( !p_input->p->input.b_eof ) + { + MainLoopDemux( p_input, &b_force_update, &i_start_mdate ); + + i_wakeup = es_out_GetWakeup( p_input->p->p_es_out ); + } + else if( !p_input->b_eof && !es_out_GetEmpty( p_input->p->p_es_out ) ) + { + msg_Dbg( p_input, "waiting decoder fifos to empty" ); + i_wakeup = mdate() + INPUT_IDLE_SLEEP; + } + else + { + break; + } } /* */ do { i_deadline = i_wakeup; - if( p_input->i_state == PAUSE_S ) + if( b_paused ) i_deadline = __MIN( i_intf_update, i_statistic_update ); /* Handle control */ @@ -749,6 +775,7 @@ static void MainLoop( input_thread_t *p_input ) while( !ControlPopNoLock( p_input, &i_type, &val, i_deadline ) ) { msg_Dbg( p_input, "control type=%d", i_type ); + if( Control( p_input, i_type, val ) ) b_force_update = true; } @@ -771,29 +798,15 @@ static void MainLoop( input_thread_t *p_input ) /* Check if i_wakeup is still valid */ if( i_wakeup != 0 ) { - mtime_t i_new_wakeup = input_EsOutGetWakeup( p_input->p->p_es_out ); + mtime_t i_new_wakeup = es_out_GetWakeup( p_input->p->p_es_out ); if( !i_new_wakeup ) i_wakeup = 0; } } while( i_current < i_wakeup ); } - if( !p_input->b_eof && !p_input->b_error && p_input->p->input.b_eof ) - { - /* We have finish to demux data but not to play them */ - while( vlc_object_alive( p_input ) ) - { - if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) ) - break; - - msg_Dbg( p_input, "waiting decoder fifos to empty" ); - - msleep( INPUT_IDLE_SLEEP ); - } - - /* We have finished */ + if( !p_input->b_error ) input_ChangeState( p_input, END_S ); - } } static void InitStatistics( input_thread_t * p_input ) @@ -836,7 +849,7 @@ static int InitSout( input_thread_t * p_input ) /* Find a usable sout and attach it to p_input */ psz = var_GetNonEmptyString( p_input, "sout" ); - if( psz && strncasecmp( p_input->p->input.p_item->psz_uri, "vlc:", 4 ) ) + if( psz && strncasecmp( p_input->p->p_item->psz_uri, "vlc:", 4 ) ) { /* Check the validity of the provided sout */ if( p_input->p->p_sout ) @@ -896,15 +909,16 @@ static int InitSout( input_thread_t * p_input ) static void InitTitle( input_thread_t * p_input ) { - vlc_value_t val; + input_source_t *p_master = &p_input->p->input; - if( p_input->b_preparsing ) return; + if( p_input->b_preparsing ) + return; /* Create global title (from master) */ - p_input->p->i_title = p_input->p->input.i_title; - p_input->p->title = p_input->p->input.title; - p_input->p->i_title_offset = p_input->p->input.i_title_offset; - p_input->p->i_seekpoint_offset = p_input->p->input.i_seekpoint_offset; + p_input->p->i_title = p_master->i_title; + p_input->p->title = p_master->title; + p_input->p->i_title_offset = p_master->i_title_offset; + p_input->p->i_seekpoint_offset = p_master->i_seekpoint_offset; if( p_input->p->i_title > 0 ) { /* Setup variables */ @@ -913,9 +927,9 @@ static void InitTitle( input_thread_t * p_input ) } /* Global flag */ - p_input->b_can_pace_control = p_input->p->input.b_can_pace_control; - p_input->p->b_can_pause = p_input->p->input.b_can_pause; - p_input->p->b_can_rate_control = p_input->p->input.b_can_rate_control; + p_input->b_can_pace_control = p_master->b_can_pace_control; + p_input->p->b_can_pause = p_master->b_can_pause; + p_input->p->b_can_rate_control = p_master->b_can_rate_control; /* Fix pts delay */ if( p_input->i_pts_delay < 0 ) @@ -923,54 +937,43 @@ static void InitTitle( input_thread_t * p_input ) /* If the desynchronisation requested by the user is < 0, we need to * cache more data. */ - var_Get( p_input, "audio-desync", &val ); - if( val.i_int < 0 ) - p_input->i_pts_delay -= (val.i_int * 1000); + const int i_desynch = var_GetInteger( p_input, "audio-desync" ); + if( i_desynch < 0 ) + p_input->i_pts_delay -= i_desynch * 1000; /* Update cr_average depending on the caching */ - p_input->p->input.i_cr_average *= (10 * p_input->i_pts_delay / 200000); - p_input->p->input.i_cr_average /= 10; - if( p_input->p->input.i_cr_average < 10 ) p_input->p->input.i_cr_average = 10; + p_input->p->i_cr_average *= (10 * p_input->i_pts_delay / 200000); + p_input->p->i_cr_average /= 10; + if( p_input->p->i_cr_average < 10 ) + p_input->p->i_cr_average = 10; } static void StartTitle( input_thread_t * p_input ) { - double f_fps; vlc_value_t val; - int i_delay; - char *psz; - char *psz_subtitle; - int64_t i_length; /* Start title/chapter */ - - if( p_input->b_preparsing ) - { - p_input->p->i_start = 0; - return; - } - val.i_int = p_input->p->input.i_title_start - p_input->p->input.i_title_offset; if( val.i_int > 0 && val.i_int < p_input->p->input.i_title ) input_ControlPush( p_input, INPUT_CONTROL_SET_TITLE, &val ); + val.i_int = p_input->p->input.i_seekpoint_start - p_input->p->input.i_seekpoint_offset; if( val.i_int > 0 /* TODO: check upper boundary */ ) input_ControlPush( p_input, INPUT_CONTROL_SET_SEEKPOINT, &val ); - /* Start time*/ - /* Set start time */ + /* Start/stop/run time */ p_input->p->i_start = INT64_C(1000000) * var_GetInteger( p_input, "start-time" ); p_input->p->i_stop = INT64_C(1000000) * var_GetInteger( p_input, "stop-time" ); p_input->p->i_run = INT64_C(1000000) * var_GetInteger( p_input, "run-time" ); - i_length = var_GetTime( p_input, "length" ); if( p_input->p->i_run < 0 ) { msg_Warn( p_input, "invalid run-time ignored" ); p_input->p->i_run = 0; } + const mtime_t i_length = var_GetTime( p_input, "length" ); if( p_input->p->i_start > 0 ) { if( p_input->p->i_start >= i_length ) @@ -993,11 +996,14 @@ static void StartTitle( input_thread_t * p_input ) msg_Warn( p_input, "invalid stop-time ignored" ); p_input->p->i_stop = 0; } +} +static void LoadSubtitles( input_thread_t *p_input ) +{ /* Load subtitles */ /* Get fps and set it if not already set */ - if( !demux_Control( p_input->p->input.p_demux, DEMUX_GET_FPS, &f_fps ) && - f_fps > 1.0 ) + const double f_fps = p_input->p->f_fps; + if( f_fps > 1.0 ) { float f_requested_fps; @@ -1013,26 +1019,23 @@ static void StartTitle( input_thread_t * p_input ) } } - i_delay = var_CreateGetInteger( p_input, "sub-delay" ); + const int i_delay = var_CreateGetInteger( p_input, "sub-delay" ); if( i_delay != 0 ) - { var_SetTime( p_input, "spu-delay", (mtime_t)i_delay * 100000 ); - } /* Look for and add subtitle files */ - psz_subtitle = var_GetNonEmptyString( p_input, "sub-file" ); + char *psz_subtitle = var_GetNonEmptyString( p_input, "sub-file" ); if( psz_subtitle != NULL ) { msg_Dbg( p_input, "forced subtitle: %s", psz_subtitle ); SubtitleAdd( p_input, psz_subtitle, true ); } - var_Get( p_input, "sub-autodetect-file", &val ); - if( val.b_bool ) + if( var_GetBool( p_input, "sub-autodetect-file" ) ) { char *psz_autopath = var_GetNonEmptyString( p_input, "sub-autodetect-path" ); char **ppsz_subs = subtitles_Detect( p_input, psz_autopath, - p_input->p->input.p_item->psz_uri ); + p_input->p->p_item->psz_uri ); free( psz_autopath ); for( int i = 0; ppsz_subs && ppsz_subs[i]; i++ ) @@ -1049,39 +1052,38 @@ static void StartTitle( input_thread_t * p_input ) free( ppsz_subs ); } free( psz_subtitle ); +} + +static void LoadSlaves( input_thread_t *p_input ) +{ + char *psz = var_GetNonEmptyString( p_input, "input-slave" ); + if( !psz ) + return; - /* Look for slave */ - psz = var_GetNonEmptyString( p_input, "input-slave" ); - if( psz != NULL ) + char *psz_org = psz; + while( psz && *psz ) { - char *psz_delim; - input_source_t *slave; - while( psz && *psz ) - { - while( *psz == ' ' || *psz == '#' ) - { - psz++; - } - if( ( psz_delim = strchr( psz, '#' ) ) ) - { - *psz_delim++ = '\0'; - } - if( *psz == 0 ) - { - break; - } + while( *psz == ' ' || *psz == '#' ) + psz++; - msg_Dbg( p_input, "adding slave input '%s'", psz ); - slave = InputSourceNew( p_input ); - if( !InputSourceInit( p_input, slave, psz, NULL ) ) - { - TAB_APPEND( p_input->p->i_slave, p_input->p->slave, slave ); - } - else free( slave ); - psz = psz_delim; - } - free( psz ); + char *psz_delim = strchr( psz, '#' ); + if( psz_delim ) + *psz_delim++ = '\0'; + + if( *psz == 0 ) + break; + + msg_Dbg( p_input, "adding slave input '%s'", psz ); + + input_source_t *p_slave = InputSourceNew( p_input ); + if( p_slave && !InputSourceInit( p_input, p_slave, psz, NULL ) ) + TAB_APPEND( p_input->p->i_slave, p_input->p->slave, p_slave ); + else + free( p_slave ); + + psz = psz_delim; } + free( psz_org ); } static void InitPrograms( input_thread_t * p_input ) @@ -1089,8 +1091,6 @@ static void InitPrograms( input_thread_t * p_input ) int i_es_out_mode; vlc_value_t val; - if( p_input->b_preparsing ) return; - /* Set up es_out */ es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, true ); i_es_out_mode = ES_OUT_MODE_AUTO; @@ -1140,12 +1140,11 @@ static void InitPrograms( input_thread_t * p_input ) static int Init( input_thread_t * p_input ) { vlc_meta_t *p_meta; - vlc_value_t val; int i, ret; - for( i = 0; i < p_input->p->input.p_item->i_options; i++ ) + for( i = 0; i < p_input->p->p_item->i_options; i++ ) { - if( !strncmp( p_input->p->input.p_item->ppsz_options[i], "meta-file", 9 ) ) + if( !strncmp( p_input->p->p_item->ppsz_options[i], "meta-file", 9 ) ) { msg_Dbg( p_input, "Input is a meta file: disabling unneeded options" ); var_SetString( p_input, "sout", "" ); @@ -1165,15 +1164,21 @@ static int Init( input_thread_t * p_input ) #endif /* Create es out */ - p_input->p->p_es_out = input_EsOutNew( p_input, p_input->p->i_rate ); + p_input->p->p_es_out_display = input_EsOutNew( p_input, p_input->p->i_rate ); + p_input->p->p_es_out = input_EsOutTimeshiftNew( p_input, p_input->p->p_es_out_display, p_input->p->i_rate ); es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, false ); es_out_Control( p_input->p->p_es_out, ES_OUT_SET_MODE, ES_OUT_MODE_NONE ); var_Create( p_input, "bit-rate", VLC_VAR_INTEGER ); var_Create( p_input, "sample-rate", VLC_VAR_INTEGER ); + /* */ + input_ChangeState( p_input, OPENING_S ); + input_SendEventCache( p_input, 0.0 ); + + /* */ if( InputSourceInit( p_input, &p_input->p->input, - p_input->p->input.p_item->psz_uri, NULL ) ) + p_input->p->p_item->psz_uri, NULL ) ) { goto error; } @@ -1182,26 +1187,22 @@ static int Init( input_thread_t * p_input ) /* Load master infos */ /* Init length */ - if( !demux_Control( p_input->p->input.p_demux, DEMUX_GET_LENGTH, - &val.i_time ) && val.i_time > 0 ) - { - var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL ); - UpdateItemLength( p_input, val.i_time ); - } - else + mtime_t i_length; + if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_LENGTH, + &i_length ) ) + i_length = 0; + if( i_length <= 0 ) + i_length = input_item_GetDuration( p_input->p->p_item ); + input_SendEventTimes( p_input, 0.0, 0, i_length ); + + if( !p_input->b_preparsing ) { - val.i_time = input_item_GetDuration( p_input->p->input.p_item ); - if( val.i_time > 0 ) - { /* fallback: gets length from metadata */ - var_Change( p_input, "length", VLC_VAR_SETVALUE, &val, NULL ); - UpdateItemLength( p_input, val.i_time ); - } + StartTitle( p_input ); + LoadSubtitles( p_input ); + LoadSlaves( p_input ); + InitPrograms( p_input ); } - StartTitle( p_input ); - - InitPrograms( p_input ); - if( !p_input->b_preparsing && p_input->p->p_sout ) { p_input->p->b_out_pace_control = (p_input->p->p_sout->i_out_pace_nocontrol > 0); @@ -1218,22 +1219,26 @@ static int Init( input_thread_t * p_input ) } p_meta = vlc_meta_New(); + if( p_meta ) + { + /* Get meta data from users */ + InputMetaUser( p_input, p_meta ); - /* Get meta data from users */ - InputMetaUser( p_input, p_meta ); - - /* Get meta data from master input */ - DemuxMeta( p_input, p_meta, p_input->p->input.p_demux ); + /* Get meta data from master input */ + InputSourceMeta( p_input, &p_input->p->input, p_meta ); - /* Access_file does not give any meta, and there are no slave */ - AccessMeta( p_input, p_meta ); + /* And from slave */ + for( int i = 0; i < p_input->p->i_slave; i++ ) + InputSourceMeta( p_input, p_input->p->slave[i], p_meta ); - InputUpdateMeta( p_input, p_meta ); + /* */ + InputUpdateMeta( p_input, p_meta ); + } if( !p_input->b_preparsing ) { msg_Dbg( p_input, "`%s' successfully opened", - p_input->p->input.p_item->psz_uri ); + p_input->p->p_item->psz_uri ); } @@ -1246,7 +1251,9 @@ error: input_ChangeState( p_input, ERROR_S ); if( p_input->p->p_es_out ) - input_EsOutDelete( p_input->p->p_es_out ); + es_out_Delete( p_input->p->p_es_out ); + if( p_input->p->p_es_out_display ) + es_out_Delete( p_input->p->p_es_out_display ); #ifdef ENABLE_SOUT if( p_input->p->p_sout ) { @@ -1287,6 +1294,7 @@ error: p_input->p->input.p_stream = NULL; p_input->p->input.p_access = NULL; p_input->p->p_es_out = NULL; + p_input->p->p_es_out_display = NULL; p_input->p->p_sout = NULL; return VLC_EGENERIC; @@ -1321,6 +1329,10 @@ static void End( input_thread_t * p_input ) /* Clean control variables */ input_ControlVarStop( p_input ); + /* Stop es out activity */ + es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ACTIVE, false ); + es_out_Control( p_input->p->p_es_out, ES_OUT_SET_MODE, ES_OUT_MODE_NONE ); + /* Clean up master */ InputSourceClean( &p_input->p->input ); @@ -1334,7 +1346,9 @@ static void End( input_thread_t * p_input ) /* Unload all modules */ if( p_input->p->p_es_out ) - input_EsOutDelete( p_input->p->p_es_out ); + es_out_Delete( p_input->p->p_es_out ); + if( p_input->p->p_es_out_display ) + es_out_Delete( p_input->p->p_es_out_display ); if( !p_input->b_preparsing ) { @@ -1344,11 +1358,12 @@ static void End( input_thread_t * p_input ) libvlc_priv_t *p_private = libvlc_priv( p_input->p_libvlc ); /* make sure we are up to date */ - stats_ComputeInputStats( p_input, p_input->p->input.p_item->p_stats ); + stats_ComputeInputStats( p_input, p_input->p->p_item->p_stats ); if( p_private->p_stats_computer == p_input ) { stats_ComputeGlobalStats( p_input->p_libvlc, p_input->p_libvlc->p_stats ); + /* FIXME how can it be thread safe ? */ p_private->p_stats_computer = NULL; } CL_CO( read_bytes ); @@ -1385,12 +1400,43 @@ static void End( input_thread_t * p_input ) } /* Tell we're dead */ - p_input->b_dead = true; + input_SendEventDead( p_input ); } /***************************************************************************** * Control *****************************************************************************/ +void input_ControlPush( input_thread_t *p_input, + int i_type, vlc_value_t *p_val ) +{ + vlc_mutex_lock( &p_input->p->lock_control ); + if( i_type == INPUT_CONTROL_SET_DIE ) + { + /* Special case, empty the control */ + p_input->p->i_control = 1; + p_input->p->control[0].i_type = i_type; + memset( &p_input->p->control[0].val, 0, sizeof( vlc_value_t ) ); + } + else if( p_input->p->i_control >= INPUT_CONTROL_FIFO_SIZE ) + { + msg_Err( p_input, "input control fifo overflow, trashing type=%d", + i_type ); + } + else + { + p_input->p->control[p_input->p->i_control].i_type = i_type; + if( p_val ) + p_input->p->control[p_input->p->i_control].val = *p_val; + else + memset( &p_input->p->control[p_input->p->i_control].val, 0, + sizeof( vlc_value_t ) ); + + p_input->p->i_control++; + } + vlc_cond_signal( &p_input->p->wait_control ); + vlc_mutex_unlock( &p_input->p->lock_control ); +} + static inline int ControlPopNoLock( input_thread_t *p_input, int *pi_type, vlc_value_t *p_val, mtime_t i_deadline ) @@ -1470,11 +1516,79 @@ static void ControlReduce( input_thread_t *p_input ) } } } +/* Pause input */ +static void ControlPause( input_thread_t *p_input, mtime_t i_control_date ) +{ + int i_ret = VLC_SUCCESS; + int i_state = PAUSE_S; + + if( p_input->p->b_can_pause ) + { + if( p_input->p->input.p_access ) + i_ret = access_Control( p_input->p->input.p_access, + ACCESS_SET_PAUSE_STATE, true ); + else + i_ret = demux_Control( p_input->p->input.p_demux, + DEMUX_SET_PAUSE_STATE, true ); + + if( i_ret ) + { + msg_Warn( p_input, "cannot set pause state" ); + i_state = p_input->i_state; + } + } + + /* */ + if( !i_ret ) + { + i_ret = es_out_SetPauseState( p_input->p->p_es_out, p_input->p->b_can_pause, true, i_control_date ); + if( i_ret ) + { + msg_Warn( p_input, "cannot set pause state at es_out level" ); + i_state = p_input->i_state; + } + } + + /* Switch to new state */ + input_ChangeState( p_input, i_state ); + +} + +static void ControlUnpause( input_thread_t *p_input, mtime_t i_control_date ) +{ + int i_ret = VLC_SUCCESS; + + if( p_input->p->b_can_pause ) + { + if( p_input->p->input.p_access ) + i_ret = access_Control( p_input->p->input.p_access, + ACCESS_SET_PAUSE_STATE, false ); + else + i_ret = demux_Control( p_input->p->input.p_demux, + DEMUX_SET_PAUSE_STATE, false ); + if( i_ret ) + { + /* FIXME What to do ? */ + msg_Warn( p_input, "cannot unset pause -> EOF" ); + vlc_mutex_unlock( &p_input->p->lock_control ); + input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL ); + vlc_mutex_lock( &p_input->p->lock_control ); + } + } + + /* Switch to play */ + input_ChangeState( p_input, PLAYING_S ); + + /* */ + if( !i_ret ) + es_out_SetPauseState( p_input->p->p_es_out, false, false, i_control_date ); +} static bool Control( input_thread_t *p_input, int i_type, vlc_value_t val ) { const mtime_t i_control_date = mdate(); + /* FIXME b_force_update is abused, it should be carefully checked */ bool b_force_update = false; if( !p_input ) @@ -1499,21 +1613,15 @@ static bool Control( input_thread_t *p_input, int i_type, msg_Err( p_input, "INPUT_CONTROL_SET_POSITION(_OFFSET) ignored while recording" ); break; } - if( i_type == INPUT_CONTROL_SET_POSITION ) - { - f_pos = val.f_float; - } - else - { - /* Should not fail */ - demux_Control( p_input->p->input.p_demux, - DEMUX_GET_POSITION, &f_pos ); - f_pos += val.f_float; - } - if( f_pos < 0.0 ) f_pos = 0.0; - if( f_pos > 1.0 ) f_pos = 1.0; + f_pos = val.f_float; + if( i_type != INPUT_CONTROL_SET_POSITION ) + f_pos += var_GetFloat( p_input, "position" ); + if( f_pos < 0.0 ) + f_pos = 0.0; + else if( f_pos > 1.0 ) + f_pos = 1.0; /* Reset the decoders states and clock sync (before calling the demuxer */ - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); if( demux_Control( p_input->p->input.p_demux, DEMUX_SET_POSITION, f_pos ) ) { @@ -1524,6 +1632,7 @@ static bool Control( input_thread_t *p_input, int i_type, { if( p_input->p->i_slave > 0 ) SlaveSeek( p_input ); + p_input->p->input.b_eof = false; b_force_update = true; } @@ -1542,21 +1651,15 @@ static bool Control( input_thread_t *p_input, int i_type, break; } - if( i_type == INPUT_CONTROL_SET_TIME ) - { - i_time = val.i_time; - } - else - { - /* Should not fail */ - demux_Control( p_input->p->input.p_demux, - DEMUX_GET_TIME, &i_time ); - i_time += val.i_time; - } - if( i_time < 0 ) i_time = 0; + i_time = val.i_time; + if( i_type != INPUT_CONTROL_SET_TIME ) + i_time += var_GetTime( p_input, "time" ); + + if( i_time < 0 ) + i_time = 0; /* Reset the decoders states and clock sync (before calling the demuxer */ - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); i_ret = demux_Control( p_input->p->input.p_demux, DEMUX_SET_TIME, i_time ); @@ -1583,6 +1686,7 @@ static bool Control( input_thread_t *p_input, int i_type, { if( p_input->p->i_slave > 0 ) SlaveSeek( p_input ); + p_input->p->input.b_eof = false; b_force_update = true; } @@ -1593,68 +1697,23 @@ static bool Control( input_thread_t *p_input, int i_type, if( ( val.i_int == PLAYING_S && p_input->i_state == PAUSE_S ) || ( val.i_int == PAUSE_S && p_input->i_state == PAUSE_S ) ) { - int i_ret; - if( p_input->p->input.p_access ) - i_ret = access_Control( p_input->p->input.p_access, - ACCESS_SET_PAUSE_STATE, false ); - else - i_ret = demux_Control( p_input->p->input.p_demux, - DEMUX_SET_PAUSE_STATE, false ); - - if( i_ret ) - { - /* FIXME What to do ? */ - msg_Warn( p_input, "cannot unset pause -> EOF" ); - vlc_mutex_unlock( &p_input->p->lock_control ); - input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL ); - vlc_mutex_lock( &p_input->p->lock_control ); - } + ControlUnpause( p_input, i_control_date ); b_force_update = true; - - /* Switch to play */ - input_ChangeStateWithVarCallback( p_input, PLAYING_S, false ); - - /* */ - if( !i_ret ) - input_EsOutChangePause( p_input->p->p_es_out, false, i_control_date ); } - else if( val.i_int == PAUSE_S && p_input->i_state == PLAYING_S && - p_input->p->b_can_pause ) + else if( val.i_int == PAUSE_S && p_input->i_state == PLAYING_S /* && + p_input->p->b_can_pause */ ) { - int i_ret, state; - if( p_input->p->input.p_access ) - i_ret = access_Control( p_input->p->input.p_access, - ACCESS_SET_PAUSE_STATE, true ); - else - i_ret = demux_Control( p_input->p->input.p_demux, - DEMUX_SET_PAUSE_STATE, true ); + ControlPause( p_input, i_control_date ); b_force_update = true; - - if( i_ret ) - { - msg_Warn( p_input, "cannot set pause state" ); - state = p_input->i_state; - } - else - { - state = PAUSE_S; - } - - /* Switch to new state */ - input_ChangeStateWithVarCallback( p_input, state, false ); - - /* */ - if( !i_ret ) - input_EsOutChangePause( p_input->p->p_es_out, true, i_control_date ); } - else if( val.i_int == PAUSE_S && !p_input->p->b_can_pause ) + else if( val.i_int == PAUSE_S && !p_input->p->b_can_pause && 0 ) { b_force_update = true; /* Correct "state" value */ - input_ChangeStateWithVarCallback( p_input, p_input->i_state, false ); + input_ChangeState( p_input, p_input->i_state ); } else if( val.i_int != PLAYING_S && val.i_int != PAUSE_S ) { @@ -1667,10 +1726,13 @@ static bool Control( input_thread_t *p_input, int i_type, case INPUT_CONTROL_SET_RATE_FASTER: { int i_rate; + int i_rate_sign; + /* Get rate and direction */ if( i_type == INPUT_CONTROL_SET_RATE ) { - i_rate = val.i_int; + i_rate = abs( val.i_int ); + i_rate_sign = val.i_int < 0 ? -1 : 1; } else { @@ -1684,18 +1746,21 @@ static bool Control( input_thread_t *p_input, int i_type, int i_idx; int i; + i_rate_sign = p_input->p->i_rate < 0 ? -1 : 1; + i_error = INT_MAX; i_idx = -1; for( i = 0; ppi_factor[i][0] != 0; i++ ) { const int i_test_r = INPUT_RATE_DEFAULT * ppi_factor[i][0] / ppi_factor[i][1]; - const int i_test_e = abs(p_input->p->i_rate - i_test_r); + const int i_test_e = abs( abs( p_input->p->i_rate ) - i_test_r ); if( i_test_e < i_error ) { i_idx = i; i_error = i_test_e; } } + assert( i_idx >= 0 && ppi_factor[i_idx][0] != 0 ); if( i_type == INPUT_CONTROL_SET_RATE_SLOWER ) @@ -1715,6 +1780,7 @@ static bool Control( input_thread_t *p_input, int i_type, } } + /* Check rate bound */ if( i_rate < INPUT_RATE_MIN ) { msg_Dbg( p_input, "cannot set rate faster" ); @@ -1725,8 +1791,24 @@ static bool Control( input_thread_t *p_input, int i_type, msg_Dbg( p_input, "cannot set rate slower" ); i_rate = INPUT_RATE_MAX; } + + /* Apply direction */ + if( i_rate_sign < 0 ) + { + if( p_input->p->input.b_rescale_ts ) + { + msg_Dbg( p_input, "cannot set negative rate" ); + i_rate = p_input->p->i_rate; + assert( i_rate > 0 ); + } + else + { + i_rate *= i_rate_sign; + } + } + if( i_rate != INPUT_RATE_DEFAULT && - ( ( !p_input->b_can_pace_control && !p_input->p->b_can_rate_control ) || + ( ( !p_input->p->b_can_rate_control && !p_input->p->input.b_rescale_ts ) || ( p_input->p->p_sout && !p_input->p->b_out_pace_control ) ) ) { msg_Dbg( p_input, "cannot change rate" ); @@ -1737,10 +1819,17 @@ static bool Control( input_thread_t *p_input, int i_type, { int i_ret; if( p_input->p->input.p_access ) + { i_ret = VLC_EGENERIC; + } else + { + if( !p_input->p->input.b_rescale_ts ) + es_out_Control( p_input->p->p_es_out, ES_OUT_RESET_PCR ); + i_ret = demux_Control( p_input->p->input.p_demux, DEMUX_SET_RATE, &i_rate ); + } if( i_ret ) { msg_Warn( p_input, "ACCESS/DEMUX_SET_RATE failed" ); @@ -1751,15 +1840,14 @@ static bool Control( input_thread_t *p_input, int i_type, /* */ if( i_rate != p_input->p->i_rate ) { - val.i_int = i_rate; - var_Change( p_input, "rate", VLC_VAR_SETVALUE, &val, NULL ); - var_SetBool( p_input, "rate-change", true ); + p_input->p->i_rate = i_rate; + input_SendEventRate( p_input, i_rate ); - p_input->p->i_rate = i_rate; - - /* FIXME do we need a RESET_PCR when !p_input->p->input.b_rescale_ts ? */ if( p_input->p->input.b_rescale_ts ) - input_EsOutChangeRate( p_input->p->p_es_out, i_rate ); + { + const int i_rate_source = (p_input->b_can_pace_control || p_input->p->b_can_rate_control ) ? i_rate : INPUT_RATE_DEFAULT; + es_out_SetRate( p_input->p->p_es_out, i_rate_source, i_rate ); + } b_force_update = true; } @@ -1777,25 +1865,21 @@ static bool Control( input_thread_t *p_input, int i_type, case INPUT_CONTROL_SET_ES: /* No need to force update, es_out does it if needed */ - es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES, - input_EsOutGetFromID( p_input->p->p_es_out, val.i_int ) ); + es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_BY_ID, val.i_int ); break; case INPUT_CONTROL_RESTART_ES: - es_out_Control( p_input->p->p_es_out, ES_OUT_RESTART_ES, - input_EsOutGetFromID( p_input->p->p_es_out, val.i_int ) ); + es_out_Control( p_input->p->p_es_out_display, ES_OUT_RESTART_ES_BY_ID, val.i_int ); break; case INPUT_CONTROL_SET_AUDIO_DELAY: - input_EsOutSetDelay( p_input->p->p_es_out, - AUDIO_ES, val.i_time ); - var_Change( p_input, "audio-delay", VLC_VAR_SETVALUE, &val, NULL ); + if( !es_out_SetDelay( p_input->p->p_es_out_display, AUDIO_ES, val.i_time ) ) + input_SendEventAudioDelay( p_input, val.i_time ); break; case INPUT_CONTROL_SET_SPU_DELAY: - input_EsOutSetDelay( p_input->p->p_es_out, - SPU_ES, val.i_time ); - var_Change( p_input, "spu-delay", VLC_VAR_SETVALUE, &val, NULL ); + if( !es_out_SetDelay( p_input->p->p_es_out_display, SPU_ES, val.i_time ) ) + input_SendEventSubtitleDelay( p_input, val.i_time ); break; case INPUT_CONTROL_SET_TITLE: @@ -1823,7 +1907,7 @@ static bool Control( input_thread_t *p_input, int i_type, if( i_title >= 0 && i_title < p_input->p->input.i_title ) { - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); demux_Control( p_demux, DEMUX_SET_TITLE, i_title ); input_ControlVarTitle( p_input, i_title ); @@ -1843,10 +1927,10 @@ static bool Control( input_thread_t *p_input, int i_type, if( i_title >= 0 && i_title < p_input->p->input.i_title ) { - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); - access_Control( p_access, ACCESS_SET_TITLE, i_title ); - stream_AccessReset( p_input->p->input.p_stream ); + stream_Control( p_input->p->input.p_stream, STREAM_CONTROL_ACCESS, + ACCESS_SET_TITLE, i_title ); } } break; @@ -1871,9 +1955,8 @@ static bool Control( input_thread_t *p_input, int i_type, { i_seekpoint = p_demux->info.i_seekpoint; i_seekpoint_time = p_input->p->input.title[p_demux->info.i_title]->seekpoint[i_seekpoint]->i_time_offset; - if( i_seekpoint_time >= 0 && - !demux_Control( p_demux, - DEMUX_GET_TIME, &i_input_time ) ) + i_input_time = var_GetTime( p_input, "time" ); + if( i_seekpoint_time >= 0 && i_input_time >= 0 ) { if( i_input_time < i_seekpoint_time + 3000000 ) i_seekpoint--; @@ -1890,14 +1973,13 @@ static bool Control( input_thread_t *p_input, int i_type, p_input->p->input.title[p_demux->info.i_title]->i_seekpoint ) { - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); demux_Control( p_demux, DEMUX_SET_SEEKPOINT, i_seekpoint ); } } else if( p_input->p->input.i_title > 0 ) { - demux_t *p_demux = p_input->p->input.p_demux; access_t *p_access = p_input->p->input.p_access; int i_seekpoint; int64_t i_input_time; @@ -1907,9 +1989,8 @@ static bool Control( input_thread_t *p_input, int i_type, { i_seekpoint = p_access->info.i_seekpoint; i_seekpoint_time = p_input->p->input.title[p_access->info.i_title]->seekpoint[i_seekpoint]->i_time_offset; - if( i_seekpoint_time >= 0 && - demux_Control( p_demux, - DEMUX_GET_TIME, &i_input_time ) ) + i_input_time = var_GetTime( p_input, "time" ); + if( i_seekpoint_time >= 0 && i_input_time >= 0 ) { if( i_input_time < i_seekpoint_time + 3000000 ) i_seekpoint--; @@ -1925,11 +2006,10 @@ static bool Control( input_thread_t *p_input, int i_type, if( i_seekpoint >= 0 && i_seekpoint < p_input->p->input.title[p_access->info.i_title]->i_seekpoint ) { - input_EsOutChangePosition( p_input->p->p_es_out ); + es_out_SetTime( p_input->p->p_es_out, -1 ); - access_Control( p_access, ACCESS_SET_SEEKPOINT, - i_seekpoint ); - stream_AccessReset( p_input->p->input.p_stream ); + stream_Control( p_input->p->input.p_stream, STREAM_CONTROL_ACCESS, + ACCESS_SET_SEEKPOINT, i_seekpoint ); } } break; @@ -1947,7 +2027,7 @@ static bool Control( input_thread_t *p_input, int i_type, { input_source_t *slave = InputSourceNew( p_input ); - if( !InputSourceInit( p_input, slave, val.psz_string, NULL ) ) + if( slave && !InputSourceInit( p_input, slave, val.psz_string, NULL ) ) { vlc_meta_t *p_meta; int64_t i_time; @@ -1976,10 +2056,12 @@ static bool Control( input_thread_t *p_input, int i_type, /* Get meta (access and demux) */ p_meta = vlc_meta_New(); - access_Control( slave->p_access, ACCESS_GET_META, - p_meta ); - demux_Control( slave->p_demux, DEMUX_GET_META, p_meta ); - InputUpdateMeta( p_input, p_meta ); + if( p_meta ) + { + access_Control( slave->p_access, ACCESS_GET_META, p_meta ); + demux_Control( slave->p_demux, DEMUX_GET_META, p_meta ); + InputUpdateMeta( p_input, p_meta ); + } TAB_APPEND( p_input->p->i_slave, p_input->p->slave, slave ); } @@ -2005,110 +2087,201 @@ static bool Control( input_thread_t *p_input, int i_type, } else { - if( input_EsOutSetRecord( p_input->p->p_es_out, val.b_bool ) ) + if( es_out_SetRecordState( p_input->p->p_es_out_display, val.b_bool ) ) val.b_bool = false; } p_input->p->b_recording = val.b_bool; - var_Change( p_input, "record", VLC_VAR_SETVALUE, &val, NULL ); + input_SendEventRecord( p_input, val.b_bool ); b_force_update = true; } break; - case INPUT_CONTROL_SET_BOOKMARK: - default: - msg_Err( p_input, "not yet implemented" ); - break; + case INPUT_CONTROL_SET_FRAME_NEXT: + if( p_input->i_state == PAUSE_S ) + { + es_out_SetFrameNext( p_input->p->p_es_out ); + } + else if( p_input->i_state == PLAYING_S ) + { + ControlPause( p_input, i_control_date ); + } + else + { + msg_Err( p_input, "invalid state for frame next" ); + } + b_force_update = true; + break; + + case INPUT_CONTROL_SET_BOOKMARK: + { + seekpoint_t bookmark; + + bookmark.i_time_offset = -1; + bookmark.i_byte_offset = -1; + + vlc_mutex_lock( &p_input->p->p_item->lock ); + if( val.i_int >= 0 && val.i_int < p_input->p->i_bookmark ) + { + const seekpoint_t *p_bookmark = p_input->p->pp_bookmark[val.i_int]; + bookmark.i_time_offset = p_bookmark->i_time_offset; + bookmark.i_byte_offset = p_bookmark->i_byte_offset; + } + vlc_mutex_unlock( &p_input->p->p_item->lock ); + + if( bookmark.i_time_offset < 0 && bookmark.i_byte_offset < 0 ) + { + msg_Err( p_input, "invalid bookmark %d", val.i_int ); + break; + } + + if( bookmark.i_time_offset >= 0 ) + { + val.i_time = bookmark.i_time_offset; + b_force_update = Control( p_input, INPUT_CONTROL_SET_TIME, val ); + } + else if( bookmark.i_byte_offset >= 0 && + p_input->p->input.p_stream ) + { + const int64_t i_size = stream_Size( p_input->p->input.p_stream ); + if( i_size > 0 && bookmark.i_byte_offset <= i_size ) + { + val.f_float = (double)bookmark.i_byte_offset / i_size; + b_force_update = Control( p_input, INPUT_CONTROL_SET_POSITION, val ); + } + } + break; + } + + default: + msg_Err( p_input, "not yet implemented" ); + break; } return b_force_update; } /***************************************************************************** - * UpdateFromDemux: + * UpdateTitleSeekpoint + *****************************************************************************/ +static int UpdateTitleSeekpoint( input_thread_t *p_input, + int i_title, int i_seekpoint ) +{ + int i_title_end = p_input->p->input.i_title_end - + p_input->p->input.i_title_offset; + int i_seekpoint_end = p_input->p->input.i_seekpoint_end - + p_input->p->input.i_seekpoint_offset; + + if( i_title_end >= 0 && i_seekpoint_end >= 0 ) + { + if( i_title > i_title_end || + ( i_title == i_title_end && i_seekpoint > i_seekpoint_end ) ) + return 0; + } + else if( i_seekpoint_end >= 0 ) + { + if( i_seekpoint > i_seekpoint_end ) + return 0; + } + else if( i_title_end >= 0 ) + { + if( i_title > i_title_end ) + return 0; + } + return 1; +} +/***************************************************************************** + * Update*FromDemux: *****************************************************************************/ -static int UpdateFromDemux( input_thread_t *p_input ) +static int UpdateTitleSeekpointFromDemux( input_thread_t *p_input ) { demux_t *p_demux = p_input->p->input.p_demux; - vlc_value_t v; + /* TODO event-like */ if( p_demux->info.i_update & INPUT_UPDATE_TITLE ) { - v.i_int = p_demux->info.i_title; - var_Change( p_input, "title", VLC_VAR_SETVALUE, &v, NULL ); - - input_ControlVarTitle( p_input, p_demux->info.i_title ); + input_SendEventTitle( p_input, p_demux->info.i_title ); p_demux->info.i_update &= ~INPUT_UPDATE_TITLE; } if( p_demux->info.i_update & INPUT_UPDATE_SEEKPOINT ) { - v.i_int = p_demux->info.i_seekpoint; - var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &v, NULL); + input_SendEventSeekpoint( p_input, + p_demux->info.i_title, p_demux->info.i_seekpoint ); p_demux->info.i_update &= ~INPUT_UPDATE_SEEKPOINT; } - p_demux->info.i_update &= ~INPUT_UPDATE_SIZE; /* Hmmm only works with master input */ if( p_input->p->input.p_demux == p_demux ) - { - int i_title_end = p_input->p->input.i_title_end - - p_input->p->input.i_title_offset; - int i_seekpoint_end = p_input->p->input.i_seekpoint_end - - p_input->p->input.i_seekpoint_offset; + return UpdateTitleSeekpoint( p_input, + p_demux->info.i_title, + p_demux->info.i_seekpoint ); + return 1; +} - if( i_title_end >= 0 && i_seekpoint_end >= 0 ) - { - if( p_demux->info.i_title > i_title_end || - ( p_demux->info.i_title == i_title_end && - p_demux->info.i_seekpoint > i_seekpoint_end ) ) return 0; - } - else if( i_seekpoint_end >=0 ) - { - if( p_demux->info.i_seekpoint > i_seekpoint_end ) return 0; - } - else if( i_title_end >= 0 ) +static void UpdateGenericFromDemux( input_thread_t *p_input ) +{ + demux_t *p_demux = p_input->p->input.p_demux; + + if( p_demux->info.i_update & INPUT_UPDATE_META ) + { + vlc_meta_t *p_meta = vlc_meta_New(); + if( p_meta ) { - if( p_demux->info.i_title > i_title_end ) return 0; + demux_Control( p_input->p->input.p_demux, DEMUX_GET_META, p_meta ); + InputUpdateMeta( p_input, p_meta ); } + p_demux->info.i_update &= ~INPUT_UPDATE_META; } - return 1; + p_demux->info.i_update &= ~INPUT_UPDATE_SIZE; } + /***************************************************************************** - * UpdateFromAccess: + * Update*FromAccess: *****************************************************************************/ -static int UpdateFromAccess( input_thread_t *p_input ) +static int UpdateTitleSeekpointFromAccess( input_thread_t *p_input ) { access_t *p_access = p_input->p->input.p_access; - vlc_value_t v; if( p_access->info.i_update & INPUT_UPDATE_TITLE ) { - v.i_int = p_access->info.i_title; - var_Change( p_input, "title", VLC_VAR_SETVALUE, &v, NULL ); - - input_ControlVarTitle( p_input, p_access->info.i_title ); + input_SendEventTitle( p_input, p_access->info.i_title ); - stream_AccessUpdate( p_input->p->input.p_stream ); + stream_Control( p_input->p->input.p_stream, STREAM_UPDATE_SIZE ); p_access->info.i_update &= ~INPUT_UPDATE_TITLE; } if( p_access->info.i_update & INPUT_UPDATE_SEEKPOINT ) { - v.i_int = p_access->info.i_seekpoint; - var_Change( p_input, "chapter", VLC_VAR_SETVALUE, &v, NULL); + input_SendEventSeekpoint( p_input, + p_access->info.i_title, p_access->info.i_seekpoint ); + p_access->info.i_update &= ~INPUT_UPDATE_SEEKPOINT; } + /* Hmmm only works with master input */ + if( p_input->p->input.p_access == p_access ) + return UpdateTitleSeekpoint( p_input, + p_access->info.i_title, + p_access->info.i_seekpoint ); + return 1; +} +static void UpdateGenericFromAccess( input_thread_t *p_input ) +{ + access_t *p_access = p_input->p->input.p_access; + if( p_access->info.i_update & INPUT_UPDATE_META ) { /* TODO maybe multi - access ? */ vlc_meta_t *p_meta = vlc_meta_New(); - access_Control( p_input->p->input.p_access,ACCESS_GET_META, p_meta ); - InputUpdateMeta( p_input, p_meta ); + if( p_meta ) + { + access_Control( p_input->p->input.p_access, ACCESS_GET_META, p_meta ); + InputUpdateMeta( p_input, p_meta ); + } p_access->info.i_update &= ~INPUT_UPDATE_META; } if( p_access->info.i_update & INPUT_UPDATE_SIGNAL ) @@ -2119,47 +2292,12 @@ static int UpdateFromAccess( input_thread_t *p_input ) if( access_Control( p_access, ACCESS_GET_SIGNAL, &f_quality, &f_strength ) ) f_quality = f_strength = -1; - var_SetFloat( p_input, "signal-quality", f_quality ); - var_SetFloat( p_input, "signal-strength", f_strength ); + input_SendEventSignal( p_input, f_quality, f_strength ); p_access->info.i_update &= ~INPUT_UPDATE_SIGNAL; } p_access->info.i_update &= ~INPUT_UPDATE_SIZE; - - /* Hmmm only works with master input */ - if( p_input->p->input.p_access == p_access ) - { - int i_title_end = p_input->p->input.i_title_end - - p_input->p->input.i_title_offset; - int i_seekpoint_end = p_input->p->input.i_seekpoint_end - - p_input->p->input.i_seekpoint_offset; - - if( i_title_end >= 0 && i_seekpoint_end >=0 ) - { - if( p_access->info.i_title > i_title_end || - ( p_access->info.i_title == i_title_end && - p_access->info.i_seekpoint > i_seekpoint_end ) ) return 0; - } - else if( i_seekpoint_end >=0 ) - { - if( p_access->info.i_seekpoint > i_seekpoint_end ) return 0; - } - else if( i_title_end >= 0 ) - { - if( p_access->info.i_title > i_title_end ) return 0; - } - } - - return 1; -} - -/***************************************************************************** - * UpdateItemLength: - *****************************************************************************/ -static void UpdateItemLength( input_thread_t *p_input, int64_t i_length ) -{ - input_item_SetDuration( p_input->p->input.p_item, (mtime_t) i_length ); } /***************************************************************************** @@ -2168,10 +2306,8 @@ static void UpdateItemLength( input_thread_t *p_input, int64_t i_length ) static input_source_t *InputSourceNew( input_thread_t *p_input ) { VLC_UNUSED(p_input); - input_source_t *in = malloc( sizeof( input_source_t ) ); - if( in ) - memset( in, 0, sizeof( input_source_t ) ); - return in; + + return calloc( 1, sizeof( input_source_t ) ); } /***************************************************************************** @@ -2181,22 +2317,15 @@ static int InputSourceInit( input_thread_t *p_input, input_source_t *in, const char *psz_mrl, const char *psz_forced_demux ) { - const bool b_master = in == &p_input->p->input; - char psz_dup[strlen(psz_mrl) + 1]; const char *psz_access; const char *psz_demux; char *psz_path; - char *psz_tmp; - char *psz; vlc_value_t val; double f_fps; strcpy( psz_dup, psz_mrl ); - if( !in ) return VLC_EGENERIC; - if( !p_input ) return VLC_EGENERIC; - /* Split uri */ input_SplitMRL( &psz_access, &psz_demux, &psz_path, psz_dup ); @@ -2287,21 +2416,20 @@ static int InputSourceInit( input_thread_t *p_input, if( demux_Control( in->p_demux, DEMUX_CAN_PAUSE, &in->b_can_pause ) ) in->b_can_pause = false; - var_SetBool( p_input, "can-pause", in->b_can_pause ); + var_SetBool( p_input, "can-pause", in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/ + var_SetBool( p_input, "can-rate", !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/ + var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control ); int ret = demux_Control( in->p_demux, DEMUX_CAN_SEEK, &val.b_bool ); if( ret != VLC_SUCCESS ) val.b_bool = false; - var_Set( p_input, "seekable", val ); + var_Set( p_input, "can-seek", val ); } else { int64_t i_pts_delay; - if( b_master ) - input_ChangeState( p_input, OPENING_S ); - /* Now try a real access */ in->p_access = access_New( p_input, psz_access, psz_demux, psz_path ); @@ -2327,28 +2455,6 @@ static int InputSourceInit( input_thread_t *p_input, goto error; } - /* */ - psz_tmp = psz = var_GetNonEmptyString( p_input, "access-filter" ); - while( psz && *psz ) - { - access_t *p_access = in->p_access; - char *end = strchr( psz, ':' ); - - if( end ) - *end++ = '\0'; - - in->p_access = access_FilterNew( in->p_access, psz ); - if( in->p_access == NULL ) - { - in->p_access = p_access; - msg_Warn( p_input, "failed to insert access filter %s", - psz ); - } - - psz = end; - } - free( psz_tmp ); - /* Get infos from access */ if( !p_input->b_preparsing ) { @@ -2371,32 +2477,64 @@ static int InputSourceInit( input_thread_t *p_input, access_Control( in->p_access, ACCESS_CAN_PAUSE, &in->b_can_pause ); - var_SetBool( p_input, "can-pause", in->b_can_pause ); + var_SetBool( p_input, "can-pause", in->b_can_pause || !in->b_can_pace_control ); /* XXX temporary because of es_out_timeshift*/ + var_SetBool( p_input, "can-rate", !in->b_can_pace_control || in->b_can_rate_control ); /* XXX temporary because of es_out_timeshift*/ + var_SetBool( p_input, "can-rewind", !in->b_rescale_ts && !in->b_can_pace_control ); + access_Control( in->p_access, ACCESS_CAN_SEEK, &val.b_bool ); - var_Set( p_input, "seekable", val ); + var_Set( p_input, "can-seek", val ); } - if( b_master ) - input_ChangeState( p_input, BUFFERING_S ); + /* */ + int i_input_list; + char **ppsz_input_list; + + TAB_INIT( i_input_list, ppsz_input_list ); + + /* On master stream only, use input-list */ + if( &p_input->p->input == in ) + { + char *psz_list; + char *psz_parser; + + psz_list = + psz_parser = var_CreateGetNonEmptyString( p_input, "input-list" ); + + while( psz_parser && *psz_parser ) + { + char *p = strchr( psz_parser, ',' ); + if( p ) + *p++ = '\0'; + + if( *psz_parser ) + { + char *psz_name = strdup( psz_parser ); + if( psz_name ) + TAB_APPEND( i_input_list, ppsz_input_list, psz_name ); + } + psz_parser = p; + } + free( psz_list ); + } /* Autodetect extra files if none specified */ - char *psz_input_list = var_CreateGetNonEmptyString( p_input, "input-list" ); - if( !psz_input_list ) + if( i_input_list <= 0 ) { - char *psz_extra_files = InputGetExtraFiles( p_input, psz_access, psz_path ); - if( psz_extra_files ) - var_SetString( p_input, "input-list", psz_extra_files ); - free( psz_extra_files ); + InputGetExtraFiles( p_input, &i_input_list, &ppsz_input_list, + psz_access, psz_path ); } + if( i_input_list > 0 ) + TAB_APPEND( i_input_list, ppsz_input_list, NULL ); /* Create the stream_t */ - in->p_stream = stream_AccessNew( in->p_access, p_input->b_preparsing ); - - /* Restor old value */ - if( !psz_input_list ) - var_SetString( p_input, "input-list", "" ); - free( psz_input_list ); + in->p_stream = stream_AccessNew( in->p_access, ppsz_input_list ); + if( ppsz_input_list ) + { + for( int i = 0; ppsz_input_list[i] != NULL; i++ ) + free( ppsz_input_list[i] ); + TAB_CLEAN( i_input_list, ppsz_input_list ); + } if( in->p_stream == NULL ) { @@ -2404,6 +2542,14 @@ static int InputSourceInit( input_thread_t *p_input, goto error; } + /* Add stream filters */ + char *psz_stream_filter = var_GetNonEmptyString( p_input, + "stream-filter" ); + in->p_stream = stream_FilterChainNew( in->p_stream, + psz_stream_filter, + var_GetBool( p_input, "input-record-native" ) ); + free( psz_stream_filter ); + /* Open a demuxer */ if( *psz_demux == '\0' && *in->p_access->psz_demux ) { @@ -2462,7 +2608,7 @@ static int InputSourceInit( input_thread_t *p_input, if( demux_Control( in->p_demux, DEMUX_CAN_RECORD, &in->b_can_stream_record ) ) in->b_can_stream_record = false; #ifdef ENABLE_SOUT - if( !var_CreateGetBool( p_input, "input-record-native" ) ) + if( !var_GetBool( p_input, "input-record-native" ) ) in->b_can_stream_record = false; var_SetBool( p_input, "can-record", true ); #else @@ -2478,17 +2624,17 @@ static int InputSourceInit( input_thread_t *p_input, if( !demux_Control( in->p_demux, DEMUX_GET_ATTACHMENTS, &attachment, &i_attachment ) ) { - vlc_mutex_lock( &p_input->p->input.p_item->lock ); + vlc_mutex_lock( &p_input->p->p_item->lock ); AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, i_attachment, attachment ); - vlc_mutex_unlock( &p_input->p->input.p_item->lock ); + vlc_mutex_unlock( &p_input->p->p_item->lock ); } } - if( !demux_Control( in->p_demux, DEMUX_GET_FPS, &f_fps ) ) + if( !demux_Control( in->p_demux, DEMUX_GET_FPS, &f_fps ) && f_fps > 0.0 ) { - vlc_mutex_lock( &p_input->p->input.p_item->lock ); - in->f_fps = f_fps; - vlc_mutex_unlock( &p_input->p->input.p_item->lock ); + vlc_mutex_lock( &p_input->p->p_item->lock ); + p_input->p->f_fps = f_fps; + vlc_mutex_unlock( &p_input->p->p_item->lock ); } if( var_GetInteger( p_input, "clock-synchro" ) != -1 ) @@ -2497,9 +2643,6 @@ static int InputSourceInit( input_thread_t *p_input, return VLC_SUCCESS; error: - if( b_master ) - input_ChangeState( p_input, ERROR_S ); - if( in->p_demux ) demux_Delete( in->p_demux ); @@ -2536,16 +2679,67 @@ static void InputSourceClean( input_source_t *in ) } } +/***************************************************************************** + * InputSourceMeta: + *****************************************************************************/ +static void InputSourceMeta( input_thread_t *p_input, + input_source_t *p_source, vlc_meta_t *p_meta ) +{ + access_t *p_access = p_source->p_access; + demux_t *p_demux = p_source->p_demux; + + /* XXX Remember that checking against p_item->p_meta->i_status & ITEM_PREPARSED + * is a bad idea */ + + /* Read access meta */ + if( p_access ) + access_Control( p_access, ACCESS_GET_META, p_meta ); + + /* Read demux meta */ + demux_Control( p_demux, DEMUX_GET_META, p_meta ); + + /* If the demux report unsupported meta data, try an external "meta reader" */ + bool b_bool; + if( demux_Control( p_demux, DEMUX_HAS_UNSUPPORTED_META, &b_bool ) ) + return; + if( !b_bool ) + return; + + demux_meta_t *p_demux_meta = p_demux->p_private = calloc( 1, sizeof(*p_demux_meta) ); + if( !p_demux_meta ) + return; + + module_t *p_id3 = module_need( p_demux, "meta reader", NULL, false ); + if( p_id3 ) + { + if( p_demux_meta->p_meta ) + { + vlc_meta_Merge( p_meta, p_demux_meta->p_meta ); + vlc_meta_Delete( p_demux_meta->p_meta ); + } + + if( p_demux_meta->i_attachments > 0 ) + { + vlc_mutex_lock( &p_input->p->p_item->lock ); + AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, + p_demux_meta->i_attachments, p_demux_meta->attachments ); + vlc_mutex_unlock( &p_input->p->p_item->lock ); + } + module_unneed( p_demux, p_id3 ); + } + free( p_demux_meta ); +} + + static void SlaveDemux( input_thread_t *p_input ) { int64_t i_time; int i; - bool b_set_time = true; if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) ) { - /* msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" ); */ - b_set_time = false; + msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" ); + return; } for( i = 0; i < p_input->p->i_slave; i++ ) @@ -2556,7 +2750,7 @@ static void SlaveDemux( input_thread_t *p_input ) if( in->b_eof ) continue; - if( b_set_time && demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) ) + if( demux_Control( in->p_demux, DEMUX_SET_NEXT_DEMUX_TIME, i_time ) ) { for( ;; ) { @@ -2572,13 +2766,13 @@ static void SlaveDemux( input_thread_t *p_input ) if( i_stime >= i_time ) break; - if( ( i_ret = in->p_demux->pf_demux( in->p_demux ) ) <= 0 ) + if( ( i_ret = demux_Demux( in->p_demux ) ) <= 0 ) break; } } else { - i_ret = in->p_demux->pf_demux( in->p_demux ); + i_ret = demux_Demux( in->p_demux ); } if( i_ret <= 0 ) @@ -2594,8 +2788,6 @@ static void SlaveSeek( input_thread_t *p_input ) int64_t i_time; int i; - if( !p_input ) return; - if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_TIME, &i_time ) ) { msg_Err( p_input, "demux doesn't like DEMUX_GET_TIME" ); @@ -2626,14 +2818,12 @@ static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta ) { vlc_value_t val; - if( !p_meta ) return; - /* Get meta information from user */ -#define GET_META( field, s ) \ +#define GET_META( field, s ) do { \ var_Get( p_input, (s), &val ); \ - if( *val.psz_string ) \ + if( val.psz_string && *val.psz_string ) \ vlc_meta_Set( p_meta, vlc_meta_ ## field, val.psz_string ); \ - free( val.psz_string ) + free( val.psz_string ); } while(0) GET_META( Title, "meta-title" ); GET_META( Artist, "meta-artist" ); @@ -2645,137 +2835,56 @@ static void InputMetaUser( input_thread_t *p_input, vlc_meta_t *p_meta ) #undef GET_META } -/***************************************************************************** - * InputGetExtraFiles - * Autodetect extra input list - *****************************************************************************/ -static char *InputGetExtraFiles( input_thread_t *p_input, - const char *psz_access, const char *psz_path ) -{ - char *psz_list = NULL; - - if( ( psz_access && *psz_access && strcmp( psz_access, "file" ) ) || !psz_path ) - return NULL; - - - const char *psz_ext = strrchr( psz_path, '.' ); - if( !psz_ext || strcmp( psz_ext, ".001" ) ) - return NULL; - - char *psz_file = strdup( psz_path ); - if( !psz_file ) - return NULL; - - /* Try to list .xyz files */ - for( int i = 2; i < 999; i++ ) - { - char *psz_ext = strrchr( psz_file, '.' ); - struct stat st; - - snprintf( psz_ext, 5, ".%.3d", i ); - - if( utf8_stat( psz_file, &st ) - || !S_ISREG( st.st_mode ) || !st.st_size ) - continue; - - msg_Dbg( p_input, "Detected extra file `%s'", psz_file ); - - if( psz_list ) - { - char *psz_old = psz_list; - /* FIXME how to handle file with ',' ?*/ - if( asprintf( &psz_list, "%s,%s", psz_old, psz_file ) < 0 ) - { - psz_list = psz_old; - break; - } - } - else - { - psz_list = strdup( psz_file ); - } - } - free( psz_file ); - - return psz_list; -} - /***************************************************************************** * InputUpdateMeta: merge p_item meta data with p_meta taking care of * arturl and locking issue. *****************************************************************************/ static void InputUpdateMeta( input_thread_t *p_input, vlc_meta_t *p_meta ) { - input_item_t *p_item = p_input->p->input.p_item; - char * psz_arturl = NULL; - char *psz_title = NULL; - int i_arturl_event = false; + input_item_t *p_item = p_input->p->p_item; - if( !p_meta ) - return; - - psz_arturl = input_item_GetArtURL( p_item ); + char *psz_title = NULL; + char *psz_arturl = input_item_GetArtURL( p_item ); vlc_mutex_lock( &p_item->lock ); + if( vlc_meta_Get( p_meta, vlc_meta_Title ) && !p_item->b_fixed_name ) psz_title = strdup( vlc_meta_Get( p_meta, vlc_meta_Title ) ); vlc_meta_Merge( p_item->p_meta, p_meta ); + vlc_meta_Delete( p_meta ); + if( psz_arturl && *psz_arturl ) { vlc_meta_Set( p_item->p_meta, vlc_meta_ArtworkURL, psz_arturl ); - i_arturl_event = true; - } - vlc_meta_Delete( p_meta ); - - if( psz_arturl && !strncmp( psz_arturl, "attachment://", strlen("attachment") ) ) - { - /* Don't look for art cover if sout - * XXX It can change when sout has meta data support */ - if( p_input->p->p_sout && !p_input->b_preparsing ) + if( !strncmp( psz_arturl, "attachment://", strlen("attachment") ) ) { - vlc_meta_Set( p_item->p_meta, vlc_meta_ArtworkURL, "" ); - i_arturl_event = true; - + /* Don't look for art cover if sout + * XXX It can change when sout has meta data support */ + if( p_input->p->p_sout && !p_input->b_preparsing ) + vlc_meta_Set( p_item->p_meta, vlc_meta_ArtworkURL, "" ); + else + input_ExtractAttachmentAndCacheArt( p_input ); } - else - input_ExtractAttachmentAndCacheArt( p_input ); } free( psz_arturl ); - /* A bit ugly */ - p_meta = NULL; - if( vlc_dictionary_keys_count( &p_item->p_meta->extra_tags ) > 0 ) - { - p_meta = vlc_meta_New(); - vlc_meta_Merge( p_meta, input_item_GetMetaObject( p_item ) ); - } vlc_mutex_unlock( &p_item->lock ); - input_item_SetPreparsed( p_item, true ); - - if( i_arturl_event == true ) - { - vlc_event_t event; - - /* Notify interested third parties */ - event.type = vlc_InputItemMetaChanged; - event.u.input_item_meta_changed.meta_type = vlc_meta_ArtworkURL; - vlc_event_send( &p_item->event_manager, &event ); - } - if( psz_title ) { - input_Control( p_input, INPUT_SET_NAME, psz_title ); + input_item_SetName( p_item, psz_title ); free( psz_title ); } + input_item_SetPreparsed( p_item, true ); + + input_SendEventMeta( p_input ); /** \todo handle sout meta */ } - static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_attachment, int i_new, input_attachment_t **pp_new ) { @@ -2793,79 +2902,115 @@ static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_atta *pi_attachment = i_attachment; *ppp_attachment = attachment; } - -static void AccessMeta( input_thread_t * p_input, vlc_meta_t *p_meta ) +/***************************************************************************** + * InputGetExtraFiles + * Autodetect extra input list + *****************************************************************************/ +static void InputGetExtraFilesPattern( input_thread_t *p_input, + int *pi_list, char ***pppsz_list, + const char *psz_path, + const char *psz_match, + const char *psz_format, + int i_start, int i_stop ) { - int i; + int i_list; + char **ppsz_list; - if( p_input->b_preparsing ) - return; + TAB_INIT( i_list, ppsz_list ); - if( p_input->p->input.p_access ) - access_Control( p_input->p->input.p_access, ACCESS_GET_META, - p_meta ); + char *psz_base = strdup( psz_path ); + if( !psz_base ) + goto exit; - /* Get meta data from slave input */ - for( i = 0; i < p_input->p->i_slave; i++ ) + /* Remove the extension */ + char *psz_end = &psz_base[strlen(psz_base)-strlen(psz_match)]; + assert( psz_end >= psz_base); + *psz_end = '\0'; + + /* Try to list files */ + for( int i = i_start; i <= i_stop; i++ ) { - DemuxMeta( p_input, p_meta, p_input->p->slave[i]->p_demux ); - if( p_input->p->slave[i]->p_access ) + struct stat st; + char *psz_file; + + if( asprintf( &psz_file, psz_format, psz_base, i ) < 0 ) + break; + + if( utf8_stat( psz_file, &st ) || !S_ISREG( st.st_mode ) || !st.st_size ) { - access_Control( p_input->p->slave[i]->p_access, - ACCESS_GET_META, p_meta ); + free( psz_file ); + break; } + + msg_Dbg( p_input, "Detected extra file `%s'", psz_file ); + TAB_APPEND( i_list, ppsz_list, psz_file ); } + free( psz_base ); +exit: + *pi_list = i_list; + *pppsz_list = ppsz_list; } -static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_demux ) +static void InputGetExtraFiles( input_thread_t *p_input, + int *pi_list, char ***pppsz_list, + const char *psz_access, const char *psz_path ) { - bool b_bool; - module_t *p_id3; - - -#if 0 - /* XXX I am not sure it is a great idea, besides, there is more than that - * if we want to do it right */ - vlc_mutex_lock( &p_item->lock ); - if( p_item->p_meta && (p_item->p_meta->i_status & ITEM_PREPARSED ) ) - { - vlc_mutex_unlock( &p_item->lock ); - return; - } - vlc_mutex_unlock( &p_item->lock ); -#endif + static const struct + { + const char *psz_match; + const char *psz_format; + int i_start; + int i_stop; + } p_pattern[] = { + /* XXX the order is important */ + { ".001", "%s.%.3d", 2, 999 }, + { ".part1.rar", "%s.part%.1d.rar",2, 9 }, + { ".part01.rar", "%s.part%.2d.rar",2, 99, }, + { ".part001.rar", "%s.part%.3d.rar",2, 999 }, + { ".rar", "%s.r%.2d", 1, 99 }, + { NULL, NULL, 0, 0 } + }; + + TAB_INIT( *pi_list, *pppsz_list ); - demux_Control( p_demux, DEMUX_GET_META, p_meta ); - if( demux_Control( p_demux, DEMUX_HAS_UNSUPPORTED_META, &b_bool ) ) - return; - if( !b_bool ) + if( ( psz_access && *psz_access && strcmp( psz_access, "file" ) ) || !psz_path ) return; - p_demux->p_private = malloc( sizeof( demux_meta_t ) ); - if(! p_demux->p_private ) - return; + const size_t i_path = strlen(psz_path); - p_id3 = module_need( p_demux, "meta reader", NULL, 0 ); - if( p_id3 ) + for( int i = 0; p_pattern[i].psz_match != NULL; i++ ) { - demux_meta_t *p_demux_meta = (demux_meta_t *)p_demux->p_private; + const size_t i_ext = strlen(p_pattern[i].psz_match ); - if( p_demux_meta->p_meta ) + if( i_path < i_ext ) + continue; + if( !strcmp( &psz_path[i_path-i_ext], p_pattern[i].psz_match ) ) { - vlc_meta_Merge( p_meta, p_demux_meta->p_meta ); - vlc_meta_Delete( p_demux_meta->p_meta ); + InputGetExtraFilesPattern( p_input, pi_list, pppsz_list, + psz_path, + p_pattern[i].psz_match, p_pattern[i].psz_format, + p_pattern[i].i_start, p_pattern[i].i_stop ); + return; } + } +} - if( p_demux_meta->i_attachments > 0 ) - { - vlc_mutex_lock( &p_input->p->input.p_item->lock ); - AppendAttachment( &p_input->p->i_attachment, &p_input->p->attachment, - p_demux_meta->i_attachments, p_demux_meta->attachments ); - vlc_mutex_unlock( &p_input->p->input.p_item->lock ); - } - module_unneed( p_demux, p_id3 ); +/* */ +static void input_ChangeState( input_thread_t *p_input, int i_state ) +{ + const bool b_changed = p_input->i_state != i_state; + + p_input->i_state = i_state; + if( i_state == ERROR_S ) + p_input->b_error = true; + else if( i_state == END_S ) + p_input->b_eof = true; + + if( b_changed ) + { + input_item_SetErrorWhenReading( p_input->p->p_item, p_input->b_error ); + input_SendEventState( p_input, i_state ); } - free( p_demux->p_private ); } @@ -3036,7 +3181,7 @@ static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_for var_Change( p_input, "spu-es", VLC_VAR_CHOICESCOUNT, &count, NULL ); sub = InputSourceNew( p_input ); - if( InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) ) + if( !sub || InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) ) { free( sub ); return; @@ -3052,38 +3197,53 @@ static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_for if( count.i_int < list.p_list->i_count ) { - int i_id = list.p_list->p_values[count.i_int].i_int; - es_out_id_t *p_es = input_EsOutGetFromID( p_input->p->p_es_out, i_id ); + const int i_id = list.p_list->p_values[count.i_int].i_int; - es_out_Control( p_input->p->p_es_out, ES_OUT_SET_DEFAULT, p_es ); - es_out_Control( p_input->p->p_es_out, ES_OUT_SET_ES, p_es ); + es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_DEFAULT_BY_ID, i_id ); + es_out_Control( p_input->p->p_es_out_display, ES_OUT_SET_ES_BY_ID, i_id ); } var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL ); } } -bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle, - bool b_check_extension ) -{ - vlc_value_t val; - - if( b_check_extension && !subtitles_Filter( psz_subtitle ) ) - return false; - - assert( psz_subtitle != NULL ); - - val.psz_string = strdup( psz_subtitle ); - if( val.psz_string ) - input_ControlPush( p_input, INPUT_CONTROL_ADD_SUBTITLE, &val ); - return true; -} - /***************************************************************************** - * input_get_event_manager + * Statistics *****************************************************************************/ -vlc_event_manager_t *input_get_event_manager( input_thread_t *p_input ) +void input_UpdateStatistic( input_thread_t *p_input, + input_statistic_t i_type, int i_delta ) { - return &p_input->p->event_manager; + assert( p_input->i_state != INIT_S ); + + vlc_mutex_lock( &p_input->p->counters.counters_lock); + switch( i_type ) + { +#define I(c) stats_UpdateInteger( p_input, p_input->p->counters.c, i_delta, NULL ) + case INPUT_STATISTIC_DECODED_VIDEO: + I(p_decoded_video); + break; + case INPUT_STATISTIC_DECODED_AUDIO: + I(p_decoded_audio); + break; + case INPUT_STATISTIC_DECODED_SUBTITLE: + I(p_decoded_sub); + break; + case INPUT_STATISTIC_SENT_PACKET: + I(p_sout_sent_packets); + break; +#undef I + case INPUT_STATISTIC_SENT_BYTE: + { + int i_bytes; /* That's pretty stupid to define it as an integer, it will overflow + really fast ... */ + if( !stats_UpdateInteger( p_input, p_input->p->counters.p_sout_sent_bytes, i_delta, &i_bytes ) ) + stats_UpdateFloat( p_input, p_input->p->counters.p_sout_send_bitrate, i_bytes, NULL ); + break; + } + default: + msg_Err( p_input, "Invalid statistic type %d (internal error)", i_type ); + break; + } + vlc_mutex_unlock( &p_input->p->counters.counters_lock); } /**/