X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fes_out.c;h=65d0f783fda452ace5f9b1b6d976c244c9b64574;hb=3d7cbf178fa105b8e132b0edd5423062652298de;hp=ecf7d8963e2d882ab85598ec68a6608c22fd6d4a;hpb=c046c7392fe5e0c8fac0f605631aa4ef491f2a5a;p=vlc diff --git a/src/input/es_out.c b/src/input/es_out.c index ecf7d8963e..65d0f783fd 100644 --- a/src/input/es_out.c +++ b/src/input/es_out.c @@ -25,9 +25,13 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif #include +#include +#include #include #include @@ -35,9 +39,14 @@ #include #include "input_internal.h" +#include "clock.h" +#include "decoder.h" +#include "es_out.h" +#include "event.h" + +#include "../stream_output/stream_output.h" -#include "vlc_playlist.h" -#include "iso_lang.h" +#include /* FIXME we should find a better way than including that */ #include "../text/iso-639_def.h" @@ -52,10 +61,10 @@ typedef struct /* Number of es for this pgrm */ int i_es; - vlc_bool_t b_selected; + bool b_selected; /* Clock for this program */ - input_clock_t clock; + input_clock_t *p_clock; char *psz_name; char *psz_now_playing; @@ -70,21 +79,33 @@ struct es_out_id_t int i_id; es_out_pgrm_t *p_pgrm; - /* Misc. */ - int64_t i_preroll_end; - /* Channel in the track type */ int i_channel; es_format_t fmt; char *psz_language; char *psz_language_code; + decoder_t *p_dec; + decoder_t *p_dec_record; + + /* Fields for Video with CC */ + bool pb_cc_present[4]; + es_out_id_t *pp_cc_es[4]; + + /* Field for CC track from a master video */ + es_out_id_t *p_master; + + /* ID for the meta data */ + int i_meta_id; }; struct es_out_sys_t { input_thread_t *p_input; + /* */ + vlc_mutex_t lock; + /* all programs */ int i_pgrm; es_out_pgrm_t **pgrm; @@ -97,7 +118,7 @@ struct es_out_sys_t es_out_id_t **es; /* mode gestion */ - vlc_bool_t b_active; + bool b_active; int i_mode; /* es count */ @@ -120,18 +141,45 @@ struct es_out_sys_t /* delay */ int64_t i_audio_delay; int64_t i_spu_delay; + + /* Rate used for clock */ + int i_rate; + + /* */ + bool b_paused; + mtime_t i_pause_date; + + /* Current preroll */ + mtime_t i_preroll_end; + + /* Used for buffering */ + bool b_buffering; + mtime_t i_buffering_extra_initial; + mtime_t i_buffering_extra_stream; + mtime_t i_buffering_extra_system; + + /* Record */ + sout_instance_t *p_sout_record; }; -static es_out_id_t *EsOutAdd ( es_out_t *, es_format_t * ); +static es_out_id_t *EsOutAdd ( es_out_t *, const es_format_t * ); static int EsOutSend ( es_out_t *, es_out_id_t *, block_t * ); static void EsOutDel ( es_out_t *, es_out_id_t * ); -static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ); static int EsOutControl( es_out_t *, int i_query, va_list ); +static void EsOutDelete ( es_out_t * ); -static void EsOutAddInfo( es_out_t *, es_out_id_t *es ); +static void EsOutSelect( es_out_t *, es_out_id_t *es, bool b_force ); +static void EsOutUpdateInfo( es_out_t *, es_out_id_t *es, const es_format_t *, const vlc_meta_t * ); +static int EsOutSetRecord( es_out_t *, bool b_record ); +static bool EsIsSelected( es_out_id_t *es ); static void EsSelect( es_out_t *out, es_out_id_t *es ); -static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update ); +static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update ); +static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es ); +static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date ); +static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date ); +static void EsOutProgramsChangeRate( es_out_t *out ); +static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced ); static char *LanguageGetName( const char *psz_code ); static char *LanguageGetCode( const char *psz_lang ); static char **LanguageSplit( const char *psz_langs ); @@ -139,26 +187,56 @@ static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang ); static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm ); +static const vlc_fourcc_t EsOutFourccClosedCaptions[4] = { + VLC_FOURCC('c', 'c', '1', ' '), + VLC_FOURCC('c', 'c', '2', ' '), + VLC_FOURCC('c', 'c', '3', ' '), + VLC_FOURCC('c', 'c', '4', ' '), +}; +static inline int EsOutGetClosedCaptionsChannel( vlc_fourcc_t fcc ) +{ + int i; + for( i = 0; i < 4; i++ ) + { + if( fcc == EsOutFourccClosedCaptions[i] ) + return i; + } + return -1; +} + + /***************************************************************************** * input_EsOutNew: *****************************************************************************/ -es_out_t *input_EsOutNew( input_thread_t *p_input ) +es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) { - es_out_t *out = malloc( sizeof( es_out_t ) ); - es_out_sys_t *p_sys = malloc( sizeof( es_out_sys_t ) ); vlc_value_t val; int i; + es_out_t *out = malloc( sizeof( *out ) ); + if( !out ) + return NULL; + + es_out_sys_t *p_sys = malloc( sizeof( *p_sys ) ); + if( !p_sys ) + { + free( out ); + return NULL; + } + out->pf_add = EsOutAdd; out->pf_send = EsOutSend; out->pf_del = EsOutDel; out->pf_control = EsOutControl; + out->pf_destroy = EsOutDelete; out->p_sys = p_sys; - out->b_sout = (p_input->p->p_sout != NULL ? VLC_TRUE : VLC_FALSE); + out->b_sout = p_input->p->p_sout != NULL; + + vlc_mutex_init_recursive( &p_sys->lock ); p_sys->p_input = p_input; - p_sys->b_active = VLC_FALSE; + p_sys->b_active = false; p_sys->i_mode = ES_OUT_MODE_AUTO; @@ -192,7 +270,7 @@ es_out_t *input_EsOutNew( input_thread_t *p_input ) msg_Dbg( p_input, "selected audio language[%d] %s", i, p_sys->ppsz_audio_language[i] ); } - if( val.psz_string ) free( val.psz_string ); + free( val.psz_string ); var_Get( p_input, "sub-language", &val ); p_sys->ppsz_sub_language = LanguageSplit(val.psz_string); @@ -202,7 +280,7 @@ es_out_t *input_EsOutNew( input_thread_t *p_input ) msg_Dbg( p_input, "selected subtitle language[%d] %s", i, p_sys->ppsz_sub_language[i] ); } - if( val.psz_string ) free( val.psz_string ); + free( val.psz_string ); } else { @@ -223,27 +301,40 @@ es_out_t *input_EsOutNew( input_thread_t *p_input ) p_sys->i_audio_delay= 0; p_sys->i_spu_delay = 0; + p_sys->b_paused = false; + p_sys->i_pause_date = -1; + + p_sys->i_rate = i_rate; + + p_sys->b_buffering = true; + p_sys->i_buffering_extra_initial = 0; + p_sys->i_buffering_extra_stream = 0; + p_sys->i_buffering_extra_system = 0; + p_sys->i_preroll_end = -1; + + p_sys->p_sout_record = NULL; + return out; } /***************************************************************************** - * input_EsOutDelete: + * *****************************************************************************/ -void input_EsOutDelete( es_out_t *out ) +static void EsOutDelete( es_out_t *out ) { es_out_sys_t *p_sys = out->p_sys; int i; + if( p_sys->p_sout_record ) + EsOutSetRecord( out, false ); + for( i = 0; i < p_sys->i_es; i++ ) { if( p_sys->es[i]->p_dec ) - { input_DecoderDelete( p_sys->es[i]->p_dec ); - } - if( p_sys->es[i]->psz_language ) - free( p_sys->es[i]->psz_language ); - if( p_sys->es[i]->psz_language_code ) - free( p_sys->es[i]->psz_language_code ); + + free( p_sys->es[i]->psz_language ); + free( p_sys->es[i]->psz_language_code ); es_format_Clean( &p_sys->es[i]->fmt ); free( p_sys->es[i] ); @@ -260,37 +351,54 @@ void input_EsOutDelete( es_out_t *out ) free( p_sys->ppsz_sub_language[i] ); free( p_sys->ppsz_sub_language ); } - - if( p_sys->es ) - free( p_sys->es ); + free( p_sys->es ); /* FIXME duplicate work EsOutProgramDel (but we cannot use it) add a EsOutProgramClean ? */ for( i = 0; i < p_sys->i_pgrm; i++ ) { es_out_pgrm_t *p_pgrm = p_sys->pgrm[i]; - if( p_pgrm->psz_now_playing ) - free( p_pgrm->psz_now_playing ); - if( p_pgrm->psz_publisher ) - free( p_pgrm->psz_publisher ); - if( p_pgrm->psz_name ) - free( p_pgrm->psz_name ); + input_clock_Delete( p_pgrm->p_clock ); + free( p_pgrm->psz_now_playing ); + free( p_pgrm->psz_publisher ); + free( p_pgrm->psz_name ); if( p_pgrm->p_epg ) vlc_epg_Delete( p_pgrm->p_epg ); free( p_pgrm ); } TAB_CLEAN( p_sys->i_pgrm, p_sys->pgrm ); + vlc_mutex_destroy( &p_sys->lock ); free( p_sys ); free( out ); } -es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id ) +static mtime_t EsOutGetWakeup( es_out_t *out ) +{ + es_out_sys_t *p_sys = out->p_sys; + input_thread_t *p_input = p_sys->p_input; + + if( !p_sys->p_pgrm ) + return 0; + + /* We do not have a wake up date if the input cannot have its speed + * controlled or sout is imposing its own or while buffering + * + * FIXME for !p_input->b_can_pace_control a wkeup time is still needed to avoid too strong buffering */ + if( !p_input->b_can_pace_control || + p_input->p->b_out_pace_control || + p_sys->b_buffering ) + return 0; + + return input_clock_GetWakeup( p_sys->p_pgrm->p_clock ); +} + +static es_out_id_t *EsOutGetFromID( es_out_t *out, int i_id ) { int i; if( i_id < 0 ) { - /* Special HACK, -i_id is tha cat of the stream */ + /* Special HACK, -i_id is the cat of the stream */ return (es_out_id_t*)((uint8_t*)NULL-i_id); } @@ -302,33 +410,31 @@ es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id ) return NULL; } -static void EsOutDiscontinuity( es_out_t *out, vlc_bool_t b_flush, vlc_bool_t b_audio ) +static bool EsOutDecodersIsEmpty( es_out_t *out ) { es_out_sys_t *p_sys = out->p_sys; int i; + if( p_sys->b_buffering && p_sys->p_pgrm ) + { + EsOutDecodersStopBuffering( out, true ); + if( p_sys->b_buffering ) + return true; + } + for( i = 0; i < p_sys->i_es; i++ ) { es_out_id_t *es = p_sys->es[i]; - /* Send a dummy block to let decoder know that - * there is a discontinuity */ - if( es->p_dec && ( !b_audio || es->fmt.i_cat == AUDIO_ES ) ) - input_DecoderDiscontinuity( es->p_dec, b_flush ); + if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) ) + return false; + if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) ) + return false; } -} -void input_EsOutChangeRate( es_out_t *out ) -{ - es_out_sys_t *p_sys = out->p_sys; - int i; - - EsOutDiscontinuity( out, VLC_FALSE, VLC_FALSE ); - - for( i = 0; i < p_sys->i_pgrm; i++ ) - input_ClockSetRate( p_sys->p_input, &p_sys->pgrm[i]->clock ); + return true; } -void input_EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay ) +static void EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay ) { es_out_sys_t *p_sys = out->p_sys; @@ -336,77 +442,436 @@ void input_EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay ) p_sys->i_audio_delay = i_delay; else if( i_cat == SPU_ES ) p_sys->i_spu_delay = i_delay; + + for( int i = 0; i < p_sys->i_es; i++ ) + EsOutDecoderChangeDelay( out, p_sys->es[i] ); } -void input_EsOutChangeState( es_out_t *out ) + +static int EsOutSetRecord( es_out_t *out, bool b_record ) { - es_out_sys_t *p_sys = out->p_sys; + es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - if( p_input->i_state == PAUSE_S ) + assert( ( b_record && !p_sys->p_sout_record ) || ( !b_record && p_sys->p_sout_record ) ); + + if( b_record ) + { + char *psz_path = var_CreateGetString( p_input, "input-record-path" ); + if( !psz_path || *psz_path == '\0' ) + { + free( psz_path ); + psz_path = strdup( config_GetHomeDir() ); + } + + char *psz_sout = NULL; // TODO conf + + if( !psz_sout && psz_path ) + { + char *psz_file = input_CreateFilename( VLC_OBJECT(p_input), psz_path, INPUT_RECORD_PREFIX, NULL ); + if( psz_file ) + { + if( asprintf( &psz_sout, "#record{dst-prefix='%s'}", psz_file ) < 0 ) + psz_sout = NULL; + free( psz_file ); + } + } + free( psz_path ); + + if( !psz_sout ) + return VLC_EGENERIC; + +#ifdef ENABLE_SOUT + p_sys->p_sout_record = sout_NewInstance( p_input, psz_sout ); +#endif + free( psz_sout ); + + if( !p_sys->p_sout_record ) + return VLC_EGENERIC; + + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( !p_es->p_dec || p_es->p_master ) + continue; + + p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record ); + if( p_es->p_dec_record && p_sys->b_buffering ) + input_DecoderStartBuffering( p_es->p_dec_record ); + } + } + else + { + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( !p_es->p_dec_record ) + continue; + + input_DecoderDelete( p_es->p_dec_record ); + p_es->p_dec_record = NULL; + } +#ifdef ENABLE_SOUT + sout_DeleteInstance( p_sys->p_sout_record ); +#endif + p_sys->p_sout_record = NULL; + } + + return VLC_SUCCESS; +} +static void EsOutChangePause( es_out_t *out, bool b_paused, mtime_t i_date ) +{ + es_out_sys_t *p_sys = out->p_sys; + + /* XXX the order is important */ + if( b_paused ) { - /* Send discontinuity to decoders (it will allow them to flush - * * if implemented */ - EsOutDiscontinuity( out, VLC_FALSE, VLC_FALSE ); + EsOutDecodersChangePause( out, true, i_date ); + EsOutProgramChangePause( out, true, i_date ); } else { - /* Out of pause, reset pcr */ - es_out_Control( out, ES_OUT_RESET_PCR ); + if( p_sys->i_buffering_extra_initial > 0 ) + { + mtime_t i_stream_start; + mtime_t i_system_start; + mtime_t i_stream_duration; + mtime_t i_system_duration; + int i_ret; + i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock, + &i_stream_start, &i_system_start, + &i_stream_duration, &i_system_duration ); + if( !i_ret ) + { + /* FIXME pcr != exactly what wanted */ + const mtime_t i_used = /*(i_stream_duration - p_sys->p_input->i_pts_delay)*/ p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial; + i_date -= i_used; + } + p_sys->i_buffering_extra_initial = 0; + p_sys->i_buffering_extra_stream = 0; + p_sys->i_buffering_extra_system = 0; + } + EsOutProgramChangePause( out, false, i_date ); + EsOutDecodersChangePause( out, false, i_date ); + + EsOutProgramsChangeRate( out ); } + p_sys->b_paused = b_paused; + p_sys->i_pause_date = i_date; } -void input_EsOutChangePosition( es_out_t *out ) + +static void EsOutChangeRate( es_out_t *out, int i_rate ) { - //es_out_sys_t *p_sys = out->p_sys; + es_out_sys_t *p_sys = out->p_sys; + + p_sys->i_rate = i_rate; - es_out_Control( out, ES_OUT_RESET_PCR ); - EsOutDiscontinuity( out, VLC_TRUE, VLC_FALSE ); + if( !p_sys->b_paused ) + EsOutProgramsChangeRate( out ); } -vlc_bool_t input_EsOutDecodersEmpty( es_out_t *out ) +static void EsOutChangePosition( es_out_t *out ) { es_out_sys_t *p_sys = out->p_sys; - int i; - for( i = 0; i < p_sys->i_es; i++ ) + input_SendEventCache( p_sys->p_input, 0.0 ); + + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( !p_es->p_dec ) + continue; + + input_DecoderStartBuffering( p_es->p_dec ); + + if( p_es->p_dec_record ) + input_DecoderStartBuffering( p_es->p_dec ); + } + + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_Reset( p_sys->pgrm[i]->p_clock ); + + p_sys->b_buffering = true; + p_sys->i_buffering_extra_initial = 0; + p_sys->i_buffering_extra_stream = 0; + p_sys->i_buffering_extra_system = 0; + p_sys->i_preroll_end = -1; +} + + + +static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced ) +{ + es_out_sys_t *p_sys = out->p_sys; + int i_ret; + + mtime_t i_stream_start; + mtime_t i_system_start; + mtime_t i_stream_duration; + mtime_t i_system_duration; + i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock, + &i_stream_start, &i_system_start, + &i_stream_duration, &i_system_duration ); + assert( !i_ret || b_forced ); + if( i_ret ) + return; + + mtime_t i_preroll_duration = 0; + if( p_sys->i_preroll_end >= 0 ) + i_preroll_duration = __MAX( p_sys->i_preroll_end - i_stream_start, 0 ); + + const mtime_t i_buffering_duration = p_sys->p_input->i_pts_delay + + i_preroll_duration + + p_sys->i_buffering_extra_stream - p_sys->i_buffering_extra_initial; + + if( i_stream_duration <= i_buffering_duration && !b_forced ) + { + const double f_level = (double)i_stream_duration / i_buffering_duration; + input_SendEventCache( p_sys->p_input, f_level ); + + msg_Dbg( p_sys->p_input, "Buffering %d%%", (int)(100 * f_level) ); + return; + } + input_SendEventCache( p_sys->p_input, 1.0 ); + + msg_Dbg( p_sys->p_input, "Stream buffering done (%d ms in %d ms)", + (int)(i_stream_duration/1000), (int)(i_system_duration/1000) ); + p_sys->b_buffering = false; + p_sys->i_preroll_end = -1; + + if( p_sys->i_buffering_extra_initial > 0 ) + { + /* FIXME wrong ? */ + return; + } + + const mtime_t i_decoder_buffering_start = mdate(); + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( !p_es->p_dec ) + continue; + input_DecoderWaitBuffering( p_es->p_dec ); + if( p_es->p_dec_record ) + input_DecoderWaitBuffering( p_es->p_dec_record ); + } + + msg_Dbg( p_sys->p_input, "Decoder buffering done in %d ms", + (int)(mdate() - i_decoder_buffering_start)/1000 ); + + const mtime_t i_wakeup_delay = 10*1000; /* FIXME CLEANUP thread wake up time*/ + const mtime_t i_current_date = p_sys->b_paused ? p_sys->i_pause_date : mdate(); + + input_clock_ChangeSystemOrigin( p_sys->p_pgrm->p_clock, i_current_date + i_wakeup_delay - i_buffering_duration ); + + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( !p_es->p_dec ) + continue; + + input_DecoderStopBuffering( p_es->p_dec ); + if( p_es->p_dec_record ) + input_DecoderStopBuffering( p_es->p_dec ); + } +} +static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, mtime_t i_date ) +{ + es_out_sys_t *p_sys = out->p_sys; + + /* Pause decoders first */ + for( int i = 0; i < p_sys->i_es; i++ ) { es_out_id_t *es = p_sys->es[i]; - if( es->p_dec && !input_DecoderEmpty( es->p_dec ) ) - return VLC_FALSE; + if( es->p_dec ) + { + input_DecoderChangePause( es->p_dec, b_paused, i_date ); + if( es->p_dec_record ) + input_DecoderChangePause( es->p_dec_record, b_paused, i_date ); + } } - return VLC_TRUE; } +static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date ) +{ + es_out_sys_t *p_sys = out->p_sys; -/***************************************************************************** - * - *****************************************************************************/ -static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es, - vlc_bool_t b_delete ) + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_ChangePause( p_sys->pgrm[i]->p_clock, b_paused, i_date ); +} + +static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es ) +{ + es_out_sys_t *p_sys = out->p_sys; + + mtime_t i_delay = 0; + if( p_es->fmt.i_cat == AUDIO_ES ) + i_delay = p_sys->i_audio_delay; + else if( p_es->fmt.i_cat == SPU_ES ) + i_delay = p_sys->i_spu_delay; + + if( i_delay != 0 ) + { + if( p_es->p_dec ) + input_DecoderChangeDelay( p_es->p_dec, i_delay ); + if( p_es->p_dec_record ) + input_DecoderChangeDelay( p_es->p_dec_record, i_delay ); + } +} +static void EsOutProgramsChangeRate( es_out_t *out ) { es_out_sys_t *p_sys = out->p_sys; - input_thread_t *p_input = p_sys->p_input; - vlc_value_t val, text; - const char *psz_var; + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_ChangeRate( p_sys->pgrm[i]->p_clock, p_sys->i_rate ); +} - if( es->fmt.i_cat == AUDIO_ES ) - psz_var = "audio-es"; - else if( es->fmt.i_cat == VIDEO_ES ) - psz_var = "video-es"; - else if( es->fmt.i_cat == SPU_ES ) - psz_var = "spu-es"; - else +static void EsOutFrameNext( es_out_t *out ) +{ + es_out_sys_t *p_sys = out->p_sys; + es_out_id_t *p_es_video = NULL; + + if( p_sys->b_buffering ) + { + msg_Warn( p_sys->p_input, "buffering, ignoring 'frame next'" ); return; + } + + assert( p_sys->b_paused ); + + for( int i = 0; i < p_sys->i_es; i++ ) + { + es_out_id_t *p_es = p_sys->es[i]; + + if( p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec ) + { + p_es_video = p_es; + break; + } + } + + if( !p_es_video ) + { + msg_Warn( p_sys->p_input, "No video track selected, ignoring 'frame next'" ); + return; + } + + mtime_t i_duration; + input_DecoderFrameNext( p_es_video->p_dec, &i_duration ); + + msg_Dbg( out->p_sys->p_input, "EsOutFrameNext consummed %d ms", (int)(i_duration/1000) ); + + if( i_duration <= 0 ) + i_duration = 40*1000; + + /* FIXME it is not a clean way ? */ + if( p_sys->i_buffering_extra_initial <= 0 ) + { + mtime_t i_stream_start; + mtime_t i_system_start; + mtime_t i_stream_duration; + mtime_t i_system_duration; + int i_ret; + + i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock, + &i_stream_start, &i_system_start, + &i_stream_duration, &i_system_duration ); + if( i_ret ) + return; + + p_sys->i_buffering_extra_initial = 1 + i_stream_duration - p_sys->p_input->i_pts_delay; /* FIXME < 0 ? */ + p_sys->i_buffering_extra_system = + p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial; + } + + const int i_rate = input_clock_GetRate( p_sys->p_pgrm->p_clock ); + + p_sys->b_buffering = true; + p_sys->i_buffering_extra_system += i_duration; + p_sys->i_buffering_extra_stream = p_sys->i_buffering_extra_initial + + ( p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial ) * + INPUT_RATE_DEFAULT / i_rate; + + p_sys->i_preroll_end = -1; +} +static mtime_t EsOutGetBuffering( es_out_t *out ) +{ + es_out_sys_t *p_sys = out->p_sys; + + if( !p_sys->p_pgrm ) + return 0; + + int i_ret; + mtime_t i_stream_start; + mtime_t i_system_start; + mtime_t i_stream_duration; + mtime_t i_system_duration; + i_ret = input_clock_GetState( p_sys->p_pgrm->p_clock, + &i_stream_start, &i_system_start, + &i_stream_duration, &i_system_duration ); + + if( i_ret ) + return 0; + + mtime_t i_delay; + + if( p_sys->b_buffering && p_sys->i_buffering_extra_initial <= 0 ) + { + i_delay = i_stream_duration; + } + else + { + mtime_t i_system_duration; + if( p_sys->b_paused ) + { + i_system_duration = p_sys->i_pause_date - i_system_start; + if( p_sys->i_buffering_extra_initial > 0 ) + i_system_duration += p_sys->i_buffering_extra_system - p_sys->i_buffering_extra_initial; + } + else + { + i_system_duration = mdate() - i_system_start; + } + + const mtime_t i_consumed = i_system_duration * INPUT_RATE_DEFAULT / p_sys->i_rate - i_stream_duration; + i_delay = p_sys->p_input->i_pts_delay - i_consumed; + } + if( i_delay < 0 ) + return 0; + return i_delay; +} + +static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id, es_format_t *fmt, const char *psz_language, + bool b_delete ) +{ + es_out_sys_t *p_sys = out->p_sys; + input_thread_t *p_input = p_sys->p_input; + const bool b_teletext = fmt->i_cat == SPU_ES && fmt->i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' ); + vlc_value_t val, text; if( b_delete ) { - val.i_int = es->i_id; - var_Change( p_input, psz_var, VLC_VAR_DELCHOICE, &val, NULL ); - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + /* TODO it should probably be a list */ + if( b_teletext ) + input_SendEventTeletext( p_sys->p_input, -1 ); + + input_SendEventEsDel( p_input, SPU_ES, i_id ); return; } /* Get the number of ES already added */ + const char *psz_var; + if( fmt->i_cat == AUDIO_ES ) + psz_var = "audio-es"; + else if( fmt->i_cat == VIDEO_ES ) + psz_var = "video-es"; + else + psz_var = "spu-es"; + var_Change( p_input, psz_var, VLC_VAR_CHOICESCOUNT, &val, NULL ); if( val.i_int == 0 ) { @@ -419,41 +884,47 @@ static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es, } /* Take care of the ES description */ - if( es->fmt.psz_description && *es->fmt.psz_description ) + if( fmt->psz_description && *fmt->psz_description ) { - if( es->psz_language && *es->psz_language ) + if( psz_language && *psz_language ) { - text.psz_string = malloc( strlen( es->fmt.psz_description) + - strlen( es->psz_language ) + 10 ); - sprintf( text.psz_string, "%s - [%s]", es->fmt.psz_description, - es->psz_language ); + text.psz_string = malloc( strlen( fmt->psz_description) + + strlen( psz_language ) + 10 ); + sprintf( text.psz_string, "%s - [%s]", fmt->psz_description, + psz_language ); } - else text.psz_string = strdup( es->fmt.psz_description ); + else text.psz_string = strdup( fmt->psz_description ); } else { - if( es->psz_language && *es->psz_language ) + if( psz_language && *psz_language ) { - char *temp; - text.psz_string = malloc( strlen( _("Track %i") )+ - strlen( es->psz_language ) + 30 ); - asprintf( &temp, _("Track %i"), val.i_int ); - sprintf( text.psz_string, "%s - [%s]", temp, es->psz_language ); - free( temp ); + if( asprintf( &text.psz_string, "%s %i - [%s]", _( "Track" ), val.i_int, psz_language ) == -1 ) + text.psz_string = NULL; } else { - text.psz_string = malloc( strlen( _("Track %i") ) + 20 ); - sprintf( text.psz_string, _("Track %i"), val.i_int ); + if( asprintf( &text.psz_string, "%s %i", _( "Track" ), val.i_int ) == -1 ) + text.psz_string = NULL; } } - val.i_int = es->i_id; - var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val, &text ); + input_SendEventEsAdd( p_input, fmt->i_cat, i_id, text.psz_string ); free( text.psz_string ); - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + if( b_teletext ) + { + /* TODO it should probably be a list */ + if( var_GetInteger( p_sys->p_input, "teletext-es" ) < 0 ) + input_SendEventTeletext( p_sys->p_input, i_id ); + } +} + +static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es, + bool b_delete ) +{ + EsOutESVarUpdateGeneric( out, es->i_id, &es->fmt, es->psz_language, b_delete ); } /* EsOutProgramSelect: @@ -463,7 +934,6 @@ static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm ) { es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - vlc_value_t val; int i; if( p_sys->p_pgrm == p_pgrm ) @@ -476,9 +946,9 @@ static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm ) for( i = 0; i < p_sys->i_es; i++ ) { - if( p_sys->es[i]->p_pgrm == old && p_sys->es[i]->p_dec && + if( p_sys->es[i]->p_pgrm == old && EsIsSelected( p_sys->es[i] ) && p_sys->i_mode != ES_OUT_MODE_ALL ) - EsUnselect( out, p_sys->es[i], VLC_TRUE ); + EsUnselect( out, p_sys->es[i], true ); } p_sys->p_es_audio = NULL; @@ -489,38 +959,34 @@ static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm ) msg_Dbg( p_input, "selecting program id=%d", p_pgrm->i_id ); /* Mark it selected */ - p_pgrm->b_selected = VLC_TRUE; + p_pgrm->b_selected = true; /* Switch master stream */ - if( p_sys->p_pgrm && p_sys->p_pgrm->clock.b_master ) - { - p_sys->p_pgrm->clock.b_master = VLC_FALSE; - } - p_pgrm->clock.b_master = VLC_TRUE; p_sys->p_pgrm = p_pgrm; /* Update "program" */ - val.i_int = p_pgrm->i_id; - var_Change( p_input, "program", VLC_VAR_SETVALUE, &val, NULL ); + input_SendEventProgramSelect( p_input, p_pgrm->i_id ); /* Update "es-*" */ - var_Change( p_input, "audio-es", VLC_VAR_CLEARCHOICES, NULL, NULL ); - var_Change( p_input, "video-es", VLC_VAR_CLEARCHOICES, NULL, NULL ); - var_Change( p_input, "spu-es", VLC_VAR_CLEARCHOICES, NULL, NULL ); + input_SendEventEsDel( p_input, AUDIO_ES, -1 ); + input_SendEventEsDel( p_input, VIDEO_ES, -1 ); + input_SendEventEsDel( p_input, SPU_ES, -1 ); + + /* TODO event */ + var_SetInteger( p_input, "teletext-es", -1 ); + for( i = 0; i < p_sys->i_es; i++ ) { if( p_sys->es[i]->p_pgrm == p_sys->p_pgrm ) - EsOutESVarUpdate( out, p_sys->es[i], VLC_FALSE ); - EsOutSelect( out, p_sys->es[i], VLC_FALSE ); + EsOutESVarUpdate( out, p_sys->es[i], false ); + EsOutSelect( out, p_sys->es[i], false ); } /* Update now playing */ - input_item_SetNowPlaying( p_input->p->input.p_item, - p_pgrm->psz_now_playing ); - input_item_SetPublisher( p_input->p->input.p_item, - p_pgrm->psz_publisher ); + input_item_SetNowPlaying( p_input->p->p_item, p_pgrm->psz_now_playing ); + input_item_SetPublisher( p_input->p->p_item, p_pgrm->psz_publisher ); - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + input_SendEventMeta( p_input ); } /* EsOutAddProgram: @@ -530,35 +996,35 @@ static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group ) { es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - vlc_value_t val; es_out_pgrm_t *p_pgrm = malloc( sizeof( es_out_pgrm_t ) ); + if( !p_pgrm ) + return NULL; /* Init */ p_pgrm->i_id = i_group; p_pgrm->i_es = 0; - p_pgrm->b_selected = VLC_FALSE; + p_pgrm->b_selected = false; p_pgrm->psz_name = NULL; p_pgrm->psz_now_playing = NULL; p_pgrm->psz_publisher = NULL; p_pgrm->p_epg = NULL; - input_ClockInit( p_input, &p_pgrm->clock, VLC_FALSE, p_input->p->input.i_cr_average ); + p_pgrm->p_clock = input_clock_New( p_input->p->i_cr_average, p_sys->i_rate ); + if( !p_pgrm->p_clock ) + { + free( p_pgrm ); + return NULL; + } /* Append it */ TAB_APPEND( p_sys->i_pgrm, p_sys->pgrm, p_pgrm ); /* Update "program" variable */ - val.i_int = i_group; - var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, NULL ); + input_SendEventProgramAdd( p_input, i_group, NULL ); if( i_group == var_GetInteger( p_input, "program" ) ) - { EsOutProgramSelect( out, p_pgrm ); - } - else - { - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); - } + return p_pgrm; } @@ -570,7 +1036,6 @@ static int EsOutProgramDel( es_out_t *out, int i_group ) es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; es_out_pgrm_t *p_pgrm = NULL; - vlc_value_t val; int i; for( i = 0; i < p_sys->i_pgrm; i++ ) @@ -595,20 +1060,20 @@ static int EsOutProgramDel( es_out_t *out, int i_group ) TAB_REMOVE( p_sys->i_pgrm, p_sys->pgrm, p_pgrm ); /* If program is selected we need to unselect it */ - if( p_sys->p_pgrm == p_pgrm ) p_sys->p_pgrm = NULL; + if( p_sys->p_pgrm == p_pgrm ) + p_sys->p_pgrm = NULL; + + input_clock_Delete( p_pgrm->p_clock ); - if( p_pgrm->psz_name ) free( p_pgrm->psz_name ); - if( p_pgrm->psz_now_playing ) free( p_pgrm->psz_now_playing ); - if( p_pgrm->psz_publisher ) free( p_pgrm->psz_publisher ); + free( p_pgrm->psz_name ); + free( p_pgrm->psz_now_playing ); + free( p_pgrm->psz_publisher ); if( p_pgrm->p_epg ) vlc_epg_Delete( p_pgrm->p_epg ); free( p_pgrm ); /* Update "program" variable */ - val.i_int = i_group; - var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL ); - - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + input_SendEventProgramDel( p_input, i_group ); return VLC_SUCCESS; } @@ -619,9 +1084,15 @@ static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm ) { char *psz = NULL; if( p_pgrm->psz_name ) - asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id ); + { + if( asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id ) == -1 ) + return NULL; + } else - asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ); + { + if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 ) + return NULL; + } return psz; } @@ -642,7 +1113,9 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) !vlc_meta_Get( p_meta, vlc_meta_NowPlaying) && !vlc_meta_Get( p_meta, vlc_meta_Publisher) && vlc_dictionary_keys_count( &p_meta->extra_tags ) <= 0 ) - return; + { + return; + } /* Find program */ for( i = 0; i < p_sys->i_pgrm; i++ ) { @@ -662,9 +1135,6 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) /* Update the description text of the program */ if( psz_title && *psz_title ) { - vlc_value_t val; - vlc_value_t text; - if( !p_pgrm->psz_name || strcmp( p_pgrm->psz_name, psz_title ) ) { char *psz_cat = EsOutProgramGetMetaName( p_pgrm ); @@ -674,23 +1144,27 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) /* TODO update epg name */ free( psz_cat ); } - if( p_pgrm->psz_name ) free( p_pgrm->psz_name ); + free( p_pgrm->psz_name ); p_pgrm->psz_name = strdup( psz_title ); - /* ugly but it works */ - val.i_int = i_group; - var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL ); - + char *psz_text; if( psz_provider && *psz_provider ) { - asprintf( &text.psz_string, "%s [%s]", psz_title, psz_provider ); - var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, &text ); - free( text.psz_string ); + if( asprintf( &psz_text, "%s [%s]", psz_title, psz_provider ) < 0 ) + psz_text = NULL; } else { - text.psz_string = (char *)psz_title; - var_Change( p_input, "program", VLC_VAR_ADDCHOICE, &val, &text ); + psz_text = strdup( psz_title ); + } + + /* ugly but it works */ + if( psz_text ) + { + input_SendEventProgramDel( p_input, i_group ); + input_SendEventProgramAdd( p_input, i_group, psz_text ); + + free( psz_text ); } } @@ -698,7 +1172,10 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) if( psz_provider ) { if( p_sys->p_pgrm == p_pgrm ) - input_item_SetPublisher( p_input->p->input.p_item, psz_provider ); + { + input_item_SetPublisher( p_input->p->p_item, psz_provider ); + input_SendEventMeta( p_input ); + } input_Control( p_input, INPUT_ADD_INFO, psz_cat, input_MetaTypeToLocalizedString(vlc_meta_Publisher), psz_provider ); } char ** ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags ); @@ -721,14 +1198,14 @@ static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src ) for( i = 0; i < p_src->i_event; i++ ) { vlc_epg_event_t *p_evt = p_src->pp_event[i]; - vlc_bool_t b_add = VLC_TRUE; + bool b_add = true; int j; for( j = 0; j < p_dst->i_event; j++ ) { if( p_dst->pp_event[j]->i_start == p_evt->i_start && p_dst->pp_event[j]->i_duration == p_evt->i_duration ) { - b_add = VLC_FALSE; + b_add = false; break; } if( p_dst->pp_event[j]->i_start > p_evt->i_start ) @@ -815,14 +1292,16 @@ static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg ) free( psz_epg ); #endif /* Update now playing */ - if( p_pgrm->psz_now_playing ) - free( p_pgrm->psz_now_playing ); + free( p_pgrm->psz_now_playing ); p_pgrm->psz_now_playing = NULL; if( p_epg->p_current && p_epg->p_current->psz_name && *p_epg->p_current->psz_name ) p_pgrm->psz_now_playing = strdup( p_epg->p_current->psz_name ); if( p_pgrm == p_sys->p_pgrm ) - input_item_SetNowPlaying( p_input->p->input.p_item, p_pgrm->psz_now_playing ); + { + input_item_SetNowPlaying( p_input->p->p_item, p_pgrm->psz_now_playing ); + input_SendEventMeta( p_input ); + } if( p_pgrm->psz_now_playing ) { @@ -842,21 +1321,26 @@ static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg ) /* EsOutAdd: * Add an es_out */ -static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) +static es_out_id_t *EsOutAdd( es_out_t *out, const es_format_t *fmt ) { es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - es_out_id_t *es = malloc( sizeof( es_out_id_t ) ); - es_out_pgrm_t *p_pgrm = NULL; - int i; - if( fmt->i_group < 0 ) { msg_Err( p_input, "invalid group number" ); return NULL; } + es_out_id_t *es = malloc( sizeof( *es ) ); + es_out_pgrm_t *p_pgrm = NULL; + int i; + + if( !es ) + return NULL; + + vlc_mutex_lock( &p_sys->lock ); + /* Search the program */ for( i = 0; i < p_sys->i_pgrm; i++ ) { @@ -876,14 +1360,14 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) p_pgrm->i_es++; /* Set up ES */ - if( fmt->i_id < 0 ) - fmt->i_id = out->p_sys->i_id; - es->i_id = fmt->i_id; es->p_pgrm = p_pgrm; es_format_Copy( &es->fmt, fmt ); - es->i_preroll_end = -1; + if( es->fmt.i_id < 0 ) + es->fmt.i_id = out->p_sys->i_id; + es->i_id = es->fmt.i_id; + es->i_meta_id = out->p_sys->i_id; - switch( fmt->i_cat ) + switch( es->fmt.i_cat ) { case AUDIO_ES: { @@ -891,10 +1375,10 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) es->i_channel = p_sys->i_audio; - vlc_mutex_lock( &p_input->p->input.p_item->lock ); memset( &rg, 0, sizeof(rg) ); - vlc_audio_replay_gain_MergeFromMeta( &rg, p_input->p->input.p_item->p_meta ); - vlc_mutex_unlock( &p_input->p->input.p_item->lock ); + vlc_mutex_lock( &p_input->p->p_item->lock ); + vlc_audio_replay_gain_MergeFromMeta( &rg, p_input->p->p_item->p_meta ); + vlc_mutex_unlock( &p_input->p->p_item->lock ); for( i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ ) { @@ -914,11 +1398,11 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) case VIDEO_ES: es->i_channel = p_sys->i_video; - if( fmt->video.i_frame_rate && fmt->video.i_frame_rate_base ) + if( es->fmt.video.i_frame_rate && es->fmt.video.i_frame_rate_base ) vlc_ureduce( &es->fmt.video.i_frame_rate, &es->fmt.video.i_frame_rate_base, - fmt->video.i_frame_rate, - fmt->video.i_frame_rate_base, 0 ); + es->fmt.video.i_frame_rate, + es->fmt.video.i_frame_rate_base, 0 ); break; case SPU_ES: @@ -929,35 +1413,97 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) es->i_channel = 0; break; } - es->psz_language = LanguageGetName( fmt->psz_language ); /* remember so we only need to do it once */ - es->psz_language_code = LanguageGetCode( fmt->psz_language ); + es->psz_language = LanguageGetName( es->fmt.psz_language ); /* remember so we only need to do it once */ + es->psz_language_code = LanguageGetCode( es->fmt.psz_language ); es->p_dec = NULL; + es->p_dec_record = NULL; + for( i = 0; i < 4; i++ ) + es->pb_cc_present[i] = false; + es->p_master = NULL; if( es->p_pgrm == p_sys->p_pgrm ) - EsOutESVarUpdate( out, es, VLC_FALSE ); + EsOutESVarUpdate( out, es, false ); + + /* Select it if needed */ + EsOutSelect( out, es, false ); + + + TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es ); + p_sys->i_id++; /* always incremented */ + switch( es->fmt.i_cat ) + { + case AUDIO_ES: + p_sys->i_audio++; + break; + case SPU_ES: + p_sys->i_sub++; + break; + case VIDEO_ES: + p_sys->i_video++; + break; + } + + EsOutUpdateInfo( out, es, &es->fmt, NULL ); + + vlc_mutex_unlock( &p_sys->lock ); + + return es; +} + +static bool EsIsSelected( es_out_id_t *es ) +{ + if( es->p_master ) + { + bool b_decode = false; + if( es->p_master->p_dec ) + { + int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec ); + if( i_channel != -1 ) + input_DecoderGetCcState( es->p_master->p_dec, &b_decode, i_channel ); + } + return b_decode; + } + else + { + return es->p_dec != NULL; + } +} +static void EsCreateDecoder( es_out_t *out, es_out_id_t *p_es ) +{ + es_out_sys_t *p_sys = out->p_sys; + input_thread_t *p_input = p_sys->p_input; + + p_es->p_dec = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_input->p->p_sout ); + if( p_es->p_dec ) + { + if( p_sys->b_buffering ) + input_DecoderStartBuffering( p_es->p_dec ); + + if( !p_es->p_master && p_sys->p_sout_record ) + { + p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_es->p_pgrm->p_clock, p_sys->p_sout_record ); + if( p_es->p_dec_record && p_sys->b_buffering ) + input_DecoderStartBuffering( p_es->p_dec_record ); + } + } + + EsOutDecoderChangeDelay( out, p_es ); +} +static void EsDestroyDecoder( es_out_t *out, es_out_id_t *p_es ) +{ + VLC_UNUSED(out); - /* Select it if needed */ - EsOutSelect( out, es, VLC_FALSE ); + if( !p_es->p_dec ) + return; + input_DecoderDelete( p_es->p_dec ); + p_es->p_dec = NULL; - TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es ); - p_sys->i_id++; /* always incremented */ - switch( fmt->i_cat ) + if( p_es->p_dec_record ) { - case AUDIO_ES: - p_sys->i_audio++; - break; - case SPU_ES: - p_sys->i_sub++; - break; - case VIDEO_ES: - p_sys->i_video++; - break; + input_DecoderDelete( p_es->p_dec_record ); + p_es->p_dec_record = NULL; } - - EsOutAddInfo( out, es ); - - return es; } static void EsSelect( es_out_t *out, es_out_id_t *es ) @@ -965,84 +1511,105 @@ static void EsSelect( es_out_t *out, es_out_id_t *es ) es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; vlc_value_t val; - const char *psz_var; - if( es->p_dec ) + if( EsIsSelected( es ) ) { msg_Warn( p_input, "ES 0x%x is already selected", es->i_id ); return; } - if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES ) + if( es->p_master ) { - if( !var_GetBool( p_input, "video" ) || - ( p_input->p->p_sout && !var_GetBool( p_input, "sout-video" ) ) ) - { - msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x", - es->i_id ); + int i_channel; + if( !es->p_master->p_dec ) + return; + + i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec ); + if( i_channel == -1 || input_DecoderSetCcState( es->p_master->p_dec, true, i_channel ) ) return; - } } - else if( es->fmt.i_cat == AUDIO_ES ) + else { - var_Get( p_input, "audio", &val ); - if( !var_GetBool( p_input, "audio" ) || - ( p_input->p->p_sout && !var_GetBool( p_input, "sout-audio" ) ) ) + if( es->fmt.i_cat == VIDEO_ES || es->fmt.i_cat == SPU_ES ) { - msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x", - es->i_id ); - return; + if( !var_GetBool( p_input, out->b_sout ? "sout-video" : "video" ) ) + { + msg_Dbg( p_input, "video is disabled, not selecting ES 0x%x", + es->i_id ); + return; + } } - } - if( es->fmt.i_cat == SPU_ES ) - { - var_Get( p_input, "spu", &val ); - if( !var_GetBool( p_input, "spu" ) || - ( p_input->p->p_sout && !var_GetBool( p_input, "sout-spu" ) ) ) + else if( es->fmt.i_cat == AUDIO_ES ) { - msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x", - es->i_id ); - return; + var_Get( p_input, "audio", &val ); + if( !var_GetBool( p_input, out->b_sout ? "sout-audio" : "audio" ) ) + { + msg_Dbg( p_input, "audio is disabled, not selecting ES 0x%x", + es->i_id ); + return; + } + } + if( es->fmt.i_cat == SPU_ES ) + { + var_Get( p_input, "spu", &val ); + if( !var_GetBool( p_input, out->b_sout ? "sout-spu" : "spu" ) ) + { + msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x", + es->i_id ); + return; + } } - } - es->i_preroll_end = -1; - es->p_dec = input_DecoderNew( p_input, &es->fmt, VLC_FALSE ); - if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm ) - return; + EsCreateDecoder( out, es ); - if( es->fmt.i_cat == VIDEO_ES ) - psz_var = "video-es"; - else if( es->fmt.i_cat == AUDIO_ES ) - psz_var = "audio-es"; - else if( es->fmt.i_cat == SPU_ES ) - psz_var = "spu-es"; - else - return; + if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm ) + return; + } /* Mark it as selected */ - val.i_int = es->i_id; - var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL ); - - - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + input_SendEventEsSelect( p_input, es->fmt.i_cat, es->i_id ); } -static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update ) +static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update ) { es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - vlc_value_t val; - const char *psz_var; - if( es->p_dec == NULL ) + if( !EsIsSelected( es ) ) { msg_Warn( p_input, "ES 0x%x is already unselected", es->i_id ); return; } - input_DecoderDelete( es->p_dec ); - es->p_dec = NULL; + if( es->p_master ) + { + if( es->p_master->p_dec ) + { + int i_channel = EsOutGetClosedCaptionsChannel( es->fmt.i_codec ); + if( i_channel != -1 ) + input_DecoderSetCcState( es->p_master->p_dec, false, i_channel ); + } + } + else + { + const int i_spu_id = var_GetInteger( p_input, "spu-es"); + int i; + for( i = 0; i < 4; i++ ) + { + if( !es->pb_cc_present[i] || !es->pp_cc_es[i] ) + continue; + + if( i_spu_id == es->pp_cc_es[i]->i_id ) + { + /* Force unselection of the CC */ + input_SendEventEsSelect( p_input, SPU_ES, -1 ); + } + EsOutDel( out, es->pp_cc_es[i] ); + + es->pb_cc_present[i] = false; + } + EsDestroyDecoder( out, es ); + } if( !b_update ) return; @@ -1050,20 +1617,9 @@ static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update ) /* Update var */ if( es->p_dec == NULL ) return; - if( es->fmt.i_cat == VIDEO_ES ) - psz_var = "video-es"; - else if( es->fmt.i_cat == AUDIO_ES ) - psz_var = "audio-es"; - else if( es->fmt.i_cat == SPU_ES ) - psz_var = "spu-es"; - else - return; - - /* Mark it as selected */ - val.i_int = -1; - var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL ); - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + /* Mark it as unselected */ + input_SendEventEsSelect( p_input, es->fmt.i_cat, -1 ); } /** @@ -1075,7 +1631,7 @@ static void EsUnselect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_update ) * \param b_force ... * \return nothing */ -static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) +static void EsOutSelect( es_out_t *out, es_out_id_t *es, bool b_force ) { es_out_sys_t *p_sys = out->p_sys; @@ -1089,7 +1645,7 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) if( p_sys->i_mode == ES_OUT_MODE_ALL || b_force ) { - if( !es->p_dec ) + if( !EsIsSelected( es ) ) EsSelect( out, es ); } else if( p_sys->i_mode == ES_OUT_MODE_PARTIAL ) @@ -1101,7 +1657,7 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) { if ( val.p_list->p_values[i].i_int == es->p_pgrm->i_id || b_force ) { - if( !es->p_dec ) + if( !EsIsSelected( es ) ) EsSelect( out, es ); break; } @@ -1202,21 +1758,21 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) i_wanted = es->i_channel; } - if( i_wanted == es->i_channel && es->p_dec == NULL ) + if( i_wanted == es->i_channel && !EsIsSelected( es ) ) EsSelect( out, es ); } /* FIXME TODO handle priority here */ - if( es->p_dec ) + if( EsIsSelected( es ) ) { if( i_cat == AUDIO_ES ) { if( p_sys->i_mode == ES_OUT_MODE_AUTO && p_sys->p_es_audio && p_sys->p_es_audio != es && - p_sys->p_es_audio->p_dec ) + EsIsSelected( p_sys->p_es_audio ) ) { - EsUnselect( out, p_sys->p_es_audio, VLC_FALSE ); + EsUnselect( out, p_sys->p_es_audio, false ); } p_sys->p_es_audio = es; } @@ -1225,9 +1781,9 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) if( p_sys->i_mode == ES_OUT_MODE_AUTO && p_sys->p_es_sub && p_sys->p_es_sub != es && - p_sys->p_es_sub->p_dec ) + EsIsSelected( p_sys->p_es_sub ) ) { - EsUnselect( out, p_sys->p_es_sub, VLC_FALSE ); + EsUnselect( out, p_sys->p_es_sub, false ); } p_sys->p_es_sub = es; } @@ -1247,20 +1803,11 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) */ static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block ) { - es_out_sys_t *p_sys = out->p_sys; - input_thread_t *p_input = p_sys->p_input; - es_out_pgrm_t *p_pgrm = es->p_pgrm; - int64_t i_delay; - int i_total=0; - - if( es->fmt.i_cat == AUDIO_ES ) - i_delay = p_sys->i_audio_delay; - else if( es->fmt.i_cat == SPU_ES ) - i_delay = p_sys->i_spu_delay; - else - i_delay = 0; + es_out_sys_t *p_sys = out->p_sys; + input_thread_t *p_input = p_sys->p_input; + int i_total = 0; - if( p_input->p_libvlc->b_stats ) + if( libvlc_stats( p_input ) ) { vlc_mutex_lock( &p_input->p->counters.counters_lock ); stats_UpdateInteger( p_input, p_input->p->counters.p_demux_read, @@ -1270,66 +1817,81 @@ static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block ) vlc_mutex_unlock( &p_input->p->counters.counters_lock ); } + vlc_mutex_lock( &p_sys->lock ); + /* Mark preroll blocks */ - if( es->i_preroll_end >= 0 ) + if( p_sys->i_preroll_end >= 0 ) { int64_t i_date = p_block->i_pts; if( i_date <= 0 ) i_date = p_block->i_dts; - if( i_date < es->i_preroll_end ) + if( i_date < p_sys->i_preroll_end ) p_block->i_flags |= BLOCK_FLAG_PREROLL; - else - es->i_preroll_end = -1; } - if( p_block->i_dts > 0 && (p_block->i_flags&BLOCK_FLAG_PREROLL) ) - { - p_block->i_dts += i_delay; - } - else if( p_block->i_dts > 0 ) - { - p_block->i_dts = - input_ClockGetTS( p_input, &p_pgrm->clock, p_block->i_dts ) + i_delay; - } - if( p_block->i_pts > 0 && (p_block->i_flags&BLOCK_FLAG_PREROLL) ) + p_block->i_rate = 0; + + if( !es->p_dec ) { - p_block->i_pts += i_delay; + block_Release( p_block ); + vlc_mutex_unlock( &p_sys->lock ); + return VLC_SUCCESS; } - else if( p_block->i_pts > 0 ) + + /* Decode */ + if( es->p_dec_record ) { - p_block->i_pts = - input_ClockGetTS( p_input, &p_pgrm->clock, p_block->i_pts ) + i_delay; + block_t *p_dup = block_Duplicate( p_block ); + if( p_dup ) + input_DecoderDecode( es->p_dec_record, p_dup ); } - if ( es->fmt.i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' ) ) + input_DecoderDecode( es->p_dec, p_block ); + + es_format_t fmt_dsc; + vlc_meta_t *p_meta_dsc; + if( input_DecoderHasFormatChanged( es->p_dec, &fmt_dsc, &p_meta_dsc ) ) { - mtime_t current_date = mdate(); - if( !p_block->i_pts - || p_block->i_pts > current_date + 10000000 - || current_date > p_block->i_pts ) - { - /* ETSI EN 300 472 Annex A : do not take into account the PTS - * for teletext streams. */ - p_block->i_pts = current_date + 400000 - + p_input->i_pts_delay + i_delay; - } + EsOutUpdateInfo( out, es, &fmt_dsc, p_meta_dsc ); + + es_format_Clean( &fmt_dsc ); + if( p_meta_dsc ) + vlc_meta_Delete( p_meta_dsc ); } - p_block->i_rate = p_input->p->i_rate; + /* Check CC status */ + bool pb_cc[4]; - /* TODO handle mute */ - if( es->p_dec && - ( es->fmt.i_cat != AUDIO_ES || - ( p_input->p->i_rate >= INPUT_RATE_DEFAULT/AOUT_MAX_INPUT_RATE && - p_input->p->i_rate <= INPUT_RATE_DEFAULT*AOUT_MAX_INPUT_RATE ) ) ) - { - input_DecoderDecode( es->p_dec, p_block ); - } - else + input_DecoderIsCcPresent( es->p_dec, pb_cc ); + for( int i = 0; i < 4; i++ ) { - block_Release( p_block ); + static const vlc_fourcc_t fcc[4] = { + VLC_FOURCC('c', 'c', '1', ' '), + VLC_FOURCC('c', 'c', '2', ' '), + VLC_FOURCC('c', 'c', '3', ' '), + VLC_FOURCC('c', 'c', '4', ' '), + }; + es_format_t fmt; + + if( es->pb_cc_present[i] || !pb_cc[i] ) + continue; + msg_Dbg( p_input, "Adding CC track %d for es[%d]", 1+i, es->i_id ); + + es_format_Init( &fmt, SPU_ES, fcc[i] ); + fmt.i_group = es->fmt.i_group; + if( asprintf( &fmt.psz_description, + _("Closed captions %u"), 1 + i ) == -1 ) + fmt.psz_description = NULL; + es->pp_cc_es[i] = EsOutAdd( out, &fmt ); + es->pp_cc_es[i]->p_master = es; + es_format_Clean( &fmt ); + + /* */ + es->pb_cc_present[i] = true; } + vlc_mutex_unlock( &p_sys->lock ); + return VLC_SUCCESS; } @@ -1339,23 +1901,28 @@ static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block ) static void EsOutDel( es_out_t *out, es_out_id_t *es ) { es_out_sys_t *p_sys = out->p_sys; - vlc_bool_t b_reselect = VLC_FALSE; + bool b_reselect = false; int i; + vlc_mutex_lock( &p_sys->lock ); + /* We don't try to reselect */ if( es->p_dec ) { - while( !out->p_sys->p_input->b_die && es->p_dec ) + while( !p_sys->p_input->b_die && !p_sys->b_buffering && es->p_dec ) { - if( input_DecoderEmpty( es->p_dec ) ) + if( input_DecoderIsEmpty( es->p_dec ) && + ( !es->p_dec_record || input_DecoderIsEmpty( es->p_dec_record ) )) break; + /* FIXME there should be a way to have auto deleted es, but there will be + * a problem when another codec of the same type is created (mainly video) */ msleep( 20*1000 ); } EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm ); } if( es->p_pgrm == p_sys->p_pgrm ) - EsOutESVarUpdate( out, es, VLC_TRUE ); + EsOutESVarUpdate( out, es, true ); TAB_REMOVE( p_sys->i_es, p_sys->es, es ); @@ -1366,7 +1933,7 @@ static void EsOutDel( es_out_t *out, es_out_id_t *es ) } if( p_sys->p_es_audio == es || p_sys->p_es_video == es || - p_sys->p_es_sub == es ) b_reselect = VLC_TRUE; + p_sys->p_es_sub == es ) b_reselect = true; if( p_sys->p_es_audio == es ) p_sys->p_es_audio = NULL; if( p_sys->p_es_video == es ) p_sys->p_es_video = NULL; @@ -1387,19 +1954,21 @@ static void EsOutDel( es_out_t *out, es_out_id_t *es ) /* Re-select another track when needed */ if( b_reselect ) + { for( i = 0; i < p_sys->i_es; i++ ) { if( es->fmt.i_cat == p_sys->es[i]->fmt.i_cat ) - EsOutSelect( out, p_sys->es[i], VLC_FALSE ); + EsOutSelect( out, p_sys->es[i], false ); } + } - if( es->psz_language ) - free( es->psz_language ); - if( es->psz_language_code ) - free( es->psz_language_code ); + free( es->psz_language ); + free( es->psz_language_code ); es_format_Clean( &es->fmt ); + vlc_mutex_unlock( &p_sys->lock ); + free( es ); } @@ -1411,11 +1980,11 @@ static void EsOutDel( es_out_t *out, es_out_id_t *es ) * \param args a variable list of arguments for the query * \return VLC_SUCCESS or an error code */ -static int EsOutControl( es_out_t *out, int i_query, va_list args ) +static int EsOutControlLocked( es_out_t *out, int i_query, va_list args ) { es_out_sys_t *p_sys = out->p_sys; - vlc_bool_t b, *pb; - int i, *pi; + bool b, *pb; + int i; es_out_id_t *es; @@ -1423,13 +1992,13 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) { case ES_OUT_SET_ES_STATE: es = (es_out_id_t*) va_arg( args, es_out_id_t * ); - b = (vlc_bool_t) va_arg( args, vlc_bool_t ); - if( b && es->p_dec == NULL ) + b = (bool) va_arg( args, int ); + if( b && !EsIsSelected( es ) ) { EsSelect( out, es ); - return es->p_dec ? VLC_SUCCESS : VLC_EGENERIC; + return EsIsSelected( es ) ? VLC_SUCCESS : VLC_EGENERIC; } - else if( !b && es->p_dec ) + else if( !b && EsIsSelected( es ) ) { EsUnselect( out, es, es->p_pgrm == p_sys->p_pgrm ); return VLC_SUCCESS; @@ -1438,26 +2007,18 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) case ES_OUT_GET_ES_STATE: es = (es_out_id_t*) va_arg( args, es_out_id_t * ); - pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * ); + pb = (bool*) va_arg( args, bool * ); - *pb = es->p_dec ? VLC_TRUE : VLC_FALSE; + *pb = EsIsSelected( es ); return VLC_SUCCESS; case ES_OUT_SET_ACTIVE: { - b = (vlc_bool_t) va_arg( args, vlc_bool_t ); + b = (bool) va_arg( args, int ); p_sys->b_active = b; - /* Needed ? */ - if( b ) - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); return VLC_SUCCESS; } - case ES_OUT_GET_ACTIVE: - pb = (vlc_bool_t*) va_arg( args, vlc_bool_t * ); - *pb = p_sys->b_active; - return VLC_SUCCESS; - case ES_OUT_SET_MODE: i = (int) va_arg( args, int ); if( i == ES_OUT_MODE_NONE || i == ES_OUT_MODE_ALL || @@ -1468,7 +2029,7 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) /* Reapply policy mode */ for( i = 0; i < p_sys->i_es; i++ ) { - if( p_sys->es[i]->p_dec ) + if( EsIsSelected( p_sys->es[i] ) ) { EsUnselect( out, p_sys->es[i], p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); @@ -1476,81 +2037,67 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) } for( i = 0; i < p_sys->i_es; i++ ) { - EsOutSelect( out, p_sys->es[i], VLC_FALSE ); + EsOutSelect( out, p_sys->es[i], false ); } return VLC_SUCCESS; } return VLC_EGENERIC; - case ES_OUT_GET_MODE: - pi = (int*) va_arg( args, int* ); - *pi = p_sys->i_mode; - return VLC_SUCCESS; - case ES_OUT_SET_ES: + case ES_OUT_RESTART_ES: + { + int i_cat; + es = (es_out_id_t*) va_arg( args, es_out_id_t * ); - /* Special case NULL, NULL+i_cat */ + if( es == NULL ) - { - for( i = 0; i < p_sys->i_es; i++ ) - { - if( p_sys->es[i]->p_dec ) - EsUnselect( out, p_sys->es[i], - p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); - } - } + i_cat = UNKNOWN_ES; else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) ) - { - for( i = 0; i < p_sys->i_es; i++ ) - { - if( p_sys->es[i]->p_dec && - p_sys->es[i]->fmt.i_cat == AUDIO_ES ) - EsUnselect( out, p_sys->es[i], - p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); - } - } + i_cat = AUDIO_ES; else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) ) - { - for( i = 0; i < p_sys->i_es; i++ ) - { - if( p_sys->es[i]->p_dec && - p_sys->es[i]->fmt.i_cat == VIDEO_ES ) - EsUnselect( out, p_sys->es[i], - p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); - } - } + i_cat = VIDEO_ES; else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) ) - { - for( i = 0; i < p_sys->i_es; i++ ) - { - if( p_sys->es[i]->p_dec && - p_sys->es[i]->fmt.i_cat == SPU_ES ) - EsUnselect( out, p_sys->es[i], - p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); - } - } + i_cat = SPU_ES; else + i_cat = -1; + + for( i = 0; i < p_sys->i_es; i++ ) { - for( i = 0; i < p_sys->i_es; i++ ) + if( i_cat == -1 ) { if( es == p_sys->es[i] ) { - EsOutSelect( out, es, VLC_TRUE ); + EsOutSelect( out, es, true ); break; } } - } - { - playlist_t * p_playlist = pl_Yield( p_sys->p_input ); - PL_LOCK; - p_playlist->gc_date = mdate(); - vlc_object_signal_unlocked( p_playlist ); - PL_UNLOCK; - pl_Release( p_playlist ); + else + { + if( i_cat == UNKNOWN_ES || p_sys->es[i]->fmt.i_cat == i_cat ) + { + if( EsIsSelected( p_sys->es[i] ) ) + { + if( i_query == ES_OUT_RESTART_ES ) + { + if( p_sys->es[i]->p_dec ) + { + EsDestroyDecoder( out, p_sys->es[i] ); + EsCreateDecoder( out, p_sys->es[i] ); + } + } + else + { + EsUnselect( out, p_sys->es[i], + p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); + } + } + } + } } return VLC_SUCCESS; + } - case ES_OUT_SET_DEFAULT: + case ES_OUT_SET_ES_DEFAULT: { es = (es_out_id_t*) va_arg( args, es_out_id_t * ); @@ -1614,14 +2161,20 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */ i_pcr = (int64_t)va_arg( args, int64_t ); - /* search program */ - input_ClockSetPCR( p_sys->p_input, &p_pgrm->clock, i_pcr ); + /* search program + * TODO do not use mdate() but proper stream acquisition date */ + input_clock_Update( p_pgrm->p_clock, VLC_OBJECT(p_sys->p_input), + p_sys->p_input->b_can_pace_control || p_sys->b_buffering, i_pcr, mdate() ); + /* Check buffering state on master clock update */ + if( p_sys->b_buffering && p_pgrm == p_sys->p_pgrm ) + EsOutDecodersStopBuffering( out, false ); + return VLC_SUCCESS; } case ES_OUT_RESET_PCR: - for( i = 0; i < p_sys->i_pgrm; i++ ) - input_ClockResetPCR( p_sys->p_input, &p_sys->pgrm[i]->clock ); + msg_Err( p_sys->p_input, "ES_OUT_RESET_PCR called" ); + EsOutChangePosition( out ); return VLC_SUCCESS; case ES_OUT_GET_TS: @@ -1629,20 +2182,12 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) { int64_t i_ts = (int64_t)va_arg( args, int64_t ); int64_t *pi_ts = (int64_t *)va_arg( args, int64_t * ); - *pi_ts = input_ClockGetTS( p_sys->p_input, - &p_sys->p_pgrm->clock, i_ts ); + *pi_ts = input_clock_GetTS( p_sys->p_pgrm->p_clock, NULL, + p_sys->p_input->i_pts_delay, i_ts ); return VLC_SUCCESS; } return VLC_EGENERIC; - case ES_OUT_GET_GROUP: - pi = (int*) va_arg( args, int* ); - if( p_sys->p_pgrm ) - *pi = p_sys->p_pgrm->i_id; - else - *pi = -1; /* FIXME */ - return VLC_SUCCESS; - case ES_OUT_SET_GROUP: { int j; @@ -1659,14 +2204,15 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) return VLC_EGENERIC; } - case ES_OUT_SET_FMT: + case ES_OUT_SET_ES_FMT: { /* This ain't pretty but is need by some demuxers (eg. Ogg ) * to update the p_extra data */ es_format_t *p_fmt; es = (es_out_id_t*) va_arg( args, es_out_id_t * ); p_fmt = (es_format_t*) va_arg( args, es_format_t * ); - if( es == NULL ) return VLC_EGENERIC; + if( es == NULL ) + return VLC_EGENERIC; if( p_fmt->i_extra ) { @@ -1674,13 +2220,12 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) es->fmt.p_extra = realloc( es->fmt.p_extra, p_fmt->i_extra ); memcpy( es->fmt.p_extra, p_fmt->p_extra, p_fmt->i_extra ); - if( !es->p_dec ) return VLC_SUCCESS; - + if( !es->p_dec ) + return VLC_SUCCESS; #if 1 - input_DecoderDelete( es->p_dec ); - es->p_dec = input_DecoderNew( p_sys->p_input, - &es->fmt, VLC_FALSE ); + EsDestroyDecoder( out, es ); + EsCreateDecoder( out, es ); #else es->p_dec->fmt_in.i_extra = p_fmt->i_extra; es->p_dec->fmt_in.p_extra = @@ -1695,18 +2240,12 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) case ES_OUT_SET_NEXT_DISPLAY_TIME: { - int64_t i_date; - - es = (es_out_id_t*) va_arg( args, es_out_id_t * ); - i_date = (int64_t)va_arg( args, int64_t ); + const int64_t i_date = (int64_t)va_arg( args, int64_t ); - if( !es || !es->p_dec ) + if( i_date < 0 ) return VLC_EGENERIC; - /* XXX We should call input_ClockGetTS but PCR has been reseted - * and it will return 0, so we won't call input_ClockGetTS on all preroll samples - * but that's ugly(more time discontinuity), it need to be improved -- fenrir */ - es->i_preroll_end = i_date; + p_sys->i_preroll_end = i_date; return VLC_SUCCESS; } @@ -1733,11 +2272,130 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) return EsOutProgramDel( out, i_group ); } + case ES_OUT_GET_WAKE_UP: + { + mtime_t *pi_wakeup = (mtime_t*)va_arg( args, mtime_t* ); + *pi_wakeup = EsOutGetWakeup( out ); + return VLC_SUCCESS; + } + + case ES_OUT_SET_ES_BY_ID: + case ES_OUT_RESTART_ES_BY_ID: + case ES_OUT_SET_ES_DEFAULT_BY_ID: + { + const int i_id = (int)va_arg( args, int ); + es_out_id_t *p_es = EsOutGetFromID( out, i_id ); + int i_new_query; + + switch( i_query ) + { + case ES_OUT_SET_ES_BY_ID: i_new_query = ES_OUT_SET_ES; break; + case ES_OUT_RESTART_ES_BY_ID: i_new_query = ES_OUT_RESTART_ES; break; + case ES_OUT_SET_ES_DEFAULT_BY_ID: i_new_query = ES_OUT_SET_ES_DEFAULT; break; + default: + assert(0); + } + /* TODO if the lock is made non recursive it should be changed */ + return es_out_Control( out, i_new_query, p_es ); + } + + case ES_OUT_GET_BUFFERING: + pb = (bool *)va_arg( args, bool* ); + *pb = p_sys->b_buffering; + return VLC_SUCCESS; + + case ES_OUT_GET_EMPTY: + pb = (bool *)va_arg( args, bool* ); + *pb = EsOutDecodersIsEmpty( out ); + return VLC_SUCCESS; + + case ES_OUT_SET_DELAY: + { + const int i_cat = (int)va_arg( args, int ); + const mtime_t i_delay = (mtime_t)va_arg( args, mtime_t ); + EsOutSetDelay( out, i_cat, i_delay ); + return VLC_SUCCESS; + } + + case ES_OUT_SET_RECORD_STATE: + b = (bool) va_arg( args, int ); + return EsOutSetRecord( out, b ); + + case ES_OUT_SET_PAUSE_STATE: + { + const bool b_source_paused = (bool)va_arg( args, int ); + const bool b_paused = (bool)va_arg( args, int ); + const mtime_t i_date = (mtime_t) va_arg( args, mtime_t ); + + assert( !b_source_paused == !b_paused ); + EsOutChangePause( out, b_paused, i_date ); + + return VLC_SUCCESS; + } + + case ES_OUT_SET_RATE: + { + const int i_src_rate = (int)va_arg( args, int ); + const int i_rate = (int)va_arg( args, int ); + + assert( i_src_rate == i_rate ); + EsOutChangeRate( out, i_rate ); + + return VLC_SUCCESS; + } + + case ES_OUT_SET_TIME: + { + const mtime_t i_date = (mtime_t)va_arg( args, mtime_t ); + + assert( i_date == -1 ); + EsOutChangePosition( out ); + + return VLC_SUCCESS; + } + + case ES_OUT_SET_FRAME_NEXT: + EsOutFrameNext( out ); + return VLC_SUCCESS; + + case ES_OUT_SET_TIMES: + { + double f_position = (double)va_arg( args, double ); + mtime_t i_time = (mtime_t)va_arg( args, mtime_t ); + mtime_t i_length = (mtime_t)va_arg( args, mtime_t ); + + /* Fix for buffering delay */ + const mtime_t i_delay = EsOutGetBuffering( out ); + + i_time -= i_delay; + if( i_time < 0 ) + i_time = 0; + + if( i_length > 0 ) + f_position -= (double)i_delay / i_length; + if( f_position < 0 ) + f_position = 0; + + input_SendEventTimes( p_sys->p_input, f_position, i_time, i_length ); + return VLC_SUCCESS; + } + default: msg_Err( p_sys->p_input, "unknown query in es_out_Control" ); return VLC_EGENERIC; } } +static int EsOutControl( es_out_t *out, int i_query, va_list args ) +{ + es_out_sys_t *p_sys = out->p_sys; + int i_ret; + + vlc_mutex_lock( &p_sys->lock ); + i_ret = EsOutControlLocked( out, i_query, args ); + vlc_mutex_unlock( &p_sys->lock ); + + return i_ret; +} /**************************************************************************** * LanguageGetName: try to expend iso639 into plain name @@ -1825,10 +2483,21 @@ static char **LanguageSplit( const char *psz_langs ) psz = strchr(psz_parser, ',' ); if( psz ) *psz++ = '\0'; - psz_code = LanguageGetCode( psz_parser ); - if( strcmp( psz_code, "??" ) ) + if( !strcmp( psz_parser, "any" ) ) + { + TAB_APPEND( i_psz, ppsz, strdup("any") ); + } + else { - TAB_APPEND( i_psz, ppsz, psz_code ); + psz_code = LanguageGetCode( psz_parser ); + if( strcmp( psz_code, "??" ) ) + { + TAB_APPEND( i_psz, ppsz, psz_code ); + } + else + { + free( psz_code ); + } } psz_parser = psz; @@ -1850,40 +2519,81 @@ static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang ) if( !ppsz_langs || !psz_lang ) return -1; for( i = 0; ppsz_langs[i]; i++ ) - if( !strcasecmp( ppsz_langs[i], psz_lang ) ) return i; + { + if( !strcasecmp( ppsz_langs[i], psz_lang ) || + !strcasecmp( ppsz_langs[i], "any" ) ) + { + return i; + } + } return -1; } /**************************************************************************** - * EsOutAddInfo: + * EsOutUpdateInfo: * - add meta info to the playlist item ****************************************************************************/ -static void EsOutAddInfo( es_out_t *out, es_out_id_t *es ) +static void EsOutUpdateInfo( es_out_t *out, es_out_id_t *es, const es_format_t *fmt, const vlc_meta_t *p_meta ) { es_out_sys_t *p_sys = out->p_sys; input_thread_t *p_input = p_sys->p_input; - es_format_t *fmt = &es->fmt; + const es_format_t *p_fmt_es = &es->fmt; char *psz_cat; lldiv_t div; - /* Add stream info */ - asprintf( &psz_cat, _("Stream %d"), out->p_sys->i_id - 1 ); + /* Create category name */ + if( asprintf( &psz_cat, _("Stream %d"), es->i_meta_id ) == -1 ) + return; + + /* Remove previous information */ + input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL ); + + /* Add informations */ + const char *psz_type; + switch( fmt->i_cat ) + { + case AUDIO_ES: + psz_type = _("Audio"); + break; + case VIDEO_ES: + psz_type = _("Video"); + break; + case SPU_ES: + psz_type = _("Subtitle"); + break; + default: + psz_type = NULL; + break; + } + + if( psz_type ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Type"), psz_type ); + + if( es->i_meta_id != es->i_id ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Original ID"), + "%d", es->i_id ); input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Codec"), - "%.4s", (char*)&fmt->i_codec ); + "%.4s", (char*)&p_fmt_es->i_codec ); - input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"), - "%s", es->psz_language ); + if( es->psz_language && *es->psz_language ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Language"), + "%s", es->psz_language ); + if( fmt->psz_description && *fmt->psz_description ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Description"), + "%s", fmt->psz_description ); - /* Add information */ switch( fmt->i_cat ) { case AUDIO_ES: input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Type"), _("Audio") ); - if( fmt->audio.i_channels > 0 ) + if( fmt->audio.i_physical_channels & AOUT_CHAN_PHYSMASK ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"), + "%s", aout_FormatPrintChannels( &fmt->audio ) ); + else if( fmt->audio.i_channels > 0 ) input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Channels"), "%u", fmt->audio.i_channels ); @@ -1891,20 +2601,38 @@ static void EsOutAddInfo( es_out_t *out, es_out_id_t *es ) { input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"), _("%u Hz"), fmt->audio.i_rate ); + /* FIXME that should be removed or improved ! (used by text/strings.c) */ var_SetInteger( p_input, "sample-rate", fmt->audio.i_rate ); } - if( fmt->audio.i_bitspersample > 0 ) + unsigned int i_bitspersample = fmt->audio.i_bitspersample; + if( i_bitspersample <= 0 ) + i_bitspersample = aout_BitsPerSample( p_fmt_es->i_codec ); + if( i_bitspersample > 0 ) input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bits per sample"), "%u", - fmt->audio.i_bitspersample ); + i_bitspersample ); if( fmt->i_bitrate > 0 ) { input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"), _("%u kb/s"), fmt->i_bitrate / 1000 ); + /* FIXME that should be removed or improved ! (used by text/strings.c) */ var_SetInteger( p_input, "bit-rate", fmt->i_bitrate ); } + for( int i = 0; i < AUDIO_REPLAY_GAIN_MAX; i++ ) + { + const audio_replay_gain_t *p_rg = &fmt->audio_replay_gain; + if( !p_rg->pb_gain[i] ) + continue; + const char *psz_name; + if( i == AUDIO_REPLAY_GAIN_TRACK ) + psz_name = _("Track replay gain"); + else + psz_name = _("Album replay gain"); + input_Control( p_input, INPUT_ADD_INFO, psz_cat, + psz_name, _("%.2f dB"), p_rg->pf_gain[i] ); + } break; case VIDEO_ES: @@ -1928,9 +2656,13 @@ static void EsOutAddInfo( es_out_t *out, es_out_id_t *es ) div = lldiv( (float)fmt->video.i_frame_rate / fmt->video.i_frame_rate_base * 1000000, 1000000 ); - input_Control( p_input, INPUT_ADD_INFO, psz_cat, - _("Frame rate"), I64Fd".%06u", - div.quot, (unsigned int )div.rem ); + if( div.rem > 0 ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, + _("Frame rate"), "%"PRId64".%06u", + div.quot, (unsigned int )div.rem ); + else + input_Control( p_input, INPUT_ADD_INFO, psz_cat, + _("Frame rate"), "%"PRId64, div.quot ); } break; @@ -1943,5 +2675,21 @@ static void EsOutAddInfo( es_out_t *out, es_out_id_t *es ) break; } + /* Append generic meta */ + if( p_meta ) + { + char **ppsz_all_keys = vlc_dictionary_all_keys( &p_meta->extra_tags ); + for( int i = 0; ppsz_all_keys && ppsz_all_keys[i]; i++ ) + { + char *psz_key = ppsz_all_keys[i]; + char *psz_value = vlc_dictionary_value_for_key( &p_meta->extra_tags, psz_key ); + + if( psz_value ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _(psz_key), _(psz_value) ); + free( psz_key ); + } + free( ppsz_all_keys ); + } + free( psz_cat ); }