X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fes_out.c;h=143e2d5151e032f42afbc4eb7b43924272dd1800;hb=7d5bf1ea1baaaad1dbd494312b725e18b00c1de9;hp=c32bf64a10791ad2d28899afe7663b08d533874d;hpb=a18cf1de2e0e1cecfb44894e5043b6806361d15d;p=vlc diff --git a/src/input/es_out.c b/src/input/es_out.c index c32bf64a10..143e2d5151 100644 --- a/src/input/es_out.c +++ b/src/input/es_out.c @@ -39,6 +39,10 @@ #include #include "input_internal.h" +#include "clock.h" +#include "decoder.h" +#include "es_out.h" +#include "event.h" #include "../stream_output/stream_output.h" @@ -58,6 +62,7 @@ typedef struct int i_es; bool b_selected; + bool b_scrambled; /* Clock for this program */ input_clock_t *p_clock; @@ -75,8 +80,8 @@ struct es_out_id_t int i_id; es_out_pgrm_t *p_pgrm; - /* Misc. */ - int64_t i_preroll_end; + /* */ + bool b_scrambled; /* Channel in the track type */ int i_channel; @@ -93,12 +98,18 @@ struct es_out_id_t /* 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; @@ -135,24 +146,46 @@ struct es_out_sys_t int64_t i_audio_delay; int64_t i_spu_delay; - /* Rate used to rescale ES ts */ + /* Clock configuration */ + mtime_t i_pts_delay; + int i_cr_average; 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, bool 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, 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 ); @@ -176,20 +209,21 @@ static inline int EsOutGetClosedCaptionsChannel( vlc_fourcc_t fcc ) } return -1; } - +static inline bool EsFmtIsTeletext( const es_format_t *p_fmt ) +{ + return p_fmt->i_cat == SPU_ES && p_fmt->i_codec == VLC_FOURCC( 't', 'e', 'l', 'x' ); +} /***************************************************************************** * input_EsOutNew: *****************************************************************************/ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) { - vlc_value_t val; - int i; - - es_out_t *out = malloc( sizeof( es_out_t ) ); - if( !out ) return NULL; + es_out_t *out = malloc( sizeof( *out ) ); + if( !out ) + return NULL; - es_out_sys_t *p_sys = malloc( sizeof( es_out_sys_t ) ); + es_out_sys_t *p_sys = malloc( sizeof( *p_sys ) ); if( !p_sys ) { free( out ); @@ -200,9 +234,12 @@ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) 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_mutex_init_recursive( &p_sys->lock ); p_sys->p_input = p_input; p_sys->b_active = false; @@ -221,35 +258,35 @@ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) p_sys->i_sub = 0; /* */ - var_Get( p_input, "audio-track", &val ); - p_sys->i_audio_last = val.i_int; + p_sys->i_audio_last = var_GetInteger( p_input, "audio-track" ); - var_Get( p_input, "sub-track", &val ); - p_sys->i_sub_last = val.i_int; + p_sys->i_sub_last = var_GetInteger( p_input, "sub-track" ); p_sys->i_default_sub_id = -1; if( !p_input->b_preparsing ) { - var_Get( p_input, "audio-language", &val ); - p_sys->ppsz_audio_language = LanguageSplit(val.psz_string); + char *psz_string; + + psz_string = var_GetString( p_input, "audio-language" ); + p_sys->ppsz_audio_language = LanguageSplit( psz_string ); if( p_sys->ppsz_audio_language ) { - for( i = 0; p_sys->ppsz_audio_language[i]; i++ ) + for( int i = 0; p_sys->ppsz_audio_language[i]; i++ ) msg_Dbg( p_input, "selected audio language[%d] %s", i, p_sys->ppsz_audio_language[i] ); } - free( val.psz_string ); + free( psz_string ); - var_Get( p_input, "sub-language", &val ); - p_sys->ppsz_sub_language = LanguageSplit(val.psz_string); + psz_string = var_GetString( p_input, "sub-language" ); + p_sys->ppsz_sub_language = LanguageSplit( psz_string ); if( p_sys->ppsz_sub_language ) { - for( i = 0; p_sys->ppsz_sub_language[i]; i++ ) + for( int i = 0; p_sys->ppsz_sub_language[i]; i++ ) msg_Dbg( p_input, "selected subtitle language[%d] %s", i, p_sys->ppsz_sub_language[i] ); } - free( val.psz_string ); + free( psz_string ); } else { @@ -257,11 +294,9 @@ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) p_sys->ppsz_audio_language = NULL; } - var_Get( p_input, "audio-track-id", &val ); - p_sys->i_audio_id = val.i_int; + p_sys->i_audio_id = var_GetInteger( p_input, "audio-track-id" ); - var_Get( p_input, "sub-track-id", &val ); - p_sys->i_sub_id = val.i_int; + p_sys->i_sub_id = var_GetInteger( p_input, "sub-track-id" ); p_sys->p_es_audio = NULL; p_sys->p_es_video = NULL; @@ -270,7 +305,18 @@ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) 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->i_pts_delay = 0; + p_sys->i_cr_average = 0; + + 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; @@ -278,15 +324,15 @@ es_out_t *input_EsOutNew( input_thread_t *p_input, int i_rate ) } /***************************************************************************** - * 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 ) - input_EsOutSetRecord( out, false ); + EsOutSetRecord( out, false ); for( i = 0; i < p_sys->i_es; i++ ) { @@ -327,17 +373,38 @@ void input_EsOutDelete( es_out_t *out ) 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->p->b_can_pace_control a wkeup time is still needed to avoid too strong buffering */ + if( !p_input->p->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); } @@ -349,54 +416,44 @@ es_out_id_t *input_EsOutGetFromID( es_out_t *out, int i_id ) return NULL; } -mtime_t input_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 */ - if( !p_input->b_can_pace_control || p_input->p->b_out_pace_control ) - return 0; - - return input_clock_GetWakeup( p_sys->p_pgrm->p_clock ); -} - -static void EsOutDiscontinuity( es_out_t *out, bool b_flush, bool 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_record ) - input_DecoderDiscontinuity( es->p_dec_record, 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; } + return true; } -void input_EsOutChangeRate( es_out_t *out, int i_rate ) + +static void EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay ) { - es_out_sys_t *p_sys = out->p_sys; - int i; + es_out_sys_t *p_sys = out->p_sys; - p_sys->i_rate = i_rate; - EsOutDiscontinuity( out, false, false ); + if( i_cat == AUDIO_ES ) + p_sys->i_audio_delay = i_delay; + else if( i_cat == SPU_ES ) + p_sys->i_spu_delay = i_delay; - for( i = 0; i < p_sys->i_pgrm; i++ ) - input_clock_ChangeRate( p_sys->pgrm[i]->p_clock, i_rate ); + for( int i = 0; i < p_sys->i_es; i++ ) + EsOutDecoderChangeDelay( out, p_sys->es[i] ); } -int input_EsOutSetRecord( es_out_t *out, bool b_record ) +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; @@ -444,7 +501,9 @@ int input_EsOutSetRecord( es_out_t *out, bool b_record ) if( !p_es->p_dec || p_es->p_master ) continue; - p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, 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 ); } } else @@ -467,92 +526,361 @@ int input_EsOutSetRecord( es_out_t *out, bool b_record ) return VLC_SUCCESS; } -void input_EsOutSetDelay( es_out_t *out, int i_cat, int64_t i_delay ) +static void EsOutChangePause( es_out_t *out, bool b_paused, mtime_t i_date ) { es_out_sys_t *p_sys = out->p_sys; - if( i_cat == AUDIO_ES ) - p_sys->i_audio_delay = i_delay; - else if( i_cat == SPU_ES ) - p_sys->i_spu_delay = i_delay; + /* 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; + + 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; } -void input_EsOutChangeState( es_out_t *out ) + + + +static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced ) { es_out_sys_t *p_sys = out->p_sys; - input_thread_t *p_input = p_sys->p_input; + 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->i_pts_delay + + i_preroll_duration + + p_sys->i_buffering_extra_stream - p_sys->i_buffering_extra_initial; - if( p_input->i_state == PAUSE_S ) + if( i_stream_duration <= i_buffering_duration && !b_forced ) { - /* Send discontinuity to decoders (it will allow them to flush - * * if implemented */ - EsOutDiscontinuity( out, false, false ); + 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; } - else + 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_resource_TerminateVout( p_sys->p_input->p->p_resource ); + + /* */ + 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++ ) { - /* Out of pause, reset pcr */ - es_out_Control( out, ES_OUT_RESET_PCR ); + es_out_id_t *es = p_sys->es[i]; + + 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 ); + } } } -void input_EsOutChangePosition( es_out_t *out ) +static void EsOutProgramChangePause( es_out_t *out, bool b_paused, mtime_t i_date ) { - //es_out_sys_t *p_sys = out->p_sys; + es_out_sys_t *p_sys = out->p_sys; - es_out_Control( out, ES_OUT_RESET_PCR ); - EsOutDiscontinuity( out, true, false ); + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_ChangePause( p_sys->pgrm[i]->p_clock, b_paused, i_date ); } -bool input_EsOutDecodersEmpty( es_out_t *out ) +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; - int i; - for( i = 0; i < p_sys->i_es; i++ ) + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_ChangeRate( p_sys->pgrm[i]->p_clock, p_sys->i_rate ); +} + +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 ) { - es_out_id_t *es = p_sys->es[i]; + msg_Warn( p_sys->p_input, "buffering, ignoring 'frame next'" ); + return; + } - if( es->p_dec && !input_DecoderEmpty( es->p_dec ) ) - return false; - if( es->p_dec_record && !input_DecoderEmpty( es->p_dec_record ) ) - return false; + 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; + } } - return true; + + 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->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; -/***************************************************************************** - * - *****************************************************************************/ -static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id, es_format_t *fmt, const char *psz_language, + 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->i_pts_delay - i_consumed; + } + if( i_delay < 0 ) + return 0; + return i_delay; +} + +static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id, + const 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; - 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 if( fmt->i_cat == SPU_ES ) - psz_var = "spu-es"; - else - return; - if( b_delete ) { - if( b_teletext ) - var_SetInteger( p_sys->p_input, "teletext-es", -1 ); + if( EsFmtIsTeletext( fmt ) ) + input_SendEventTeletextDel( p_sys->p_input, i_id ); - val.i_int = i_id; - var_Change( p_input, psz_var, VLC_VAR_DELCHOICE, &val, NULL ); - - var_SetBool( p_sys->p_input, "intf-change", true ); + input_SendEventEsDel( p_input, fmt->i_cat, 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 ) { @@ -590,18 +918,18 @@ static void EsOutESVarUpdateGeneric( es_out_t *out, int i_id, es_format_t *fmt, } } - val.i_int = i_id; - var_Change( p_input, psz_var, VLC_VAR_ADDCHOICE, &val, &text ); - - free( text.psz_string ); - - if( b_teletext ) + input_SendEventEsAdd( p_input, fmt->i_cat, i_id, text.psz_string ); + if( EsFmtIsTeletext( fmt ) ) { - if( var_GetInteger( p_sys->p_input, "teletext-es" ) < 0 ) - var_SetInteger( p_sys->p_input, "teletext-es", i_id ); + char psz_page[3+1]; + snprintf( psz_page, sizeof(psz_page), "%d%2.2x", + fmt->subs.teletext.i_magazine, + fmt->subs.teletext.i_page ); + input_SendEventTeletextAdd( p_sys->p_input, + i_id, fmt->subs.teletext.i_magazine >= 0 ? psz_page : NULL ); } - var_SetBool( p_sys->p_input, "intf-change", true ); + free( text.psz_string ); } static void EsOutESVarUpdate( es_out_t *out, es_out_id_t *es, @@ -617,7 +945,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 ) @@ -649,14 +976,18 @@ static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm ) 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 ); + input_SendEventTeletextDel( p_input, -1 ); + input_SendEventProgramScrambled( p_input, p_pgrm->i_id, p_pgrm->b_scrambled ); + + /* 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 ) @@ -665,12 +996,10 @@ static void EsOutProgramSelect( es_out_t *out, es_out_pgrm_t *p_pgrm ) } /* 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", true ); + input_SendEventMeta( p_input ); } /* EsOutAddProgram: @@ -680,7 +1009,6 @@ 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 ) @@ -690,32 +1018,29 @@ static es_out_pgrm_t *EsOutProgramAdd( es_out_t *out, int i_group ) p_pgrm->i_id = i_group; p_pgrm->i_es = 0; p_pgrm->b_selected = false; + p_pgrm->b_scrambled = false; p_pgrm->psz_name = NULL; p_pgrm->psz_now_playing = NULL; p_pgrm->psz_publisher = NULL; p_pgrm->p_epg = NULL; - p_pgrm->p_clock = input_clock_New( p_input->p->input.i_cr_average, p_sys->i_rate ); + p_pgrm->p_clock = input_clock_New( p_sys->i_rate ); if( !p_pgrm->p_clock ) { free( p_pgrm ); return NULL; } + input_clock_SetJitter( p_pgrm->p_clock, p_sys->i_pts_delay, p_sys->i_cr_average ); + /* 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", true ); - } + return p_pgrm; } @@ -727,7 +1052,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++ ) @@ -765,14 +1089,25 @@ static int EsOutProgramDel( es_out_t *out, int i_group ) 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", true ); + input_SendEventProgramDel( p_input, i_group ); return VLC_SUCCESS; } +/* EsOutProgramFind + */ +static es_out_pgrm_t *EsOutProgramFind( es_out_t *p_out, int i_group ) +{ + es_out_sys_t *p_sys = p_out->p_sys; + + for( int i = 0; i < p_sys->i_pgrm; i++ ) + { + if( p_sys->pgrm[i]->i_id == i_group ) + return p_sys->pgrm[i]; + } + return EsOutProgramAdd( p_out, i_group ); +} + /* EsOutProgramMeta: */ static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm ) @@ -794,7 +1129,7 @@ static char *EsOutProgramGetMetaName( es_out_pgrm_t *p_pgrm ) 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; + es_out_pgrm_t *p_pgrm; input_thread_t *p_input = p_sys->p_input; char *psz_cat; const char *psz_title = NULL; @@ -812,16 +1147,9 @@ static void EsOutProgramMeta( es_out_t *out, int i_group, vlc_meta_t *p_meta ) return; } /* 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 */ + p_pgrm = EsOutProgramFind( out, i_group ); + if( !p_pgrm ) + return; /* */ psz_title = vlc_meta_Get( p_meta, vlc_meta_Title); @@ -830,37 +1158,37 @@ 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 ); /* Remove old entries */ input_Control( p_input, INPUT_DEL_INFO, psz_cat, NULL ); - /* TODO update epg name */ + /* TODO update epg name ? + * TODO update scrambled info name ? */ free( psz_cat ); } 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 ) { - if( asprintf( &text.psz_string, "%s [%s]", psz_title, psz_provider ) != -1 ) - { - 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 ); } } @@ -868,14 +1196,19 @@ 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 ); 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] ) ); + input_Control( p_input, INPUT_ADD_INFO, psz_cat, + vlc_gettext(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 ); @@ -906,10 +1239,9 @@ static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src ) } if( b_add ) { - vlc_epg_event_t *p_copy = malloc( sizeof(vlc_epg_event_t) ); + vlc_epg_event_t *p_copy = calloc( 1, sizeof(vlc_epg_event_t) ); if( !p_copy ) break; - memset( p_copy, 0, sizeof(vlc_epg_event_t) ); 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; @@ -919,7 +1251,8 @@ static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src ) } } /* Update current */ - vlc_epg_SetCurrent( p_dst, p_src->p_current ? p_src->p_current->i_start : -1 ); + if( p_src->p_current ) + vlc_epg_SetCurrent( p_dst, p_src->p_current->i_start ); /* Keep only 1 old event */ if( p_dst->p_current ) @@ -932,22 +1265,14 @@ static void vlc_epg_Merge( vlc_epg_t *p_dst, const vlc_epg_t *p_src ) 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 */ + input_thread_t *p_input = p_sys->p_input; + es_out_pgrm_t *p_pgrm; + char *psz_cat; + + /* Find program */ + p_pgrm = EsOutProgramFind( out, i_group ); + if( !p_pgrm ) + return; /* Merge EPG */ if( !p_pgrm->p_epg ) @@ -955,43 +1280,28 @@ static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg ) 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 ); + psz_cat = EsOutProgramGetMetaName( p_pgrm ); - 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 ); + char *psz_epg; + if( asprintf( &psz_epg, "EPG %s", psz_cat ) >= 0 ) + { + input_item_SetEpg( p_input->p->p_item, psz_epg, p_pgrm->p_epg ); + free( psz_epg ); } - 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_epg->p_current && p_pgrm->p_epg->p_current->psz_name && *p_pgrm->p_epg->p_current->psz_name ) + p_pgrm->psz_now_playing = strdup( p_pgrm->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 ) { @@ -1008,54 +1318,79 @@ static void EsOutProgramEpg( es_out_t *out, int i_group, vlc_epg_t *p_epg ) free( psz_cat ); } +static void EsOutProgramUpdateScrambled( es_out_t *p_out, es_out_pgrm_t *p_pgrm ) +{ + es_out_sys_t *p_sys = p_out->p_sys; + input_thread_t *p_input = p_sys->p_input; + bool b_scrambled = false; + + for( int i = 0; i < p_sys->i_es; i++ ) + { + if( p_sys->es[i]->p_pgrm == p_pgrm && p_sys->es[i]->b_scrambled ) + { + b_scrambled = true; + break; + } + } + if( !p_pgrm->b_scrambled == !b_scrambled ) + return; + + p_pgrm->b_scrambled = b_scrambled; + char *psz_cat = EsOutProgramGetMetaName( p_pgrm ); + + if( b_scrambled ) + input_Control( p_input, INPUT_ADD_INFO, psz_cat, _("Scrambled"), _("Yes") ); + else + input_Control( p_input, INPUT_DEL_INFO, psz_cat, _("Scrambled") ); + + input_SendEventProgramScrambled( p_input, p_pgrm->i_id, b_scrambled ); +} + /* 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( !es ) return NULL; - if( fmt->i_group < 0 ) { msg_Err( p_input, "invalid group number" ); - free( es ); return NULL; } + es_out_id_t *es = malloc( sizeof( *es ) ); + es_out_pgrm_t *p_pgrm; + int i; + + if( !es ) + return NULL; + + vlc_mutex_lock( &p_sys->lock ); + /* Search the program */ - for( i = 0; i < p_sys->i_pgrm; i++ ) - { - if( fmt->i_group == p_sys->pgrm[i]->i_id ) - { - p_pgrm = p_sys->pgrm[i]; - break; - } - } - if( p_pgrm == NULL ) + p_pgrm = EsOutProgramFind( out, fmt->i_group ); + if( !p_pgrm ) { - /* Create a new one */ - p_pgrm = EsOutProgramAdd( out, fmt->i_group ); + vlc_mutex_unlock( &p_sys->lock ); + free( es ); + return NULL; } /* Increase ref count for program */ 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; + es->b_scrambled = false; - switch( fmt->i_cat ) + switch( es->fmt.i_cat ) { case AUDIO_ES: { @@ -1064,9 +1399,9 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) es->i_channel = p_sys->i_audio; memset( &rg, 0, sizeof(rg) ); - vlc_mutex_lock( &p_input->p->input.p_item->lock ); - 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++ ) { @@ -1086,11 +1421,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: @@ -1101,8 +1436,8 @@ 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++ ) @@ -1118,7 +1453,7 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) 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++; @@ -1131,7 +1466,12 @@ static es_out_id_t *EsOutAdd( es_out_t *out, es_format_t *fmt ) break; } - EsOutAddInfo( out, es ); + EsOutUpdateInfo( out, es, &es->fmt, NULL ); + + if( es->b_scrambled ) + EsOutProgramUpdateScrambled( out, es->p_pgrm ); + + vlc_mutex_unlock( &p_sys->lock ); return es; } @@ -1159,9 +1499,21 @@ 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_input->p->p_sout ); - if( p_es->p_dec && !p_es->p_master && p_sys->p_sout_record ) - p_es->p_dec_record = input_DecoderNew( p_input, &p_es->fmt, p_sys->p_sout_record ); + 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 ) { @@ -1184,8 +1536,6 @@ 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( EsIsSelected( es ) ) { @@ -1216,7 +1566,6 @@ static void EsSelect( es_out_t *out, es_out_id_t *es ) } 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", @@ -1226,7 +1575,6 @@ static void EsSelect( es_out_t *out, es_out_id_t *es ) } 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", @@ -1235,35 +1583,21 @@ static void EsSelect( es_out_t *out, es_out_id_t *es ) } } - es->i_preroll_end = -1; EsCreateDecoder( out, es ); if( es->p_dec == NULL || es->p_pgrm != p_sys->p_pgrm ) 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 = es->i_id; - var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL ); - - var_SetBool( p_sys->p_input, "intf-change", true ); + input_SendEventEsSelect( p_input, es->fmt.i_cat, es->i_id ); + input_SendEventTeletextSelect( p_input, EsFmtIsTeletext( &es->fmt ) ? es->i_id : -1 ); } 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( !EsIsSelected( es ) ) { @@ -1292,10 +1626,7 @@ static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update ) if( i_spu_id == es->pp_cc_es[i]->i_id ) { /* Force unselection of the CC */ - val.i_int = -1; - var_Change( p_input, "spu-es", VLC_VAR_SETVALUE, &val, NULL ); - if( !b_update ) - var_SetBool( p_sys->p_input, "intf-change", true ); + input_SendEventEsSelect( p_input, SPU_ES, -1 ); } EsOutDel( out, es->pp_cc_es[i] ); @@ -1307,23 +1638,10 @@ static void EsUnselect( es_out_t *out, es_out_id_t *es, bool b_update ) if( !b_update ) return; - /* 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 unselected */ - val.i_int = -1; - var_Change( p_input, psz_var, VLC_VAR_SETVALUE, &val, NULL ); - - var_SetBool( p_sys->p_input, "intf-change", true ); + input_SendEventEsSelect( p_input, es->fmt.i_cat, -1 ); + if( EsFmtIsTeletext( &es->fmt ) ) + input_SendEventTeletextSelect( p_input, -1 ); } /** @@ -1507,131 +1825,108 @@ static void EsOutSelect( es_out_t *out, es_out_id_t *es, bool 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( libvlc_stats (p_input) ) + 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, p_block->i_buffer, &i_total ); stats_UpdateFloat( p_input , p_input->p->counters.p_demux_bitrate, (float)i_total, NULL ); + + /* Update number of corrupted data packats */ + if( p_block->i_flags & BLOCK_FLAG_CORRUPTED ) + { + stats_UpdateInteger( p_input, p_input->p->counters.p_demux_corrupted, + 1, NULL ); + } + /* Update number of discontinuities */ + if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY ) + { + stats_UpdateInteger( p_input, p_input->p->counters.p_demux_discontinuity, + 1, NULL ); + } 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_clock_GetTS( p_pgrm->p_clock, p_input->i_pts_delay, 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_clock_GetTS( p_pgrm->p_clock, p_input->i_pts_delay, 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 ( p_block->i_rate == INPUT_RATE_DEFAULT && - 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_sys->i_rate; + /* Check CC status */ + bool pb_cc[4]; - /* TODO handle mute */ - if( es->p_dec && - ( es->fmt.i_cat != AUDIO_ES || - ( p_sys->i_rate >= INPUT_RATE_DEFAULT/AOUT_MAX_INPUT_RATE && - p_sys->i_rate <= INPUT_RATE_DEFAULT*AOUT_MAX_INPUT_RATE ) ) ) + input_DecoderIsCcPresent( es->p_dec, pb_cc ); + for( int i = 0; i < 4; i++ ) { - bool pb_cc[4]; - bool b_cc_new = false; - int i; - if( es->p_dec_record ) - { - block_t *p_dup = block_Duplicate( p_block ); - if( p_dup ) - input_DecoderDecode( es->p_dec_record, p_dup ); - } - input_DecoderDecode( es->p_dec, p_block ); - - /* Check CC status */ - input_DecoderIsCcPresent( es->p_dec, pb_cc ); - for( i = 0; i < 4; i++ ) - { - 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; + 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 ); + 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_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; - b_cc_new = true; - } - if( b_cc_new ) - var_SetBool( p_sys->p_input, "intf-change", true ); - } - else - { - block_Release( p_block ); + /* */ + es->pb_cc_present[i] = true; } + vlc_mutex_unlock( &p_sys->lock ); + return VLC_SUCCESS; } @@ -1644,14 +1939,18 @@ static void EsOutDel( es_out_t *out, es_out_id_t *es ) 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 ) && - ( !es->p_dec_record || input_DecoderEmpty( es->p_dec_record ) )) + 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 ); @@ -1662,12 +1961,15 @@ static void EsOutDel( es_out_t *out, es_out_id_t *es ) TAB_REMOVE( p_sys->i_es, p_sys->es, es ); + /* Update program */ es->p_pgrm->i_es--; if( es->p_pgrm->i_es == 0 ) - { msg_Dbg( p_sys->p_input, "Program doesn't contain anymore ES" ); - } + if( es->b_scrambled ) + EsOutProgramUpdateScrambled( out, es->p_pgrm ); + + /* */ if( p_sys->p_es_audio == es || p_sys->p_es_video == es || p_sys->p_es_sub == es ) b_reselect = true; @@ -1690,17 +1992,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], false ); } + } free( es->psz_language ); free( es->psz_language_code ); es_format_Clean( &es->fmt ); + vlc_mutex_unlock( &p_sys->lock ); + free( es ); } @@ -1712,11 +2018,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; bool b, *pb; - int i, *pi; + int i; es_out_id_t *es; @@ -1747,18 +2053,24 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) case ES_OUT_SET_ACTIVE: { 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_resource_TerminateVout( p_sys->p_input->p->p_resource ); + } p_sys->b_active = b; - /* Needed ? */ - if( b ) - var_SetBool( p_sys->p_input, "intf-change", true ); return VLC_SUCCESS; } - case ES_OUT_GET_ACTIVE: - pb = (bool*) va_arg( args, bool * ); - *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 || @@ -1783,11 +2095,6 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) } 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: { @@ -1839,16 +2146,10 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) } } } - if( i_query == ES_OUT_SET_ES ) - { - vlc_event_t event; - event.type = vlc_InputSelectedStreamChanged; - vlc_event_send( &p_sys->p_input->p->event_manager, &event ); - } 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 * ); @@ -1894,53 +2195,32 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) if( i_query == ES_OUT_SET_PCR ) { p_pgrm = p_sys->p_pgrm; + if( !p_pgrm ) + p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */ } else { - int i; i_group = (int)va_arg( args, int ); - 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; - } - } + p_pgrm = EsOutProgramFind( out, i_group ); } - if( p_pgrm == NULL ) - p_pgrm = EsOutProgramAdd( out, i_group ); /* Create it */ + if( !p_pgrm ) + return VLC_EGENERIC; i_pcr = (int64_t)va_arg( args, int64_t ); /* 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, i_pcr, mdate() ); + p_sys->p_input->p->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_clock_Reset( p_sys->pgrm[i]->p_clock ); - 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_clock_GetTS( p_sys->p_pgrm->p_clock, - 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 */ + msg_Err( p_sys->p_input, "ES_OUT_RESET_PCR called" ); + EsOutChangePosition( out ); return VLC_SUCCESS; case ES_OUT_SET_GROUP: @@ -1959,7 +2239,7 @@ 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 */ @@ -1993,20 +2273,27 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) return VLC_SUCCESS; } - case ES_OUT_SET_NEXT_DISPLAY_TIME: + case ES_OUT_SET_ES_SCRAMBLED_STATE: { - 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 ); + bool b_scrambled = (bool)va_arg( args, int ); + + if( !es->b_scrambled != !b_scrambled ) + { + es->b_scrambled = b_scrambled; + EsOutProgramUpdateScrambled( out, es->p_pgrm ); + } + return VLC_SUCCESS; + } + + case ES_OUT_SET_NEXT_DISPLAY_TIME: + { + 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_clock_GetTS but PCR has been reseted - * and it will return 0, so we won't call input_clock_GetTS 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; } @@ -2026,6 +2313,7 @@ static int EsOutControl( es_out_t *out, int i_query, va_list args ) EsOutProgramEpg( out, i_group, p_epg ); return VLC_SUCCESS; } + case ES_OUT_DEL_GROUP: { int i_group = (int)va_arg( args, int ); @@ -2033,11 +2321,154 @@ 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_resource_TerminateVout( p_sys->p_input->p->p_resource ); + 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; + } + case ES_OUT_SET_JITTER: + { + mtime_t i_pts_delay = (mtime_t)va_arg( args, mtime_t ); + int i_cr_average = (int)va_arg( args, int ); + + if( i_pts_delay == p_sys->i_pts_delay && + i_cr_average == p_sys->i_cr_average ) + return VLC_SUCCESS; + + p_sys->i_pts_delay = i_pts_delay; + p_sys->i_cr_average = i_cr_average; + + for( int i = 0; i < p_sys->i_pgrm; i++ ) + input_clock_SetJitter( p_sys->pgrm[i]->p_clock, + i_pts_delay, i_cr_average ); + 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 @@ -2173,35 +2604,69 @@ static int LanguageArrayIndex( char **ppsz_langs, char *psz_lang ) } /**************************************************************************** - * 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 */ - if( asprintf( &psz_cat, _("Stream %d"), out->p_sys->i_id - 1 ) == -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 ); @@ -2209,20 +2674,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: @@ -2246,9 +2729,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"), "%"PRId64".%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; @@ -2261,5 +2748,22 @@ 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, + vlc_gettext(psz_key), vlc_gettext(psz_value) ); + free( psz_key ); + } + free( ppsz_all_keys ); + } + free( psz_cat ); }