X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fclock.c;h=c4f81009b6ea50ebcf29629c1c558abf8a773ff5;hb=470ce70b69e1530173950a8dfd6d274a70caa7bc;hp=beee45ef0b9209e82ae7d2ab91d9c97ca318e349;hpb=6db5caeffaab8e61e963a296287ea91f0049be19;p=vlc diff --git a/src/input/clock.c b/src/input/clock.c index beee45ef0b..c4f81009b6 100644 --- a/src/input/clock.c +++ b/src/input/clock.c @@ -33,6 +33,7 @@ #include #include #include "clock.h" +#include /* TODO: * - clean up locking once clock code is stable @@ -67,7 +68,7 @@ * in all the FIFOs, but it may be not enough. */ -/* p_input->p->i_cr_average : Maximum number of samples used to compute the +/* i_cr_average : Maximum number of samples used to compute the * dynamic average value. * We use the following formula : * new_average = (old_average * c_average + new_sample_value) / (c_average +1) @@ -85,6 +86,19 @@ * my dice --Meuuh */ #define CR_MEAN_PTS_GAP (300000) +/* Rate (in 1/256) at which we will read faster to try to increase our + * internal buffer (if we control the pace of the source). + */ +#define CR_BUFFERING_RATE (48) + +/* Extra internal buffer value (in CLOCK_FREQ) + * It is 60s max, remember as it is limited by the size it takes by es_out.c + * it can be really large. + */ +//#define CR_BUFFERING_TARGET (60000000) +/* Due to some problems in es_out, we cannot use a large value yet */ +#define CR_BUFFERING_TARGET (100000) + /***************************************************************************** * Structures *****************************************************************************/ @@ -106,6 +120,7 @@ static void AvgClean( average_t * ); static void AvgReset( average_t * ); static void AvgUpdate( average_t *, mtime_t i_value ); static mtime_t AvgGet( average_t * ); +static void AvgRescale( average_t *, int i_divider ); /* */ typedef struct @@ -120,40 +135,60 @@ static inline clock_point_t clock_point_Create( mtime_t i_stream, mtime_t i_syst return p; } +/* */ +#define INPUT_CLOCK_LATE_COUNT (3) + /* */ struct input_clock_t { /* */ vlc_mutex_t lock; - /* Reference point */ - bool b_has_reference; - clock_point_t ref; - /* Last point * It is used to detect unexpected stream discontinuities */ clock_point_t last; - /* Maximal timestamp returned by input_clock_GetTS (in system unit) */ + /* Maximal timestamp returned by input_clock_ConvertTS (in system unit) */ mtime_t i_ts_max; + /* Amount of extra buffering expressed in stream clock */ + mtime_t i_buffering_duration; + /* Clock drift */ mtime_t i_next_drift_update; average_t drift; + /* Late statistics */ + struct + { + mtime_t pi_value[INPUT_CLOCK_LATE_COUNT]; + unsigned i_index; + } late; + + /* Reference point */ + clock_point_t ref; + bool b_has_reference; + + /* External clock drift */ + mtime_t i_external_clock; + bool b_has_external_clock; + /* Current modifiers */ - int i_rate; bool b_paused; + int i_rate; + mtime_t i_pts_delay; mtime_t i_pause_date; }; static mtime_t ClockStreamToSystem( input_clock_t *, mtime_t i_stream ); static mtime_t ClockSystemToStream( input_clock_t *, mtime_t i_system ); +static mtime_t ClockGetTsOffset( input_clock_t * ); + /***************************************************************************** * input_clock_New: create a new clock *****************************************************************************/ -input_clock_t *input_clock_New( int i_cr_average, int i_rate ) +input_clock_t *input_clock_New( int i_rate ) { input_clock_t *cl = malloc( sizeof(*cl) ); if( !cl ) @@ -161,18 +196,26 @@ input_clock_t *input_clock_New( int i_cr_average, int i_rate ) vlc_mutex_init( &cl->lock ); cl->b_has_reference = false; - cl->ref = clock_point_Create( 0, 0 ); + cl->ref = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID ); + cl->b_has_external_clock = false; + + cl->last = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID ); + + cl->i_ts_max = VLC_TS_INVALID; - cl->last = clock_point_Create( 0, 0 ); + cl->i_buffering_duration = 0; - cl->i_ts_max = 0; + cl->i_next_drift_update = VLC_TS_INVALID; + AvgInit( &cl->drift, 10 ); - cl->i_next_drift_update = 0; - AvgInit( &cl->drift, i_cr_average ); + cl->late.i_index = 0; + for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ ) + cl->late.pi_value[i] = 0; cl->i_rate = i_rate; + cl->i_pts_delay = 0; cl->b_paused = false; - cl->i_pause_date = 0; + cl->i_pause_date = VLC_TS_INVALID; return cl; } @@ -193,21 +236,23 @@ void input_clock_Delete( input_clock_t *cl ) * i_ck_stream: date in stream clock * i_ck_system: date in system clock *****************************************************************************/ -void input_clock_Update( input_clock_t *cl, - vlc_object_t *p_log, bool b_can_pace_control, +void input_clock_Update( input_clock_t *cl, vlc_object_t *p_log, + bool *pb_late, + bool b_can_pace_control, bool b_buffering_allowed, mtime_t i_ck_stream, mtime_t i_ck_system ) { bool b_reset_reference = false; + assert( i_ck_stream > VLC_TS_INVALID && i_ck_system > VLC_TS_INVALID ); + vlc_mutex_lock( &cl->lock ); - if( ( !cl->b_has_reference ) || - ( i_ck_stream == 0 && cl->last.i_stream != 0 ) ) + if( !cl->b_has_reference ) { /* */ b_reset_reference= true; } - else if( cl->last.i_stream != 0 && + else if( cl->last.i_stream > VLC_TS_INVALID && ( (cl->last.i_stream - i_ck_stream) > CR_MAX_GAP || (cl->last.i_stream - i_ck_stream) < -CR_MAX_GAP ) ) { @@ -215,23 +260,28 @@ void input_clock_Update( input_clock_t *cl, * warning from the stream control facilities (dd-edited * stream ?). */ msg_Warn( p_log, "clock gap, unexpected stream discontinuity" ); - cl->i_ts_max = 0; + cl->i_ts_max = VLC_TS_INVALID; /* */ msg_Warn( p_log, "feeding synchro with a new reference point trying to recover from clock gap" ); b_reset_reference= true; } + + /* */ if( b_reset_reference ) { - cl->i_next_drift_update = 0; + cl->i_next_drift_update = VLC_TS_INVALID; AvgReset( &cl->drift ); /* Feed synchro with a new reference point. */ cl->b_has_reference = true; cl->ref = clock_point_Create( i_ck_stream, __MAX( cl->i_ts_max + CR_MEAN_PTS_GAP, i_ck_system ) ); + cl->b_has_external_clock = false; } + /* Compute the drift between the stream clock and the system clock + * when we don't control the source pace */ if( !b_can_pace_control && cl->i_next_drift_update < i_ck_system ) { const mtime_t i_converted = ClockSystemToStream( cl, i_ck_system ); @@ -240,8 +290,39 @@ void input_clock_Update( input_clock_t *cl, cl->i_next_drift_update = i_ck_system + CLOCK_FREQ/5; /* FIXME why that */ } + + /* Update the extra buffering value */ + if( !b_can_pace_control || b_reset_reference ) + { + cl->i_buffering_duration = 0; + } + else if( b_buffering_allowed ) + { + /* Try to bufferize more than necessary by reading + * CR_BUFFERING_RATE/256 faster until we have CR_BUFFERING_TARGET. + */ + const mtime_t i_duration = __MAX( i_ck_stream - cl->last.i_stream, 0 ); + + cl->i_buffering_duration += ( i_duration * CR_BUFFERING_RATE + 255 ) / 256; + if( cl->i_buffering_duration > CR_BUFFERING_TARGET ) + cl->i_buffering_duration = CR_BUFFERING_TARGET; + } + //fprintf( stderr, "input_clock_Update: %d :: %lld\n", b_buffering_allowed, cl->i_buffering_duration/1000 ); + + /* */ cl->last = clock_point_Create( i_ck_stream, i_ck_system ); + /* It does not take the decoder latency into account but it is not really + * the goal of the clock here */ + const mtime_t i_system_expected = ClockStreamToSystem( cl, i_ck_stream + AvgGet( &cl->drift ) ); + const mtime_t i_late = ( i_ck_system - cl->i_pts_delay ) - i_system_expected; + *pb_late = i_late > 0; + if( i_late > 0 ) + { + cl->late.pi_value[cl->late.i_index] = i_late; + cl->late.i_index = ( cl->late.i_index + 1 ) % INPUT_CLOCK_LATE_COUNT; + } + vlc_mutex_unlock( &cl->lock ); } @@ -253,8 +334,9 @@ void input_clock_Reset( input_clock_t *cl ) vlc_mutex_lock( &cl->lock ); cl->b_has_reference = false; - cl->ref = clock_point_Create( 0, 0 ); - cl->i_ts_max = 0; + cl->ref = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID ); + cl->b_has_external_clock = false; + cl->i_ts_max = VLC_TS_INVALID; vlc_mutex_unlock( &cl->lock ); } @@ -266,10 +348,12 @@ void input_clock_ChangeRate( input_clock_t *cl, int i_rate ) { vlc_mutex_lock( &cl->lock ); - /* Move the reference point */ if( cl->b_has_reference ) - cl->ref = cl->last; - + { + /* Move the reference point (as if we were playing at the new rate + * from the start */ + cl->ref.i_system = cl->last.i_system - (cl->last.i_system - cl->ref.i_system) * i_rate / cl->i_rate; + } cl->i_rate = i_rate; vlc_mutex_unlock( &cl->lock ); @@ -310,7 +394,7 @@ mtime_t input_clock_GetWakeup( input_clock_t *cl ) /* Synchronized, we can wait */ if( cl->b_has_reference ) - i_wakeup = ClockStreamToSystem( cl, cl->last.i_stream ); + i_wakeup = ClockStreamToSystem( cl, cl->last.i_stream + AvgGet( &cl->drift ) - cl->i_buffering_duration ); vlc_mutex_unlock( &cl->lock ); @@ -318,13 +402,13 @@ mtime_t input_clock_GetWakeup( input_clock_t *cl ) } /***************************************************************************** - * input_clock_GetTS: manages a PTS or DTS + * input_clock_ConvertTS *****************************************************************************/ -mtime_t input_clock_GetTS( input_clock_t *cl, int *pi_rate, - mtime_t i_pts_delay, mtime_t i_ts ) +int input_clock_ConvertTS( input_clock_t *cl, + int *pi_rate, mtime_t *pi_ts0, mtime_t *pi_ts1, + mtime_t i_ts_bound ) { - mtime_t i_converted_ts; - + assert( pi_ts0 ); vlc_mutex_lock( &cl->lock ); if( pi_rate ) @@ -333,17 +417,40 @@ mtime_t input_clock_GetTS( input_clock_t *cl, int *pi_rate, if( !cl->b_has_reference ) { vlc_mutex_unlock( &cl->lock ); - return 0; + *pi_ts0 = VLC_TS_INVALID; + if( pi_ts1 ) + *pi_ts1 = VLC_TS_INVALID; + return VLC_EGENERIC; } /* */ - i_converted_ts = ClockStreamToSystem( cl, i_ts + AvgGet( &cl->drift ) ); - if( i_converted_ts > cl->i_ts_max ) - cl->i_ts_max = i_converted_ts; + const mtime_t i_ts_buffering = cl->i_buffering_duration * cl->i_rate / INPUT_RATE_DEFAULT; + const mtime_t i_ts_delay = cl->i_pts_delay + ClockGetTsOffset( cl ); + + /* */ + if( *pi_ts0 > VLC_TS_INVALID ) + { + *pi_ts0 = ClockStreamToSystem( cl, *pi_ts0 + AvgGet( &cl->drift ) ); + if( *pi_ts0 > cl->i_ts_max ) + cl->i_ts_max = *pi_ts0; + *pi_ts0 += i_ts_delay; + } + + /* XXX we do not ipdate i_ts_max on purpose */ + if( pi_ts1 && *pi_ts1 > VLC_TS_INVALID ) + { + *pi_ts1 = ClockStreamToSystem( cl, *pi_ts1 + AvgGet( &cl->drift ) ) + + i_ts_delay; + } vlc_mutex_unlock( &cl->lock ); - return i_converted_ts + i_pts_delay; + /* Check ts validity */ + if( i_ts_bound != INT64_MAX && + *pi_ts0 > VLC_TS_INVALID && *pi_ts0 >= mdate() + i_ts_delay + i_ts_buffering + i_ts_bound ) + return VLC_EGENERIC; + + return VLC_SUCCESS; } /***************************************************************************** * input_clock_GetRate: Return current rate @@ -382,29 +489,114 @@ int input_clock_GetState( input_clock_t *cl, return VLC_SUCCESS; } -void input_clock_ChangeSystemOrigin( input_clock_t *cl, mtime_t i_system ) +void input_clock_ChangeSystemOrigin( input_clock_t *cl, bool b_absolute, mtime_t i_system ) { vlc_mutex_lock( &cl->lock ); assert( cl->b_has_reference ); - const mtime_t i_offset = i_system - cl->ref.i_system; + mtime_t i_offset; + if( b_absolute ) + { + i_offset = i_system - cl->ref.i_system - ClockGetTsOffset( cl ); + } + else + { + if( !cl->b_has_external_clock ) + { + cl->b_has_external_clock = true; + cl->i_external_clock = i_system; + } + i_offset = i_system - cl->i_external_clock; + } cl->ref.i_system += i_offset; cl->last.i_system += i_offset; - if( cl->b_paused ) - cl->i_pause_date = i_system; + vlc_mutex_unlock( &cl->lock ); +} + +void input_clock_GetSystemOrigin( input_clock_t *cl, mtime_t *pi_system, mtime_t *pi_delay ) +{ + vlc_mutex_lock( &cl->lock ); + + assert( cl->b_has_reference ); + + *pi_system = cl->ref.i_system; + if( pi_delay ) + *pi_delay = cl->i_pts_delay; + + vlc_mutex_unlock( &cl->lock ); +} + +#warning "input_clock_SetJitter needs more work" +void input_clock_SetJitter( input_clock_t *cl, + mtime_t i_pts_delay, int i_cr_average ) +{ + vlc_mutex_lock( &cl->lock ); + + /* Update late observations */ + const mtime_t i_delay_delta = i_pts_delay - cl->i_pts_delay; + mtime_t pi_late[INPUT_CLOCK_LATE_COUNT]; + for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ ) + pi_late[i] = __MAX( cl->late.pi_value[(cl->late.i_index + 1 + i)%INPUT_CLOCK_LATE_COUNT] - i_delay_delta, 0 ); + + for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ ) + cl->late.pi_value[i] = 0; + cl->late.i_index = 0; + + for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ ) + { + if( pi_late[i] <= 0 ) + continue; + cl->late.pi_value[cl->late.i_index] = pi_late[i]; + cl->late.i_index = ( cl->late.i_index + 1 ) % INPUT_CLOCK_LATE_COUNT; + } + + /* TODO always save the value, and when rebuffering use the new one if smaller + * TODO when increasing -> force rebuffering + */ + if( cl->i_pts_delay < i_pts_delay ) + cl->i_pts_delay = i_pts_delay; + + /* */ + if( i_cr_average < 10 ) + i_cr_average = 10; + + if( cl->drift.i_divider != i_cr_average ) + AvgRescale( &cl->drift, i_cr_average ); vlc_mutex_unlock( &cl->lock ); } +mtime_t input_clock_GetJitter( input_clock_t *cl ) +{ + vlc_mutex_lock( &cl->lock ); + +#if INPUT_CLOCK_LATE_COUNT != 3 +# error "unsupported INPUT_CLOCK_LATE_COUNT" +#endif + /* Find the median of the last late values + * It works pretty well at rejecting bad values + * + * XXX we only increase pts_delay over time, decreasing it is + * not that easy if we want to be robust. + */ + const mtime_t *p = cl->late.pi_value; + mtime_t i_late_median = p[0] + p[1] + p[2] - __MIN(__MIN(p[0],p[1]),p[2]) - __MAX(__MAX(p[0],p[1]),p[2]); + mtime_t i_pts_delay = cl->i_pts_delay ; + + vlc_mutex_unlock( &cl->lock ); + + return i_pts_delay + i_late_median; +} + /***************************************************************************** * ClockStreamToSystem: converts a movie clock to system date *****************************************************************************/ static mtime_t ClockStreamToSystem( input_clock_t *cl, mtime_t i_stream ) { if( !cl->b_has_reference ) - return 0; + return VLC_TS_INVALID; return ( i_stream - cl->ref.i_stream ) * cl->i_rate / INPUT_RATE_DEFAULT + cl->ref.i_system; @@ -422,6 +614,15 @@ static mtime_t ClockSystemToStream( input_clock_t *cl, mtime_t i_system ) cl->ref.i_stream; } +/** + * It returns timestamp display offset due to ref/last modfied on rate changes + * It ensures that currently converted dates are not changed. + */ +static mtime_t ClockGetTsOffset( input_clock_t *cl ) +{ + return cl->i_pts_delay * ( cl->i_rate - INPUT_RATE_DEFAULT ) / INPUT_RATE_DEFAULT; +} + /***************************************************************************** * Long term average helpers *****************************************************************************/ @@ -456,4 +657,11 @@ static mtime_t AvgGet( average_t *p_avg ) { return p_avg->i_value; } +static void AvgRescale( average_t *p_avg, int i_divider ) +{ + const mtime_t i_tmp = p_avg->i_value * p_avg->i_divider + p_avg->i_residue; + p_avg->i_divider = i_divider; + p_avg->i_value = i_tmp / p_avg->i_divider; + p_avg->i_residue = i_tmp % p_avg->i_divider; +}