libvlc: Split public headers by object and layers.

[vlc] / src / input / clock.c

diff --git a/src/input/clock.c b/src/input/clock.c
index beee45ef0b9209e82ae7d2ab91d9c97ca318e349..dc010e531288a447a7aa1f14eb39ad6acf66bd9d 100644 (file)
--- a/src/input/clock.c
+++ b/src/input/clock.c
@@ -33,6 +33,7 @@
 #include <vlc_common.h>
 #include <vlc_input.h>
 #include "clock.h"
+#include <assert.h>
 
 /* 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)
@@ -106,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
@@ -134,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 */
@@ -143,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;
 };
@@ -153,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 )
@@ -161,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;
 }
@@ -199,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 ) )
     {
@@ -215,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" );
@@ -223,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. */
@@ -253,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 );
 }
@@ -268,7 +273,10 @@ void input_clock_ChangeRate( input_clock_t *cl, int i_rate )
 
     /* Move the reference point */
     if( cl->b_has_reference )
+    {
+        cl->last.i_system = ClockStreamToSystem( cl, cl->last.i_stream );
         cl->ref = cl->last;
+    }
 
     cl->i_rate = i_rate;
 
@@ -318,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 )
@@ -333,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
@@ -392,8 +422,27 @@ void input_clock_ChangeSystemOrigin( input_clock_t *cl, mtime_t i_system )
     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 );
+}
+
+#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 );
 }
@@ -404,7 +453,7 @@ void input_clock_ChangeSystemOrigin( input_clock_t *cl, mtime_t i_system )
 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;
@@ -456,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;
+}