clock: clean up/simplify + remove 1/90000 reference.
[vlc.git] / src / input / clock.c
index b9a9e84..9043328 100644 (file)
@@ -72,7 +72,7 @@ static void ClockNewRef( input_clock_t * p_pgrm,
  *****************************************************************************/
 
 /* Maximum gap allowed between two CRs. */
-#define CR_MAX_GAP 2000000
+#define CR_MAX_GAP (I64C(2000000)*100/9)
 
 /* Latency introduced on DVDs with CR == 0 on chapter change - this is from
  * my dice --Meuuh */
@@ -81,22 +81,13 @@ static void ClockNewRef( input_clock_t * p_pgrm,
 /*****************************************************************************
  * ClockToSysdate: converts a movie clock to system date
  *****************************************************************************/
-static mtime_t ClockToSysdate( input_thread_t *p_input,
-                               input_clock_t *cl, mtime_t i_clock )
+static mtime_t ClockToSysdate( input_clock_t *cl, mtime_t i_clock )
 {
-    mtime_t     i_sysdate = 0;
-
-    if( cl->i_synchro_state == SYNCHRO_OK )
-    {
-        i_sysdate = (mtime_t)(i_clock - cl->cr_ref)
-                        * (mtime_t)p_input->p->i_rate
-                        * (mtime_t)300;
-        i_sysdate /= 27;
-        i_sysdate /= INPUT_RATE_DEFAULT;
-        i_sysdate += (mtime_t)cl->sysdate_ref;
-    }
+    if( cl->i_synchro_state != SYNCHRO_OK )
+        return 0;
 
-    return( i_sysdate );
+    return (i_clock - cl->cr_ref) * cl->i_rate / INPUT_RATE_DEFAULT +
+           cl->sysdate_ref;
 }
 
 /*****************************************************************************
@@ -104,12 +95,10 @@ static mtime_t ClockToSysdate( input_thread_t *p_input,
  *****************************************************************************
  * Caution : the synchro state must be SYNCHRO_OK for this to operate.
  *****************************************************************************/
-static mtime_t ClockCurrent( input_thread_t *p_input,
-                             input_clock_t *cl )
+static mtime_t ClockCurrent( input_clock_t *cl )
 {
-    return( (mdate() - cl->sysdate_ref) * 27 * INPUT_RATE_DEFAULT
-             / p_input->p->i_rate / 300
-             + cl->cr_ref );
+    return (mdate() - cl->sysdate_ref) * INPUT_RATE_DEFAULT / cl->i_rate +
+           cl->cr_ref;
 }
 
 /*****************************************************************************
@@ -126,7 +115,8 @@ static void ClockNewRef( input_clock_t *cl,
  * input_ClockInit: reinitializes the clock reference after a stream
  *                  discontinuity
  *****************************************************************************/
-void input_ClockInit( input_clock_t *cl, vlc_bool_t b_master, int i_cr_average )
+void input_ClockInit( input_thread_t *p_input,
+                      input_clock_t *cl, vlc_bool_t b_master, int i_cr_average )
 {
     cl->i_synchro_state = SYNCHRO_START;
 
@@ -137,6 +127,7 @@ void input_ClockInit( input_clock_t *cl, vlc_bool_t b_master, int i_cr_average )
     cl->sysdate_ref = 0;
     cl->delta_cr = 0;
     cl->i_delta_cr_residue = 0;
+    cl->i_rate = p_input->p->i_rate;
 
     cl->i_cr_average = i_cr_average;
 
@@ -149,86 +140,69 @@ void input_ClockInit( input_clock_t *cl, vlc_bool_t b_master, int i_cr_average )
 void input_ClockSetPCR( input_thread_t *p_input,
                         input_clock_t *cl, mtime_t i_clock )
 {
+    const vlc_bool_t b_synchronize = p_input->b_can_pace_control && cl->b_master;
+    const mtime_t i_mdate = mdate();
+
     if( ( cl->i_synchro_state != SYNCHRO_OK ) ||
         ( i_clock == 0 && cl->last_cr != 0 ) )
     {
         /* Feed synchro with a new reference point. */
         ClockNewRef( cl, i_clock,
-                     cl->last_pts + CR_MEAN_PTS_GAP > mdate() ?
-                     cl->last_pts + CR_MEAN_PTS_GAP : mdate() );
+                         __MAX( cl->last_pts + CR_MEAN_PTS_GAP, i_mdate ) );
         cl->i_synchro_state = SYNCHRO_OK;
 
-        if( p_input->b_can_pace_control && cl->b_master )
-        {
-            cl->last_cr = i_clock;
-            if( !p_input->p->b_out_pace_control )
-            {
-                mtime_t i_wakeup = ClockToSysdate( p_input, cl, i_clock );
-                while( (i_wakeup - mdate()) / CLOCK_FREQ > 1 )
-                {
-                    msleep( CLOCK_FREQ );
-                    if( p_input->b_die ) i_wakeup = mdate();
-                }
-                mwait( i_wakeup );
-            }
-        }
-        else
+        if( !b_synchronize )
         {
             cl->last_cr = 0;
-            cl->last_sysdate = 0;
             cl->delta_cr = 0;
             cl->i_delta_cr_residue = 0;
+            cl->last_sysdate = 0;
+            cl->last_update = 0;
         }
     }
-    else
+    else if ( cl->last_cr != 0 &&
+              ( (cl->last_cr - i_clock) > CR_MAX_GAP ||
+                (cl->last_cr - i_clock) < - CR_MAX_GAP ) )
     {
-        if ( cl->last_cr != 0 &&
-               (    (cl->last_cr - i_clock) > CR_MAX_GAP
-                 || (cl->last_cr - i_clock) < - CR_MAX_GAP ) )
-        {
-            /* Stream discontinuity, for which we haven't received a
-             * warning from the stream control facilities (dd-edited
-             * stream ?). */
-            msg_Warn( p_input, "clock gap, unexpected stream discontinuity" );
-            input_ClockInit( cl, cl->b_master, cl->i_cr_average );
-        }
+        /* Stream discontinuity, for which we haven't received a
+         * warning from the stream control facilities (dd-edited
+         * stream ?). */
+        msg_Warn( p_input, "clock gap, unexpected stream discontinuity" );
+        input_ClockInit( p_input, cl, cl->b_master, cl->i_cr_average );
+    }
 
-        cl->last_cr = i_clock;
+    cl->last_cr = i_clock;
+    cl->last_sysdate = i_mdate;
 
-        if( p_input->b_can_pace_control && cl->b_master )
+    if( b_synchronize )
+    {
+        /* Wait a while before delivering the packets to the decoder.
+         * In case of multiple programs, we arbitrarily follow the
+         * clock of the selected program. */
+        if( !p_input->p->b_out_pace_control )
         {
-            /* Wait a while before delivering the packets to the decoder.
-             * In case of multiple programs, we arbitrarily follow the
-             * clock of the selected program. */
-            if( !p_input->p->b_out_pace_control )
+            mtime_t i_wakeup = ClockToSysdate( cl, i_clock );
+            while( (i_wakeup - mdate()) / CLOCK_FREQ > 1 )
             {
-                mtime_t i_wakeup = ClockToSysdate( p_input, cl, i_clock );
-                while( (i_wakeup - mdate()) / CLOCK_FREQ > 1 )
-                {
-                    msleep( CLOCK_FREQ );
-                    if( p_input->b_die ) i_wakeup = mdate();
-                }
-                mwait( i_wakeup );
+                msleep( CLOCK_FREQ );
+                if( p_input->b_die ) i_wakeup = mdate();
             }
+            mwait( i_wakeup );
         }
-        else if ( mdate() - cl->last_sysdate > 200000 )
-        {
-            /* Smooth clock reference variations. */
-            mtime_t i_extrapoled_clock = ClockCurrent( p_input, cl );
-            mtime_t delta_cr;
-
-            /* Bresenham algorithm to smooth variations. */
-            delta_cr = ( cl->delta_cr * (cl->i_cr_average - 1)
-                               + ( i_extrapoled_clock - i_clock )
-                               + cl->i_delta_cr_residue )
-                           / cl->i_cr_average;
-            cl->i_delta_cr_residue = ( cl->delta_cr * (cl->i_cr_average - 1)
-                                       + ( i_extrapoled_clock - i_clock )
-                                       + cl->i_delta_cr_residue )
-                                    % cl->i_cr_average;
-            cl->delta_cr = delta_cr;
-            cl->last_sysdate = mdate();
-        }
+    }
+    else if ( i_mdate - cl->last_update > 200000 )
+    {
+        /* Smooth clock reference variations. */
+        const mtime_t i_extrapoled_clock = ClockCurrent( cl );
+        /* Bresenham algorithm to smooth variations. */
+        const mtime_t i_tmp = cl->delta_cr * (cl->i_cr_average - 1) +
+                              ( i_extrapoled_clock - i_clock ) * 1  +
+                              cl->i_delta_cr_residue;
+
+        cl->i_delta_cr_residue = i_tmp % cl->i_cr_average;
+        cl->delta_cr           = i_tmp / cl->i_cr_average;
+
+        cl->last_update = i_mdate;
     }
 }
 
@@ -241,7 +215,21 @@ mtime_t input_ClockGetTS( input_thread_t * p_input,
     if( cl->i_synchro_state != SYNCHRO_OK )
         return 0;
 
-    cl->last_pts = ClockToSysdate( p_input, cl, i_ts + cl->delta_cr );
+    cl->last_pts = ClockToSysdate( cl, i_ts + cl->delta_cr );
     return cl->last_pts + p_input->i_pts_delay;
 }
 
+/*****************************************************************************
+ * input_ClockSetRate:
+ *****************************************************************************/
+void input_ClockSetRate( input_thread_t *p_input, input_clock_t *cl )
+{
+    if( cl->i_synchro_state == SYNCHRO_OK )
+    {
+        /* Move the reference point */
+        cl->cr_ref = cl->last_cr;
+        cl->sysdate_ref = cl->last_sysdate;
+    }
+    cl->i_rate = p_input->p->i_rate;
+}
+