X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fdecoder.c;h=b4beeddf7ea3ce6632c8ed263373eefdb05cacb9;hb=883450528ae90cc67be6de49034630f3fa93e282;hp=ddf6688ef6697519b97deede6e71b58de2c1016b;hpb=d666030b2349e8a710fcba4d2cabb912cc700580;p=vlc

diff --git a/src/input/decoder.c b/src/input/decoder.c
index ddf6688ef6..b4beeddf7e 100644
--- a/src/input/decoder.c
+++ b/src/input/decoder.c
@@ -445,10 +445,7 @@ static decoder_t * CreateDecoder( input_thread_t *p_input,
 
     p_dec = vlc_object_create( p_input, i_object_type );
     if( p_dec == NULL )
-    {
-        msg_Err( p_input, "out of memory" );
         return NULL;
-    }
 
     p_dec->pf_decode_audio = 0;
     p_dec->pf_decode_video = 0;
@@ -467,7 +464,7 @@ static decoder_t * CreateDecoder( input_thread_t *p_input,
     p_dec->p_owner = p_owner = malloc( sizeof( decoder_owner_sys_t ) );
     if( p_dec->p_owner == NULL )
     {
-        msg_Err( p_dec, "out of memory" );
+        vlc_object_release( p_dec );
         return NULL;
     }
     p_dec->p_owner->b_own_thread = true;
@@ -485,7 +482,8 @@ static decoder_t * CreateDecoder( input_thread_t *p_input,
     /* decoder fifo */
     if( ( p_dec->p_owner->p_fifo = block_FifoNew() ) == NULL )
     {
-        msg_Err( p_dec, "out of memory" );
+        free( p_dec->p_owner );
+        vlc_object_release( p_dec );
         return NULL;
     }
 
@@ -621,20 +619,30 @@ static inline void DecoderUpdatePreroll( int64_t *pi_preroll, const block_t *p )
 }
 static void DecoderDecodeAudio( decoder_t *p_dec, block_t *p_block )
 {
-    input_thread_t *p_input = p_dec->p_owner->p_input;
-    const int i_rate = p_block->i_rate;
-    aout_buffer_t *p_aout_buf;
+    input_thread_t  *p_input = p_dec->p_owner->p_input;
+    const int       i_rate = p_block->i_rate;
+    aout_buffer_t   *p_aout_buf;
 
     while( (p_aout_buf = p_dec->pf_decode_audio( p_dec, &p_block )) )
     {
+        aout_instance_t *p_aout = p_dec->p_owner->p_aout;
+        aout_input_t    *p_aout_input = p_dec->p_owner->p_aout_input;
+
+        if( p_dec->b_die )
+        {
+            /* It prevent freezing VLC in case of broken decoder */
+            aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
+            if( p_block )
+                block_Release( p_block );
+            break;
+        }
         vlc_mutex_lock( &p_input->p->counters.counters_lock );
         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_audio, 1, NULL );
         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
 
         if( p_aout_buf->start_date < p_dec->p_owner->i_preroll_end )
         {
-            aout_DecDeleteBuffer( p_dec->p_owner->p_aout,
-                                  p_dec->p_owner->p_aout_input, p_aout_buf );
+            aout_DecDeleteBuffer( p_aout, p_aout_input, p_aout_buf );
             continue;
         }
 
@@ -644,9 +652,7 @@ static void DecoderDecodeAudio( decoder_t *p_dec, block_t *p_block )
             msg_Dbg( p_dec, "End of audio preroll" );
             p_dec->p_owner->i_preroll_end = -1;
         }
-        aout_DecPlay( p_dec->p_owner->p_aout,
-                      p_dec->p_owner->p_aout_input,
-                      p_aout_buf, i_rate );
+        aout_DecPlay( p_aout, p_aout_input, p_aout_buf, i_rate );
     }
 }
 static void DecoderGetCc( decoder_t *p_dec, decoder_t *p_dec_cc )
@@ -726,28 +732,136 @@ 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;
+
+    /* Enable with --auto-adjust-pts-delay */
+    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.
+     * The whole point of this, is to bypass the pts_delay set
+     * by the access but also the delay arbitraly set by
+     * the remote server.
+     * Actually the remote server's muxer may set up a
+     * pts<->dts delay in the muxed stream. That is
+     * why we may end up in having a negative pts_delay,
+     * to compensate that artificial delay. */
+    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;
-    picture_t *p_pic;
+    picture_t      *p_pic;
 
     while( (p_pic = p_dec->pf_decode_video( p_dec, &p_block )) )
     {
+        vout_thread_t  *p_vout = p_dec->p_owner->p_vout;
+        if( p_dec->b_die )
+        {
+            /* It prevent freezing VLC in case of broken decoder */
+            VoutDisplayedPicture( p_vout, p_pic );
+            if( p_block )
+                block_Release( p_block );
+            break;
+        }
+
         vlc_mutex_lock( &p_input->p->counters.counters_lock );
         stats_UpdateInteger( p_dec, p_input->p->counters.p_decoded_video, 1, NULL );
         vlc_mutex_unlock( &p_input->p->counters.counters_lock );
 
         if( p_pic->date < p_dec->p_owner->i_preroll_end )
         {
-            VoutDisplayedPicture( p_dec->p_owner->p_vout, p_pic );
+            VoutDisplayedPicture( p_vout, p_pic );
             continue;
         }
 
         if( p_dec->p_owner->i_preroll_end > 0 )
         {
             msg_Dbg( p_dec, "End of video preroll" );
-            if( p_dec->p_owner->p_vout )
-                VoutFlushPicture( p_dec->p_owner->p_vout );
+            if( p_vout )
+                VoutFlushPicture( p_vout );
             /* */
             p_dec->p_owner->i_preroll_end = -1;
         }
@@ -755,9 +869,11 @@ static void DecoderDecodeVideo( decoder_t *p_dec, block_t *p_block )
         if( ( !p_dec->p_owner->p_packetizer || !p_dec->p_owner->p_packetizer->pf_get_cc ) && p_dec->pf_get_cc )
             DecoderGetCc( p_dec, p_dec );
 
-        vout_DatePicture( p_dec->p_owner->p_vout, p_pic,
-                          p_pic->date );
-        vout_DisplayPicture( p_dec->p_owner->p_vout, p_pic );
+        vout_DatePicture( p_vout, p_pic, p_pic->date );
+
+        optimize_video_pts( p_dec );
+
+        vout_DisplayPicture( p_vout, p_pic );
     }
 }