From ea89b9c2d9d5b13c28da56f6b5ec284614db491f Mon Sep 17 00:00:00 2001 From: Pierre d'Herbemont Date: Fri, 6 Jun 2008 00:13:27 +0200 Subject: [PATCH] input: Add --auto-adjust-pts-delay, this allows to stream/receive with an extremely low latency. Simple demo: vlc --sout="#duplicate{dst=display,dst='transcode{vcodec=mp4v}:std{access=http,dst=0.0.0.0:8080,mux=ts}'}" --ignore-config --use-stream-immediate movie.avi & vlc --use-stream-immediate http://127.0.0.1:8080 and vlc --use-stream-immediate http://127.0.0.1:8080 --auto-adjust-pts-delay You'll have to wait a bit until the pts delay is auto adjusted. Generally it takes 2-4 seconds, because access set a very high default pts delay value. One amelioration would be to lower the pts_delay when this option is set to allow a quicker convergence. The general algorithm requires some tuning, but results are here. Note, this only works if there is a video track. A similar function could be developped for the audio tracks. --- src/input/decoder.c | 93 ++++++++++++++++++++++++++++++++++++++ src/input/input_internal.h | 7 +++ src/input/var.c | 3 ++ src/libvlc-module.c | 2 + 4 files changed, 105 insertions(+) diff --git a/src/input/decoder.c b/src/input/decoder.c index ddf6688ef6..ce171b8c26 100644 --- a/src/input/decoder.c +++ b/src/input/decoder.c @@ -726,6 +726,96 @@ static void VoutFlushPicture( vout_thread_t *p_vout ) } vlc_mutex_unlock( &p_vout->picture_lock ); } + + +static void optimize_video_pts( decoder_t *p_dec ) +{ + picture_t * oldest_pict = NULL; + picture_t * youngest_pict = NULL; + int i; + + input_thread_t * p_input = p_dec->p_owner->p_input; + vout_thread_t * p_vout = p_dec->p_owner->p_vout; + input_thread_private_t * p_priv = p_input->p; + + if( !p_priv->pts_adjust.auto_adjust ) return; + + for( i = 0; i < I_RENDERPICTURES; i++ ) + { + picture_t * pic = PP_RENDERPICTURE[i]; + if( pic->i_status != READY_PICTURE ) + continue; + + if( !oldest_pict || pic->date < oldest_pict->date ) + oldest_pict = pic; + if( !youngest_pict || pic->date > youngest_pict->date ) + youngest_pict = pic; + } + + if( !youngest_pict || !oldest_pict ) + return; + + /* Try to find if we can reduce the pts + * This first draft is way to simple, and we can't say if the + * algo will converge. It's also full of constants. + * But this simple algo allows to reduce the latency + * to the minimum. */ + mtime_t buffer_size = youngest_pict->date - oldest_pict->date; + int64_t pts_slide = 0; + if( buffer_size < 10000 ) + { + if( p_priv->pts_adjust.i_num_faulty > 10 ) + { + pts_slide = __MAX(p_input->i_pts_delay *3 / 2, 10000); + p_priv->pts_adjust.i_num_faulty = 0; + } + if( p_priv->pts_adjust.to_high ) + { + p_priv->pts_adjust.to_high = !p_priv->pts_adjust.to_high; + p_priv->pts_adjust.i_num_faulty = 0; + } + p_priv->pts_adjust.i_num_faulty++; + } + else if( buffer_size > 100000 ) + { + if( p_priv->pts_adjust.i_num_faulty > 25 ) + { + pts_slide = -buffer_size/2; + p_priv->pts_adjust.i_num_faulty = 0; + } + if( p_priv->pts_adjust.to_high ) + { + p_priv->pts_adjust.to_high = !p_priv->pts_adjust.to_high; + p_priv->pts_adjust.i_num_faulty = 0; + } + p_priv->pts_adjust.i_num_faulty++; + } + if( pts_slide ) + { + mtime_t origi_delay = p_input->i_pts_delay; + + p_input->i_pts_delay += pts_slide; + + /* Don't play with the pts delay for more than -2<->3sec */ + if( p_input->i_pts_delay < -2000000 ) + p_input->i_pts_delay = -2000000; + else if( p_input->i_pts_delay > 3000000 ) + p_input->i_pts_delay = 3000000; + pts_slide = p_input->i_pts_delay - origi_delay; + + msg_Dbg( p_input, "Sliding the pts by %dms pts delay at %dms picture buffer was %dms", + (int)pts_slide/1000, (int)p_input->i_pts_delay/1000, (int)buffer_size/1000); + + vlc_mutex_lock( &p_vout->picture_lock ); + /* Slide all the picture */ + for( i = 0; i < I_RENDERPICTURES; i++ ) + PP_RENDERPICTURE[i]->date += pts_slide; + /* FIXME: slide aout/spu */ + vlc_mutex_unlock( &p_vout->picture_lock ); + + } +} + static void DecoderDecodeVideo( decoder_t *p_dec, block_t *p_block ) { input_thread_t *p_input = p_dec->p_owner->p_input; @@ -757,6 +847,9 @@ static void DecoderDecodeVideo( decoder_t *p_dec, block_t *p_block ) vout_DatePicture( p_dec->p_owner->p_vout, p_pic, p_pic->date ); + + optimize_video_pts( p_dec ); + vout_DisplayPicture( p_dec->p_owner->p_vout, p_pic ); } } diff --git a/src/input/input_internal.h b/src/input/input_internal.h index dfa59b66c5..da57642e8b 100644 --- a/src/input/input_internal.h +++ b/src/input/input_internal.h @@ -112,6 +112,13 @@ struct input_thread_private_t int i_slave; input_source_t **slave; + /* pts delay fixup */ + struct { + int i_num_faulty; + bool to_high; + bool auto_adjust; + } pts_adjust; + /* Stats counters */ struct { counter_t *p_read_packets; diff --git a/src/input/var.c b/src/input/var.c index 28b4d75815..b2601073a8 100644 --- a/src/input/var.c +++ b/src/input/var.c @@ -165,6 +165,9 @@ void input_ControlVarInit ( input_thread_t *p_input ) var_Change( p_input, "spu-delay", VLC_VAR_SETVALUE, &val, NULL ); ADD_CALLBACK( "spu-delay", EsDelayCallback ); + p_input->p->pts_adjust.auto_adjust = var_CreateGetBool( + p_input, "auto-adjust-pts-delay" ); + /* Video ES */ var_Create( p_input, "video-es", VLC_VAR_INTEGER | VLC_VAR_HASCHOICE ); text.psz_string = _("Video Track"); diff --git a/src/libvlc-module.c b/src/libvlc-module.c index 2373f6980a..f302c3f5cd 100644 --- a/src/libvlc-module.c +++ b/src/libvlc-module.c @@ -1822,6 +1822,8 @@ vlc_module_begin(); add_bool( "use-stream-immediate", false, NULL, USE_STREAM_IMMEDIATE, USE_STREAM_IMMEDIATE_LONGTEXT, false ); + add_bool( "auto-adjust-pts-delay", false, NULL, + "auto-adjust-pts-delay", "auto-adjust-pts-delay", false ); #if !defined(__APPLE__) && !defined(SYS_BEOS) && defined(LIBVLC_USE_PTHREAD) add_bool( "rt-priority", false, NULL, RT_PRIORITY_TEXT, -- 2.39.2