X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fes_out.c;h=94382ffd9ff9abb9053403229c2d2f50eac03bb0;hb=7ccd46a8a014e991d23e34fdc169ae621036eb2b;hp=98f4fa0656cbdb227b1ad760e598c71b0ed3829c;hpb=886975814e0cb1a2688d063f24e665168b2aae85;p=vlc diff --git a/src/input/es_out.c b/src/input/es_out.c index 98f4fa0656..d736f63828 100644 --- a/src/input/es_out.c +++ b/src/input/es_out.c @@ -25,19 +25,28 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif #include -#include +#include +#include #include #include #include +#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,13 +61,16 @@ 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; + char *psz_publisher; + vlc_epg_t *p_epg; } es_out_pgrm_t; struct es_out_id_t @@ -67,24 +79,33 @@ struct es_out_id_t int i_id; es_out_pgrm_t *p_pgrm; - /* Signal a discontinuity in the timeline for every PID */ - vlc_bool_t b_discontinuity; - - /* 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 */ @@ -108,6 +129,7 @@ struct es_out_sys_t /* es to select */ int i_audio_last, i_audio_id; int i_sub_last, i_sub_id; + int i_default_sub_id; /* As specified in container; if applicable */ char **ppsz_audio_language; char **ppsz_sub_language; @@ -119,53 +141,111 @@ 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 ); 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; - p_sys->i_pgrm = 0; - p_sys->pgrm = NULL; + TAB_INIT( p_sys->i_pgrm, p_sys->pgrm ); p_sys->p_pgrm = NULL; p_sys->i_id = 0; - p_sys->i_es = 0; - p_sys->es = NULL; + + TAB_INIT( p_sys->i_es, p_sys->es ); p_sys->i_audio = 0; p_sys->i_video = 0; @@ -178,6 +258,8 @@ es_out_t *input_EsOutNew( input_thread_t *p_input ) var_Get( p_input, "sub-track", &val ); p_sys->i_sub_last = val.i_int; + p_sys->i_default_sub_id = -1; + if( !p_input->b_preparsing ) { var_Get( p_input, "audio-language", &val ); @@ -188,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); @@ -198,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 { @@ -219,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] ); @@ -256,29 +351,54 @@ void input_EsOutDelete( es_out_t *out ) free( p_sys->ppsz_sub_language[i] ); free( p_sys->ppsz_sub_language ); } + free( p_sys->es ); - if( 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++ ) { - if( p_sys->pgrm[i]->psz_now_playing ) - free( p_sys->pgrm[i]->psz_now_playing ); - free( p_sys->pgrm[i] ); + es_out_pgrm_t *p_pgrm = p_sys->pgrm[i]; + 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 ); } - if( p_sys->pgrm ) - free( p_sys->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); } @@ -290,26 +410,31 @@ es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id ) return NULL; } -void input_EsOutDiscontinuity( es_out_t *out, 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]; - es->b_discontinuity = VLC_TRUE; /* signal discontinuity */ - /* 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 ); - } + if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) ) + return false; + if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) ) + return false; } + 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; @@ -317,53 +442,440 @@ 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] ); } -vlc_bool_t input_EsOutDecodersEmpty( es_out_t *out ) +static int EsOutSetRecord( es_out_t *out, bool b_record ) +{ + es_out_sys_t *p_sys = out->p_sys; + input_thread_t *p_input = p_sys->p_input; + + 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 ) + { + EsOutDecodersChangePause( out, true, i_date ); + EsOutProgramChangePause( out, true, i_date ); + } + else + { + 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->p->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; +} + +static void EsOutChangeRate( es_out_t *out, int i_rate ) { es_out_sys_t *p_sys = out->p_sys; - int i; - for( i = 0; i < p_sys->i_es; i++ ) + p_sys->i_rate = i_rate; + + if( !p_sys->b_paused ) + EsOutProgramsChangeRate( out ); +} + +static void EsOutChangePosition( es_out_t *out ) +{ + es_out_sys_t *p_sys = out->p_sys; + + 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_record ); + } + + 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->p->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 || p_es->fmt.i_cat == SPU_ES ) + 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 ); + + /* Here is a good place to destroy unused vout with every demuxer */ + input_ressource_TerminateVout( p_sys->p_input->p->p_ressource ); + + /* */ + 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_record ); + } +} +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->p->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->p->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 ) { @@ -376,41 +888,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: @@ -420,7 +938,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 ) @@ -433,9 +950,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; @@ -446,44 +963,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 if defined per program */ - if( p_pgrm->psz_now_playing ) - { - char *psz_cat = malloc( strlen(_("Program")) + 10 ); + /* Update now playing */ + 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 ); - sprintf( psz_cat, "%s %d", _("Program"), p_pgrm->i_id ); - input_Control( p_input, INPUT_ADD_INFO, _(VLC_META_INFO_CAT), - _(VLC_META_NOW_PLAYING), "%s", p_pgrm->psz_now_playing ); - free( psz_cat ); - } - - - var_SetBool( p_sys->p_input, "intf-change", VLC_TRUE ); + input_SendEventMeta( p_input ); } /* EsOutAddProgram: @@ -493,32 +1000,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; - input_ClockInit( &p_pgrm->clock, VLC_FALSE, p_input->p->input.i_cr_average ); + p_pgrm->psz_publisher = NULL; + p_pgrm->p_epg = NULL; + 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; } @@ -530,7 +1040,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++ ) @@ -555,46 +1064,63 @@ 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 = 0; + if( p_sys->p_pgrm == p_pgrm ) + p_sys->p_pgrm = NULL; + + input_clock_Delete( p_pgrm->p_clock ); - if( p_pgrm->psz_now_playing ) free( p_pgrm->psz_now_playing ); + 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; } /* EsOutProgramMeta: */ +static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm ) +{ + char *psz = NULL; + if( p_pgrm->psz_name ) + { + if( asprintf( &psz, _("%s [%s %d]"), p_pgrm->psz_name, _("Program"), p_pgrm->i_id ) == -1 ) + return NULL; + } + else + { + if( asprintf( &psz, "%s %d", _("Program"), p_pgrm->i_id ) == -1 ) + return NULL; + } + return psz; +} + static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) { es_out_sys_t *p_sys = out->p_sys; es_out_pgrm_t *p_pgrm = NULL; input_thread_t *p_input = p_sys->p_input; - char *psz_cat = malloc( strlen(_("Program")) + 10 ); - char *psz_title = NULL; - char *psz_now_playing = NULL; - char *psz_provider = NULL; + char *psz_cat; + const char *psz_title = NULL; + const char *psz_provider = NULL; int i; msg_Dbg( p_input, "EsOutProgramMeta: number=%d", i_group ); - sprintf( psz_cat, "%s %d", _("Program"), i_group ); - if( p_meta->psz_title ) psz_title = p_meta->psz_title; - if( p_meta->psz_publisher ) psz_provider = p_meta->psz_publisher; - if( p_meta->psz_nowplaying ) psz_now_playing = p_meta->psz_nowplaying; - - if( !psz_title && !psz_now_playing ) + /* Check against empty meta data (empty for what we handle) */ + if( !vlc_meta_Get( p_meta, vlc_meta_Title) && + !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 ) { - free( psz_cat ); return; } - + /* Find program */ for( i = 0; i < p_sys->i_pgrm; i++ ) { if( p_sys->pgrm[i]->i_id == i_group ) @@ -603,67 +1129,221 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) break; } } + if( p_pgrm == NULL ) + p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */ - if( p_pgrm == NULL ) { - free( psz_cat ); - msg_Dbg( p_input, "Trying to add meta for non-existing program" ); - return; - } + /* */ + psz_title = vlc_meta_Get( p_meta, vlc_meta_Title); + psz_provider = vlc_meta_Get( p_meta, vlc_meta_Publisher); /* 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 ); - /* ugly but it works */ - val.i_int = i_group; - var_Change( p_input, "program", VLC_VAR_DELCHOICE, &val, NULL ); + /* Remove old entries */ + input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL ); + /* TODO update epg name */ + free( psz_cat ); + } + free( p_pgrm->psz_name ); + p_pgrm->psz_name = strdup( psz_title ); + 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 = 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 ); } } - if( psz_now_playing ) - { - if( p_pgrm->psz_now_playing ) free( p_pgrm->psz_now_playing ); - p_pgrm->psz_now_playing = strdup(psz_now_playing); + psz_cat = EsOutProgramGetMetaName( p_pgrm ); + if( psz_provider ) + { if( p_sys->p_pgrm == p_pgrm ) { - vlc_meta_SetNowPlaying( p_input->p->input.p_item->p_meta, - psz_now_playing ); + 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 ); + for( i = 0; ppsz_all_keys[i]; i++ ) + { + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _(ppsz_all_keys[i]), + vlc_dictionary_value_for_key( &p_meta->extra_tags, ppsz_all_keys[i] ) ); + free( ppsz_all_keys[i] ); + } + free( ppsz_all_keys ); + + free( psz_cat ); +} + +static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src ) +{ + int i; + + /* Add new event */ + for( i = 0; i < p_src->i_event; i++ ) + { + vlc_epg_event_t *p_evt = p_src->pp_event[i]; + 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 = false; + break; + } + if( p_dst->pp_event[j]->i_start > p_evt->i_start ) + break; + } + if( b_add ) + { + vlc_epg_event_t *p_copy = calloc( 1, sizeof(vlc_epg_event_t) ); + if( !p_copy ) + break; + p_copy->i_start = p_evt->i_start; + p_copy->i_duration = p_evt->i_duration; + p_copy->psz_name = p_evt->psz_name ? strdup( p_evt->psz_name ) : NULL; + p_copy->psz_short_description = p_evt->psz_short_description ? strdup( p_evt->psz_short_description ) : NULL; + p_copy->psz_description = p_evt->psz_description ? strdup( p_evt->psz_description ) : NULL; + TAB_INSERT( p_dst->i_event, p_dst->pp_event, p_copy, j ); } } + /* Update current */ + vlc_epg_SetCurrent( p_dst, p_src->p_current ? p_src->p_current->i_start : -1 ); + + /* Keep only 1 old event */ + if( p_dst->p_current ) + { + while( p_dst->i_event > 1 && p_dst->pp_event[0] != p_dst->p_current && p_dst->pp_event[1] != p_dst->p_current ) + TAB_REMOVE( p_dst->i_event, p_dst->pp_event, p_dst->pp_event[0] ); + } +} + +static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg ) +{ + 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; + char *psz_cat; + int i; + + /* Find program */ + for( i = 0; i < p_sys->i_pgrm; i++ ) + { + if( p_sys->pgrm[i]->i_id == i_group ) + { + p_pgrm = p_sys->pgrm[i]; + break; + } + } + if( p_pgrm == NULL ) + p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */ + + /* Merge EPG */ + if( !p_pgrm->p_epg ) + p_pgrm->p_epg = vlc_epg_New( p_pgrm->psz_name ); + vlc_epg_Merge( p_pgrm->p_epg, p_epg ); + + /* Update info */ + psz_cat = EsOutProgramGetMetaName( p_pgrm ); +#ifdef HAVE_LOCALTIME_R + char *psz_epg; + if( asprintf( &psz_epg, "EPG %s", psz_cat ) == -1 ) + psz_epg = NULL; + input_Control( p_input, INPUT_DEL_INFO, psz_epg, NULL ); + msg_Dbg( p_input, "EsOutProgramEpg: number=%d name=%s", i_group, p_pgrm->p_epg->psz_name ); + for( i = 0; i < p_pgrm->p_epg->i_event; i++ ) + { + const vlc_epg_event_t *p_evt = p_pgrm->p_epg->pp_event[i]; + time_t t_start = (time_t)p_evt->i_start; + struct tm tm_start; + char psz_start[128]; + + localtime_r( &t_start, &tm_start ); + + snprintf( psz_start, sizeof(psz_start), "%2.2d:%2.2d:%2.2d", tm_start.tm_hour, tm_start.tm_min, tm_start.tm_sec ); + if( p_evt->psz_short_description || p_evt->psz_description ) + input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d) - %s", + p_evt->psz_name, + p_evt->i_duration/60/60, (p_evt->i_duration/60)%60, + p_evt->psz_short_description ? p_evt->psz_short_description : p_evt->psz_description ); + else + input_Control( p_input, INPUT_ADD_INFO, psz_epg, psz_start, "%s (%2.2d:%2.2d)", + p_evt->psz_name, + p_evt->i_duration/60/60, (p_evt->i_duration/60)%60 ); + } + free( psz_epg ); +#endif + /* Update 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->p_item, p_pgrm->psz_now_playing ); + input_SendEventMeta( p_input ); + } + + if( p_pgrm->psz_now_playing ) + { + input_Control( p_input, INPUT_ADD_INFO, psz_cat, + input_MetaTypeToLocalizedString(vlc_meta_NowPlaying), + p_pgrm->psz_now_playing ); + } + else + { + input_Control( p_input, INPUT_DEL_INFO, psz_cat, + input_MetaTypeToLocalizedString(vlc_meta_NowPlaying) ); + } + free( psz_cat ); } /* 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++ ) { @@ -683,27 +1363,49 @@ 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; - es->b_discontinuity = VLC_FALSE; + 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: + { + audio_replay_gain_t rg; + es->i_channel = p_sys->i_audio; + + memset( &rg, 0, sizeof(rg) ); + 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++ ) + { + if( !es->fmt.audio_replay_gain.pb_peak[i] ) + { + es->fmt.audio_replay_gain.pb_peak[i] = rg.pb_peak[i]; + es->fmt.audio_replay_gain.pf_peak[i] = rg.pf_peak[i]; + } + if( !es->fmt.audio_replay_gain.pb_gain[i] ) + { + es->fmt.audio_replay_gain.pb_gain[i] = rg.pb_gain[i]; + es->fmt.audio_replay_gain.pf_gain[i] = rg.pf_gain[i]; + } + } break; + } 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: @@ -714,20 +1416,24 @@ 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, VLC_FALSE ); + EsOutSelect( out, es, false ); TAB_APPEND( out->p_sys->i_es, out->p_sys->es, es ); p_sys->i_id++; /* always incremented */ - switch( fmt->i_cat ) + switch( es->fmt.i_cat ) { case AUDIO_ES: p_sys->i_audio++; @@ -740,94 +1446,173 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) break; } - EsOutAddInfo( out, es ); + 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); + + if( !p_es->p_dec ) + return; + + input_DecoderDelete( p_es->p_dec ); + p_es->p_dec = NULL; + + if( p_es->p_dec_record ) + { + input_DecoderDelete( p_es->p_dec_record ); + p_es->p_dec_record = NULL; + } +} + 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 ) + { + 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 ) { - msg_Dbg( p_input, "spu is disabled, not selecting ES 0x%x", - es->i_id ); - return; + 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; @@ -835,20 +1620,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 ); } /** @@ -860,7 +1634,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; @@ -874,7 +1648,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 ) @@ -886,7 +1660,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; } @@ -965,6 +1739,12 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, vlc_bool_t b_force ) i_wanted = es->i_channel; } + else if( p_sys->i_default_sub_id >= 0 ) + { + if( es->i_id == p_sys->i_default_sub_id ) + i_wanted = es->i_channel; + } + if( p_sys->i_sub_last >= 0 ) i_wanted = p_sys->i_sub_last; @@ -981,21 +1761,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; } @@ -1004,9 +1784,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; } @@ -1026,20 +1806,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, @@ -1049,59 +1820,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; } - /* +11 -> avoid null value with non null dts/pts */ - if( p_block->i_dts > 0 ) + p_block->i_rate = 0; + + if( !es->p_dec ) { - p_block->i_dts = - input_ClockGetTS( p_input, &p_pgrm->clock, - ( p_block->i_dts + 11 ) * 9 / 100 ) + i_delay; + block_Release( p_block ); + vlc_mutex_unlock( &p_sys->lock ); + return VLC_SUCCESS; } - 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 + 11 ) * 9 / 100 ) + 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 ) ) - { - 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; } @@ -1111,15 +1904,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( !p_sys->p_input->b_die && !p_sys->b_buffering && 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 ); @@ -1130,7 +1936,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; @@ -1151,19 +1957,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 ); } @@ -1175,11 +1983,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; @@ -1187,13 +1995,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; @@ -1202,26 +2010,32 @@ 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 ); + if( b && !p_sys->b_active && p_sys->i_es > 0 ) + { + /* XXX Terminate vout if there are tracks but no video one. + * This one is not mandatory but is he earliest place where it + * can be done */ + for( 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 ) + break; + } + if( i >= p_sys->i_es ) + input_ressource_TerminateVout( p_sys->p_input->p->p_ressource ); + } 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 || @@ -1232,7 +2046,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 ); @@ -1240,79 +2054,101 @@ 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 ) + i_cat = UNKNOWN_ES; + else if( es == (es_out_id_t*)((uint8_t*)NULL+AUDIO_ES) ) + i_cat = AUDIO_ES; + else if( es == (es_out_id_t*)((uint8_t*)NULL+VIDEO_ES) ) + i_cat = VIDEO_ES; + else if( es == (es_out_id_t*)((uint8_t*)NULL+SPU_ES) ) + 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( p_sys->es[i]->p_dec ) - EsUnselect( out, p_sys->es[i], - p_sys->es[i]->p_pgrm == p_sys->p_pgrm ); + if( es == p_sys->es[i] ) + { + EsOutSelect( out, es, true ); + break; + } + } + 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_ES_DEFAULT: + { + es = (es_out_id_t*) va_arg( args, es_out_id_t * ); + + if( es == NULL ) + { + /*p_sys->i_default_video_id = -1;*/ + /*p_sys->i_default_audio_id = -1;*/ + p_sys->i_default_sub_id = -1; + } 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 ); - } + /*p_sys->i_default_video_id = -1;*/ } 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 ); - } + /*p_sys->i_default_audio_id = -1;*/ } 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 ); - } + p_sys->i_default_sub_id = -1; } else { - for( i = 0; i < p_sys->i_es; i++ ) - { - if( es == p_sys->es[i] ) - { - EsOutSelect( out, es, VLC_TRUE ); - break; - } - } - } - { - playlist_t * p_playlist = pl_Yield( p_sys->p_input ); - PL_LOCK; - p_playlist->gc_date = mdate(); - vlc_cond_signal( &p_playlist->object_wait ); - PL_UNLOCK; - pl_Release( p_playlist ); + /*if( es->fmt.i_cat == VIDEO_ES ) + p_sys->i_default_video_id = es->i_id; + else + if( es->fmt.i_cat == AUDIO_ES ) + p_sys->i_default_audio_id = es->i_id; + else*/ + if( es->fmt.i_cat == SPU_ES ) + p_sys->i_default_sub_id = es->i_id; } return VLC_SUCCESS; + } case ES_OUT_SET_PCR: case ES_OUT_SET_GROUP_PCR: @@ -1342,39 +2178,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 */ - /* 11 is a vodoo trick to avoid non_pcr*9/100 to be null */ - input_ClockSetPCR( p_sys->p_input, &p_pgrm->clock, - (i_pcr + 11 ) * 9 / 100); + /* 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++ ) - { - p_sys->pgrm[i]->clock.i_synchro_state = SYNCHRO_REINIT; - p_sys->pgrm[i]->clock.last_pts = 0; - } - return VLC_SUCCESS; - - case ES_OUT_GET_TS: - if( p_sys->p_pgrm ) - { - 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 + 11 ) * 9 / 100 ); - 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 */ + msg_Err( p_sys->p_input, "ES_OUT_RESET_PCR called" ); + EsOutChangePosition( out ); return VLC_SUCCESS; case ES_OUT_SET_GROUP: @@ -1393,14 +2210,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 ) { @@ -1408,13 +2226,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 = @@ -1429,16 +2246,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; - es->i_preroll_end = i_date; - input_DecoderPreroll( es->p_dec, i_date ); + p_sys->i_preroll_end = i_date; return VLC_SUCCESS; } @@ -1450,6 +2263,14 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) EsOutProgramMeta( out, i_group, p_meta ); return VLC_SUCCESS; } + case ES_OUT_SET_GROUP_EPG: + { + int i_group = (int)va_arg( args, int ); + vlc_epg_t *p_epg = (vlc_epg_t*)va_arg( args, vlc_epg_t * ); + + EsOutProgramEpg( out, i_group, p_epg ); + return VLC_SUCCESS; + } case ES_OUT_DEL_GROUP: { int i_group = (int)va_arg( args, int ); @@ -1457,11 +2278,137 @@ 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 */ + int i_ret = es_out_Control( out, i_new_query, p_es ); + + /* Clean up vout after user action (in active mode only). + * FIXME it does not work well with multiple video windows */ + if( p_sys->b_active ) + input_ressource_TerminateVout( p_sys->p_input->p->p_ressource ); + return i_ret; + } + + 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; + + if( !p_sys->b_buffering ) + 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 @@ -1549,10 +2496,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; @@ -1574,61 +2532,120 @@ 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"), - "%d", fmt->audio.i_channels ); + "%u", fmt->audio.i_channels ); if( fmt->audio.i_rate > 0 ) { input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Sample rate"), - _("%d Hz"), fmt->audio.i_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"), "%d", - fmt->audio.i_bitspersample ); + _("Bits per sample"), "%u", + i_bitspersample ); if( fmt->i_bitrate > 0 ) { input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Bitrate"), - _("%d kb/s"), fmt->i_bitrate / 1000 ); + _("%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: @@ -1637,13 +2654,13 @@ static void EsOutAddInfo( es_out_t *out, es_out_id_t *es ) if( fmt->video.i_width > 0 && fmt->video.i_height > 0 ) input_Control( p_input, INPUT_ADD_INFO, psz_cat, - _("Resolution"), "%dx%d", + _("Resolution"), "%ux%u", fmt->video.i_width, fmt->video.i_height ); if( fmt->video.i_visible_width > 0 && fmt->video.i_visible_height > 0 ) input_Control( p_input, INPUT_ADD_INFO, psz_cat, - _("Display resolution"), "%dx%d", + _("Display resolution"), "%ux%u", fmt->video.i_visible_width, fmt->video.i_visible_height); if( fmt->video.i_frame_rate > 0 && @@ -1652,9 +2669,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; @@ -1667,5 +2688,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 ); }