X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Finput.c;h=ba75afac575b896e565f91ce9a9c7a0f5c769fce;hb=5fca3033c82ea4f7ef236124823d37df35b3e870;hp=9083d0fb38153c0417c96915ee2333aaa3884da4;hpb=b4951bceb2c47d47b7c2daadb83edb620d9bca27;p=vlc diff --git a/src/input/input.c b/src/input/input.c index 9083d0fb38..ba75afac57 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 *); @@ -96,35 +100,13 @@ static void AppendAttachment( int *pi_attachment, input_attachment_t ***ppp_atta 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 +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 */ @@ -183,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; @@ -245,7 +229,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 ) @@ -258,7 +241,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, '}' ); @@ -267,6 +250,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; @@ -298,6 +283,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 ) @@ -481,8 +467,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; @@ -494,7 +481,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(); @@ -526,7 +513,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(); @@ -657,39 +644,24 @@ 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( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_POSITION, &f_position ) ) + f_position = 0.0; - if( old_val.i_time != val.i_time ) - { - UpdateItemLength( p_input, i_length ); - } - } + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_TIME, &i_time ) ) + i_time = 0; + + if( demux_Control( p_input->p->input.p_demux, + DEMUX_GET_LENGTH, &i_length ) ) + i_length = 0; - var_SetBool( p_input, "intf-change", true ); + es_out_SetTimes( p_input->p->p_es_out, f_position, i_time, i_length ); } /** @@ -705,6 +677,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 ); } /** @@ -720,65 +693,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 ); - /* */ - 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 ) @@ -909,7 +905,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); @@ -1124,7 +1121,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++ ) @@ -1149,7 +1145,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 ); @@ -1166,21 +1163,13 @@ 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 ); - } - } + 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->input.p_item ); + input_SendEventTimes( p_input, 0.0, 0, i_length ); StartTitle( p_input ); @@ -1230,7 +1219,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 ) { @@ -1271,6 +1262,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; @@ -1305,6 +1297,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 ); @@ -1318,7 +1314,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 ) { @@ -1375,6 +1373,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 ) @@ -1382,7 +1411,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 ) ) @@ -1451,13 +1483,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 ) { @@ -1478,21 +1580,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 ) ) { @@ -1503,6 +1599,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; } @@ -1521,21 +1618,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 ); @@ -1562,6 +1653,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; } @@ -1572,68 +1664,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 ) { @@ -1646,10 +1693,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 { @@ -1663,18 +1713,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 ) @@ -1694,6 +1747,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" ); @@ -1704,8 +1758,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" ); @@ -1716,10 +1786,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" ); @@ -1730,15 +1807,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; } @@ -1756,25 +1832,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: @@ -1802,7 +1874,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 ); @@ -1822,7 +1894,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 ); @@ -1850,9 +1922,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--; @@ -1869,7 +1940,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 ); } @@ -1886,9 +1957,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--; @@ -1904,7 +1974,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 ); @@ -1984,17 +2054,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" ); @@ -2007,24 +2093,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; } @@ -2032,28 +2141,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; } @@ -2063,14 +2153,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 ); @@ -2078,8 +2164,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 ) @@ -2090,42 +2177,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; } /***************************************************************************** @@ -2253,13 +2325,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 { @@ -2337,10 +2411,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 ) @@ -2675,7 +2752,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; @@ -2683,60 +2759,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 */ } @@ -2788,7 +2844,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 */ @@ -2834,6 +2889,23 @@ static void DemuxMeta( input_thread_t *p_input, vlc_meta_t *p_meta, demux_t *p_d 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 @@ -3018,11 +3090,10 @@ 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 ); } @@ -3044,6 +3115,45 @@ bool input_AddSubtitles( input_thread_t *p_input, char *psz_subtitle, 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 *****************************************************************************/