X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Finput%2Fclock.c;h=dc010e531288a447a7aa1f14eb39ad6acf66bd9d;hb=b43e57e6281a33020114dc13caab5d99113631d5;hp=7ef5dba9a867d0aa204c4c0539b38b91979f901b;hpb=52c7e46fa529906127f80341b680ebee0957ec75;p=vlc

diff --git a/src/input/clock.c b/src/input/clock.c
index 7ef5dba9a8..dc010e5312 100644
--- a/src/input/clock.c
+++ b/src/input/clock.c
@@ -107,6 +107,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
@@ -135,7 +136,7 @@ struct input_clock_t
      * 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;
 
     /* Clock drift */
@@ -144,6 +145,7 @@ struct input_clock_t
 
     /* Current modifiers */
     int     i_rate;
+    mtime_t i_pts_delay;
     bool    b_paused;
     mtime_t i_pause_date;
 };
@@ -154,7 +156,7 @@ static mtime_t ClockSystemToStream( input_clock_t *, mtime_t i_system );
 /*****************************************************************************
  * 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 )
@@ -162,18 +164,19 @@ 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->last = clock_point_Create( 0, 0 );
+    cl->last = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID );
 
-    cl->i_ts_max = 0;
+    cl->i_ts_max = VLC_TS_INVALID;
 
-    cl->i_next_drift_update = 0;
-    AvgInit( &cl->drift, i_cr_average );
+    cl->i_next_drift_update = VLC_TS_INVALID;
+    AvgInit( &cl->drift, 10 );
 
     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;
 }
@@ -200,15 +203,16 @@ void input_clock_Update( input_clock_t *cl,
 {
     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 ) )
     {
@@ -216,7 +220,7 @@ 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" );
@@ -224,7 +228,7 @@ void input_clock_Update( input_clock_t *cl,
     }
     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. */
@@ -254,8 +258,8 @@ 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->i_ts_max = VLC_TS_INVALID;
 
     vlc_mutex_unlock( &cl->lock );
 }
@@ -322,13 +326,15 @@ 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;
+    mtime_t i_pts_delay;
 
+    assert( pi_ts0 );
     vlc_mutex_lock( &cl->lock );
 
     if( pi_rate )
@@ -337,17 +343,37 @@ 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;
+    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 += cl->i_pts_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 ) ) +
+                  cl->i_pts_delay;
+    }
+
+    i_pts_delay = cl->i_pts_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() + cl->i_pts_delay + i_ts_bound )
+        return VLC_EGENERIC;
+
+    return VLC_SUCCESS;
 }
 /*****************************************************************************
  * input_clock_GetRate: Return current rate
@@ -399,13 +425,35 @@ void input_clock_ChangeSystemOrigin( input_clock_t *cl, mtime_t i_system )
     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 );
+
+    /* 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 );
+}
+
 /*****************************************************************************
  * 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;
@@ -457,4 +505,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;
+}