X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Finput%2Finput.c;h=a31f7ee701db3b80c735f6dd587f8dead6bcfc72;hb=d30180d8ec7de8776611de5c2f0b0e1587bf0ad4;hp=c61e45fbfa97041a779950903a889fe78e26a57f;hpb=4ce86c99c1bceda6dbaeae75dc748e9902b0abff;p=vlc diff --git a/src/input/input.c b/src/input/input.c index c61e45fbfa..a31f7ee701 100644 --- a/src/input/input.c +++ b/src/input/input.c @@ -36,6 +36,12 @@ #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 #include "../stream_output/stream_output.h" @@ -54,8 +60,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 * ); @@ -71,8 +77,6 @@ static bool Control( input_thread_t *, int, vlc_value_t ); static int UpdateFromAccess( input_thread_t * ); static int UpdateFromDemux( input_thread_t * ); -static void UpdateItemLength( input_thread_t *, int64_t i_length ); - static void MRLSections( input_thread_t *, char *, int *, int *, int *, int *); static input_source_t *InputSourceNew( input_thread_t *); @@ -94,35 +98,15 @@ 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, @@ -154,8 +138,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 */ @@ -181,19 +166,20 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, 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 ); 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; @@ -212,6 +198,7 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, p_input->p->input.b_rescale_ts = true; p_input->p->input.b_eof = false; p_input->p->input.i_cr_average = 0; + memset( &p_input->p->input_last_times, 0, sizeof(p_input->p->input_last_times) ); vlc_mutex_lock( &p_item->lock ); @@ -243,7 +230,6 @@ static input_thread_t *Create( vlc_object_t *p_parent, input_item_t *p_item, input_ControlVarInit( p_input ); /* */ - p_input->p->pts_adjust.b_auto_adjust = var_GetBool( p_input, "auto-adjust-pts-delay" ); p_input->p->input.i_cr_average = var_GetInteger( p_input, "cr-average" ); if( !p_input->b_preparsing ) @@ -256,7 +242,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, '}' ); @@ -265,6 +251,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; @@ -296,6 +284,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 ) @@ -391,7 +380,7 @@ input_thread_t *__input_CreateThreadExtended( vlc_object_t *p_parent, * \param p_parent a vlc_object * \param p_item an input item * \param b_block should we block until read is finished ? - * \return the input object id if non blocking, an error code else + * \return an error code, VLC_SUCCESS on success */ int __input_Read( vlc_object_t *p_parent, input_item_t *p_item, bool b_block ) @@ -418,7 +407,7 @@ int __input_Read( vlc_object_t *p_parent, input_item_t *p_item, return VLC_EGENERIC; } } - return p_input->i_object_id; + return VLC_SUCCESS; } /** @@ -479,8 +468,9 @@ void input_StopThread( input_thread_t *p_input ) input_ControlPush( p_input, INPUT_CONTROL_SET_DIE, NULL ); } -sout_instance_t * input_DetachSout( input_thread_t *p_input ) +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; @@ -492,7 +482,7 @@ sout_instance_t * input_DetachSout( input_thread_t *p_input ) * 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(); @@ -524,7 +514,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(); @@ -655,39 +645,52 @@ 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; + input_event_times_t ev; + mtime_t i_es_out_delay; + + es_out_GetBuffering( p_input->p->p_es_out, &i_es_out_delay ); + + ev.f_position = 0.0; + ev.i_time = 0; + ev.i_length = 0; /* update input status variables */ - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_POSITION, &f_pos ) ) + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_POSITION, &ev.f_position ) ) + ev.f_position = 0.0; + + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_TIME, &ev.i_time ) ) + ev.i_time = 0; + + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_LENGTH, &ev.i_length ) ) + ev.i_length = 0; + + if( ev.i_time > 0 ) { - val.f_float = (float)f_pos; - var_Change( p_input, "position", VLC_VAR_SETVALUE, &val, NULL ); + ev.i_time -= i_es_out_delay; + if( ev.i_time < 0 ) + ev.i_time = 0; } - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_TIME, &i_time ) ) + if( ev.i_length > 0 ) { - p_input->i_time = i_time; - val.i_time = i_time; - var_Change( p_input, "time", VLC_VAR_SETVALUE, &val, NULL ); + ev.f_position -= (double)i_es_out_delay / ev.i_length; } - if( !demux_Control( p_input->p->input.p_demux, - DEMUX_GET_LENGTH, &i_length ) ) + + if( p_input->i_state == PAUSE_S ) { - 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 ); + input_event_times_t old = p_input->p->input_last_times; - if( old_val.i_time != val.i_time ) - { - UpdateItemLength( p_input, i_length ); - } + /* XXX We have a jitter because of PCR frequency/get time precision. + * Hides it */ + if( llabs(ev.i_time - old.i_time) < CLOCK_FREQ ) + ev.i_time = old.i_time; } - var_SetBool( p_input, "intf-change", true ); + p_input->p->input_last_times = ev; + + input_SendEventTimes( p_input, &ev ); } /** @@ -703,6 +706,7 @@ static void MainLoopStatistic( input_thread_t *p_input ) stats_ComputeGlobalStats( p_input->p_libvlc, p_input->p_libvlc->p_stats ); } + input_SendEventStatistics( p_input ); } /** @@ -718,65 +722,88 @@ 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; vlc_value_t val; mtime_t i_current; mtime_t i_deadline; + mtime_t i_wakeup; + bool b_paused; /* Demux data */ b_force_update = false; - if( p_input->i_state != PAUSE_S ) - MainLoopDemux( p_input, &b_force_update, &i_start_mdate ); + i_wakeup = 0; + /* 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, NULL ); - /* */ - i_deadline = 0; - if( p_input->i_state == PAUSE_S ) - i_deadline = __MIN( i_intf_update, i_statistic_update ); - - /* Handle control */ - vlc_mutex_lock( &p_input->p->lock_control ); - ControlReduce( p_input ); - while( !ControlPopNoLock( p_input, &i_type, &val, i_deadline ) ) + if( !b_paused ) { - msg_Dbg( p_input, "control type=%d", i_type ); - if( Control( p_input, i_type, val ) ) - b_force_update = true; - } - vlc_mutex_unlock( &p_input->p->lock_control ); + if( !p_input->p->input.b_eof ) + { + MainLoopDemux( p_input, &b_force_update, &i_start_mdate ); - /* Update interface and statistics */ - i_current = mdate(); - if( i_intf_update < i_current || b_force_update ) - { - MainLoopInterface( p_input ); - i_intf_update = i_current + INT64_C(250000); - } - if( i_statistic_update < i_current ) - { - MainLoopStatistic( p_input ); - i_statistic_update = i_current + INT64_C(1000000); + 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; + } } - } - 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( !p_input->b_die ) - { - if( input_EsOutDecodersEmpty( p_input->p->p_es_out ) ) - break; + /* */ + do { + i_deadline = i_wakeup; + if( b_paused ) + i_deadline = __MIN( i_intf_update, i_statistic_update ); + + /* Handle control */ + vlc_mutex_lock( &p_input->p->lock_control ); + ControlReduce( p_input ); + while( !ControlPopNoLock( p_input, &i_type, &val, i_deadline ) ) + { + msg_Dbg( p_input, "control type=%d", i_type ); - msg_Dbg( p_input, "waiting decoder fifos to empty" ); + if( Control( p_input, i_type, val ) ) + b_force_update = true; + } + vlc_mutex_unlock( &p_input->p->lock_control ); - msleep( INPUT_IDLE_SLEEP ); - } + /* Update interface and statistics */ + i_current = mdate(); + if( i_intf_update < i_current || b_force_update ) + { + MainLoopInterface( p_input ); + i_intf_update = i_current + INT64_C(250000); + b_force_update = false; + } + if( i_statistic_update < i_current ) + { + MainLoopStatistic( p_input ); + i_statistic_update = i_current + INT64_C(1000000); + } - /* We have finished */ - input_ChangeState( p_input, END_S ); + /* Check if i_wakeup is still valid */ + if( i_wakeup != 0 ) + { + 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_error ) + input_ChangeState( p_input, END_S ); } static void InitStatistics( input_thread_t * p_input ) @@ -907,7 +934,8 @@ 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); + if( val.i_int < 0 ) + p_input->i_pts_delay -= (val.i_int * 1000); /* Update cr_average depending on the caching */ p_input->p->input.i_cr_average *= (10 * p_input->i_pts_delay / 200000); @@ -919,7 +947,7 @@ static void StartTitle( input_thread_t * p_input ) { double f_fps; vlc_value_t val; - int i, i_delay; + int i_delay; char *psz; char *psz_subtitle; int64_t i_length; @@ -1006,45 +1034,29 @@ static void StartTitle( input_thread_t * p_input ) if( psz_subtitle != NULL ) { msg_Dbg( p_input, "forced subtitle: %s", psz_subtitle ); - input_AddSubtitles( p_input, psz_subtitle, false ); + SubtitleAdd( p_input, psz_subtitle, true ); } var_Get( p_input, "sub-autodetect-file", &val ); if( val.b_bool ) { char *psz_autopath = var_GetNonEmptyString( p_input, "sub-autodetect-path" ); - char **subs = subtitles_Detect( p_input, psz_autopath, - p_input->p->input.p_item->psz_uri ); - input_source_t *sub; - i = 0; - if( psz_autopath == NULL ) - psz_autopath = strdup(""); - - /* Try to autoselect the first autodetected subtitles file - * if no subtitles file was specified */ - if( ( psz_subtitle == NULL ) && subs && subs[0] ) - { - input_AddSubtitles( p_input, subs[0], false ); - free( subs[0] ); - i = 1; - } + char **ppsz_subs = subtitles_Detect( p_input, psz_autopath, + p_input->p->input.p_item->psz_uri ); + free( psz_autopath ); - /* Then, just add the following subtitles files */ - for( ; subs && subs[i]; i++ ) + for( int i = 0; ppsz_subs && ppsz_subs[i]; i++ ) { - if( !psz_subtitle || strcmp( psz_subtitle, subs[i] ) ) - { - sub = InputSourceNew( p_input ); - if( !InputSourceInit( p_input, sub, subs[i], "subtitle" ) ) - { - TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub ); - } - else free( sub ); - } - free( subs[i] ); + /* Try to autoselect the first autodetected subtitles file + * if no subtitles file was specified */ + bool b_forced = i == 0 && !psz_subtitle; + + if( !psz_subtitle || strcmp( psz_subtitle, ppsz_subs[i] ) ) + SubtitleAdd( p_input, ppsz_subs[i], b_forced ); + + free( ppsz_subs[i] ); } - free( subs ); - free( psz_autopath ); + free( ppsz_subs ); } free( psz_subtitle ); @@ -1138,7 +1150,6 @@ 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++ ) @@ -1163,7 +1174,8 @@ 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 ); @@ -1180,21 +1192,15 @@ 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 - { - 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 ); - } - } + input_event_times_t ev_times; + ev_times.f_position = 0; + ev_times.i_time = 0; + if( demux_Control( p_input->p->input.p_demux, DEMUX_GET_LENGTH, + &ev_times.i_length ) ) + ev_times.i_length = 0; + if( ev_times.i_length <= 0 ) + ev_times.i_length = input_item_GetDuration( p_input->p->input.p_item ); + input_SendEventTimes( p_input, &ev_times ); StartTitle( p_input ); @@ -1244,7 +1250,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 ) { @@ -1285,6 +1293,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; @@ -1332,7 +1341,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 ) { @@ -1389,6 +1400,37 @@ static void End( input_thread_t * 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 ) @@ -1396,7 +1438,10 @@ static inline int ControlPopNoLock( input_thread_t *p_input, while( p_input->p->i_control <= 0 ) { - if( i_deadline <= 0 ) + if( !vlc_object_alive( p_input ) ) + return VLC_EGENERIC; + + if( i_deadline < 0 ) return VLC_EGENERIC; if( vlc_cond_timedwait( &p_input->p->wait_control, &p_input->p->lock_control, i_deadline ) ) @@ -1465,13 +1510,83 @@ 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 ) return b_force_update; + if( !p_input ) + return b_force_update; switch( i_type ) { @@ -1506,7 +1621,7 @@ static bool Control( input_thread_t *p_input, int i_type, if( f_pos < 0.0 ) f_pos = 0.0; 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 ) ) { @@ -1517,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; } @@ -1549,7 +1665,7 @@ static bool Control( input_thread_t *p_input, int i_type, 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 ); @@ -1576,6 +1692,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; } @@ -1586,68 +1703,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_EsOutChangeState( p_input->p->p_es_out ); } - 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_EsOutChangeState( p_input->p->p_es_out ); } - 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 ) { @@ -1660,10 +1732,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 { @@ -1677,18 +1752,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 ) @@ -1708,6 +1786,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" ); @@ -1718,8 +1797,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" ); @@ -1730,10 +1825,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" ); @@ -1744,15 +1846,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; + p_input->p->i_rate = i_rate; + input_SendEventRate( p_input, 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; } @@ -1770,25 +1871,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: @@ -1816,7 +1913,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 ); @@ -1836,7 +1933,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 ); access_Control( p_access, ACCESS_SET_TITLE, i_title ); stream_AccessReset( p_input->p->input.p_stream ); @@ -1883,7 +1980,7 @@ 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 ); } @@ -1918,7 +2015,7 @@ 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 ); @@ -1927,6 +2024,14 @@ static bool Control( input_thread_t *p_input, int i_type, } break; + case INPUT_CONTROL_ADD_SUBTITLE: + if( val.psz_string ) + { + SubtitleAdd( p_input, val.psz_string, true ); + free( val.psz_string ); + } + break; + case INPUT_CONTROL_ADD_SLAVE: if( val.psz_string ) { @@ -1990,17 +2095,33 @@ 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_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: default: msg_Err( p_input, "not yet implemented" ); @@ -2013,24 +2134,47 @@ static bool Control( input_thread_t *p_input, int i_type, /***************************************************************************** * UpdateFromDemux: *****************************************************************************/ +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; +} static int UpdateFromDemux( 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; } @@ -2038,28 +2182,9 @@ static int UpdateFromDemux( input_thread_t *p_input ) /* 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; - - 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 ) - { - if( p_demux->info.i_title > i_title_end ) return 0; - } - } - + return UpdateTitleSeekpoint( p_input, + p_demux->info.i_title, + p_demux->info.i_seekpoint ); return 1; } @@ -2069,14 +2194,10 @@ static int UpdateFromDemux( input_thread_t *p_input ) static int UpdateFromAccess( 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 ); @@ -2084,8 +2205,9 @@ static int UpdateFromAccess( input_thread_t *p_input ) } 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; } if( p_access->info.i_update & INPUT_UPDATE_META ) @@ -2096,42 +2218,27 @@ static int UpdateFromAccess( input_thread_t *p_input ) InputUpdateMeta( p_input, p_meta ); p_access->info.i_update &= ~INPUT_UPDATE_META; } + if( p_access->info.i_update & INPUT_UPDATE_SIGNAL ) + { + double f_quality; + double f_strength; - p_access->info.i_update &= ~INPUT_UPDATE_SIZE; + if( access_Control( p_access, ACCESS_GET_SIGNAL, &f_quality, &f_strength ) ) + f_quality = f_strength = -1; - /* 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; + input_SendEventSignal( p_input, f_quality, f_strength ); - 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; - } + p_access->info.i_update &= ~INPUT_UPDATE_SIGNAL; } - return 1; -} + p_access->info.i_update &= ~INPUT_UPDATE_SIZE; -/***************************************************************************** - * 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 ); + /* 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; } /***************************************************************************** @@ -2206,12 +2313,9 @@ static int InputSourceInit( input_thread_t *p_input, } } - /* Try access_demux if no demux given */ - if( *psz_demux == '\0' ) - { - in->p_demux = demux_New( p_input, psz_access, psz_demux, psz_path, - NULL, p_input->p->p_es_out, false ); - } + /* Try access_demux first */ + in->p_demux = demux_New( p_input, psz_access, psz_demux, psz_path, + NULL, p_input->p->p_es_out, false ); } else { @@ -2262,13 +2366,15 @@ 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 { @@ -2346,10 +2452,13 @@ 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 ) @@ -2583,7 +2692,8 @@ static void SlaveSeek( input_thread_t *p_input ) if( demux_Control( in->p_demux, DEMUX_SET_TIME, i_time ) ) { - msg_Err( p_input, "seek failed for slave %d -> EOF", i ); + if( !in->b_eof ) + msg_Err( p_input, "seek failed for slave %d -> EOF", i ); in->b_eof = true; } else @@ -2648,9 +2758,8 @@ static char *InputGetExtraFiles( input_thread_t *p_input, snprintf( psz_ext, 5, ".%.3d", i ); - if( utf8_stat( psz_file, &st ) != 0 ) - break; - if( st.st_size <= 0 ) + 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 ); @@ -2684,7 +2793,6 @@ 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; if( !p_meta ) return; @@ -2692,60 +2800,40 @@ static void InputUpdateMeta( input_thread_t *p_input, vlc_meta_t *p_meta ) 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 */ } @@ -2797,7 +2885,6 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d 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 */ @@ -2820,7 +2907,7 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d if(! p_demux->p_private ) return; - p_id3 = module_Need( p_demux, "meta reader", NULL, 0 ); + p_id3 = module_need( p_demux, "meta reader", NULL, 0 ); if( p_id3 ) { demux_meta_t *p_demux_meta = (demux_meta_t *)p_demux->p_private; @@ -2838,11 +2925,28 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d 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 ); + module_unneed( p_demux, p_id3 ); } free( p_demux->p_private ); } +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->input.p_item, p_input->b_error ); + input_SendEventState( p_input, i_state ); + } +} + /***************************************************************************** * MRLSplit: parse the access, demux and url part of the @@ -2979,19 +3083,13 @@ static void MRLSections( input_thread_t *p_input, char *psz_source, /***************************************************************************** * input_AddSubtitles: add a subtitles file and enable it *****************************************************************************/ -bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle, - bool b_check_extension ) +static void SubtitleAdd( input_thread_t *p_input, char *psz_subtitle, bool b_forced ) { input_source_t *sub; vlc_value_t count; vlc_value_t list; char *psz_path, *psz_extension; - if( b_check_extension && !subtitles_Filter( psz_subtitle ) ) - { - return false; - } - /* if we are provided a subtitle.sub file, * see if we don't have a subtitle.idx and use it instead */ psz_path = strdup( psz_subtitle ); @@ -3000,13 +3098,12 @@ bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle, psz_extension = strrchr( psz_path, '.'); if( psz_extension && strcmp( psz_extension, ".sub" ) == 0 ) { - FILE *f; + struct stat st; strcpy( psz_extension, ".idx" ); - /* FIXME: a portable wrapper for stat() or access() would be more suited */ - if( ( f = utf8_fopen( psz_path, "rt" ) ) ) + + if( !utf8_stat( psz_path, &st ) && S_ISREG( st.st_mode ) ) { - fclose( f ); msg_Dbg( p_input, "using %s subtitles file instead of %s", psz_path, psz_subtitle ); strcpy( psz_subtitle, psz_path ); @@ -3018,30 +3115,86 @@ bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle, var_Change( p_input, "spu-es", VLC_VAR_CHOICESCOUNT, &count, NULL ); sub = InputSourceNew( p_input ); - if( !InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) ) + if( InputSourceInit( p_input, sub, psz_subtitle, "subtitle" ) ) + { + free( sub ); + return; + } + TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub ); + + /* Select the ES */ + if( b_forced && !var_Change( p_input, "spu-es", VLC_VAR_GETLIST, &list, NULL ) ) { - TAB_APPEND( p_input->p->i_slave, p_input->p->slave, sub ); + if( count.i_int == 0 ) + count.i_int++; + /* if it was first one, there is disable too */ - /* Select the ES */ - if( !var_Change( p_input, "spu-es", VLC_VAR_GETLIST, &list, NULL ) ) + if( count.i_int < list.p_list->i_count ) { - if( count.i_int == 0 ) - count.i_int++; - /* if it was first one, there is disable too */ + const int i_id = list.p_list->p_values[count.i_int].i_int; - if( count.i_int < list.p_list->i_count ) - { - input_ControlPush( p_input, INPUT_CONTROL_SET_ES, - &list.p_list->p_values[count.i_int] ); - } - var_Change( p_input, "spu-es", VLC_VAR_FREELIST, &list, NULL ); + 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 ); } - else free( sub ); +} + +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; } +/***************************************************************************** + * Statistics + *****************************************************************************/ +void input_UpdateStatistic( input_thread_t *p_input, + input_statistic_t i_type, int i_delta ) +{ + 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); +} /***************************************************************************** * input_get_event_manager *****************************************************************************/