src/input/clock.c

   1 /*****************************************************************************
   2  * clock.c: Clock/System date convertions, stream management
   3  *****************************************************************************
   4  * Copyright (C) 1999-2008 VLC authors and VideoLAN
   5  * Copyright (C) 2008 Laurent Aimar
   6  * $Id$
   7  *
   8  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   9  *          Laurent Aimar < fenrir _AT_ videolan _DOT_ org >
  10  *
  11  * This program is free software; you can redistribute it and/or modify it
  12  * under the terms of the GNU Lesser General Public License as published by
  13  * the Free Software Foundation; either version 2.1 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19  * GNU Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this program; if not, write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29 #ifdef HAVE_CONFIG_H
  30 # include "config.h"
  31 #endif
  32
  33 #include <vlc_common.h>
  34 #include <vlc_input.h>
  35 #include "clock.h"
  36 #include <assert.h>
  37
  38 /* TODO:
  39  * - clean up locking once clock code is stable
  40  *
  41  */
  42
  43 /*
  44  * DISCUSSION : SYNCHRONIZATION METHOD
  45  *
  46  * In some cases we can impose the pace of reading (when reading from a
  47  * file or a pipe), and for the synchronization we simply sleep() until
  48  * it is time to deliver the packet to the decoders. When reading from
  49  * the network, we must be read at the same pace as the server writes,
  50  * otherwise the kernel's buffer will trash packets. The risk is now to
  51  * overflow the input buffers in case the server goes too fast, that is
  52  * why we do these calculations :
  53  *
  54  * We compute a mean for the pcr because we want to eliminate the
  55  * network jitter and keep the low frequency variations. The mean is
  56  * in fact a low pass filter and the jitter is a high frequency signal
  57  * that is why it is eliminated by the filter/average.
  58  *
  59  * The low frequency variations enable us to synchronize the client clock
  60  * with the server clock because they represent the time variation between
  61  * the 2 clocks. Those variations (ie the filtered pcr) are used to compute
  62  * the presentation dates for the audio and video frames. With those dates
  63  * we can decode (or trash) the MPEG2 stream at "exactly" the same rate
  64  * as it is sent by the server and so we keep the synchronization between
  65  * the server and the client.
  66  *
  67  * It is a very important matter if you want to avoid underflow or overflow
  68  * in all the FIFOs, but it may be not enough.
  69  */
  70
  71 /* i_cr_average : Maximum number of samples used to compute the
  72  * dynamic average value.
  73  * We use the following formula :
  74  * new_average = (old_average * c_average + new_sample_value) / (c_average +1)
  75  */
  76
  77
  78 /*****************************************************************************
  79  * Constants
  80  *****************************************************************************/
  81
  82 /* Maximum gap allowed between two CRs. */
  83 #define CR_MAX_GAP (60 * CLOCK_FREQ)
  84
  85 /* Latency introduced on DVDs with CR == 0 on chapter change - this is from
  86  * my dice --Meuuh */
  87 #define CR_MEAN_PTS_GAP (300000)
  88
  89 /* Rate (in 1/256) at which we will read faster to try to increase our
  90  * internal buffer (if we control the pace of the source).
  91  */
  92 #define CR_BUFFERING_RATE (48)
  93
  94 /* Extra internal buffer value (in CLOCK_FREQ)
  95  * It is 60s max, remember as it is limited by the size it takes by es_out.c
  96  * it can be really large.
  97  */
  98 //#define CR_BUFFERING_TARGET (60000000)
  99 /* Due to some problems in es_out, we cannot use a large value yet */
 100 #define CR_BUFFERING_TARGET (100000)
 101
 102 /*****************************************************************************
 103  * Structures
 104  *****************************************************************************/
 105
 106 /**
 107  * This structure holds long term average
 108  */
 109 typedef struct
 110 {
 111     mtime_t i_value;
 112     int     i_residue;
 113
 114     int     i_count;
 115     int     i_divider;
 116 } average_t;
 117 static void    AvgInit( average_t *, int i_divider );
 118 static void    AvgClean( average_t * );
 119
 120 static void    AvgReset( average_t * );
 121 static void    AvgUpdate( average_t *, mtime_t i_value );
 122 static mtime_t AvgGet( average_t * );
 123 static void    AvgRescale( average_t *, int i_divider );
 124
 125 /* */
 126 typedef struct
 127 {
 128     mtime_t i_stream;
 129     mtime_t i_system;
 130 } clock_point_t;
 131
 132 static inline clock_point_t clock_point_Create( mtime_t i_stream, mtime_t i_system )
 133 {
 134     clock_point_t p = { .i_stream = i_stream, .i_system = i_system };
 135     return p;
 136 }
 137
 138 /* */
 139 #define INPUT_CLOCK_LATE_COUNT (3)
 140
 141 /* */
 142 struct input_clock_t
 143 {
 144     /* */
 145     vlc_mutex_t lock;
 146
 147     /* Last point
 148      * It is used to detect unexpected stream discontinuities */
 149     clock_point_t last;
 150
 151     /* Maximal timestamp returned by input_clock_ConvertTS (in system unit) */
 152     mtime_t i_ts_max;
 153
 154     /* Amount of extra buffering expressed in stream clock */
 155     mtime_t i_buffering_duration;
 156
 157     /* Clock drift */
 158     mtime_t i_next_drift_update;
 159     average_t drift;
 160
 161     /* Late statistics */
 162     struct
 163     {
 164         mtime_t  pi_value[INPUT_CLOCK_LATE_COUNT];
 165         unsigned i_index;
 166     } late;
 167
 168     /* Reference point */
 169     clock_point_t ref;
 170     bool          b_has_reference;
 171
 172     /* External clock drift */
 173     mtime_t       i_external_clock;
 174     bool          b_has_external_clock;
 175
 176     /* Current modifiers */
 177     bool    b_paused;
 178     int     i_rate;
 179     mtime_t i_pts_delay;
 180     mtime_t i_pause_date;
 181 };
 182
 183 static mtime_t ClockStreamToSystem( input_clock_t *, mtime_t i_stream );
 184 static mtime_t ClockSystemToStream( input_clock_t *, mtime_t i_system );
 185
 186 static mtime_t ClockGetTsOffset( input_clock_t * );
 187
 188 /*****************************************************************************
 189  * input_clock_New: create a new clock
 190  *****************************************************************************/
 191 input_clock_t *input_clock_New( int i_rate )
 192 {
 193     input_clock_t *cl = malloc( sizeof(*cl) );
 194     if( !cl )
 195         return NULL;
 196
 197     vlc_mutex_init( &cl->lock );
 198     cl->b_has_reference = false;
 199     cl->ref = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID );
 200     cl->b_has_external_clock = false;
 201
 202     cl->last = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID );
 203
 204     cl->i_ts_max = VLC_TS_INVALID;
 205
 206     cl->i_buffering_duration = 0;
 207
 208     cl->i_next_drift_update = VLC_TS_INVALID;
 209     AvgInit( &cl->drift, 10 );
 210
 211     cl->late.i_index = 0;
 212     for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ )
 213         cl->late.pi_value[i] = 0;
 214
 215     cl->i_rate = i_rate;
 216     cl->i_pts_delay = 0;
 217     cl->b_paused = false;
 218     cl->i_pause_date = VLC_TS_INVALID;
 219
 220     return cl;
 221 }
 222
 223 /*****************************************************************************
 224  * input_clock_Delete: destroy a new clock
 225  *****************************************************************************/
 226 void input_clock_Delete( input_clock_t *cl )
 227 {
 228     AvgClean( &cl->drift );
 229     vlc_mutex_destroy( &cl->lock );
 230     free( cl );
 231 }
 232
 233 /*****************************************************************************
 234  * input_clock_Update: manages a clock reference
 235  *
 236  *  i_ck_stream: date in stream clock
 237  *  i_ck_system: date in system clock
 238  *****************************************************************************/
 239 void input_clock_Update( input_clock_t *cl, vlc_object_t *p_log,
 240                          bool *pb_late,
 241                          bool b_can_pace_control, bool b_buffering_allowed,
 242                          mtime_t i_ck_stream, mtime_t i_ck_system )
 243 {
 244     bool b_reset_reference = false;
 245
 246     assert( i_ck_stream > VLC_TS_INVALID && i_ck_system > VLC_TS_INVALID );
 247
 248     vlc_mutex_lock( &cl->lock );
 249
 250     if( !cl->b_has_reference )
 251     {
 252         /* */
 253         b_reset_reference= true;
 254     }
 255     else if( cl->last.i_stream > VLC_TS_INVALID &&
 256              ( (cl->last.i_stream - i_ck_stream) > CR_MAX_GAP ||
 257                (cl->last.i_stream - i_ck_stream) < -CR_MAX_GAP ) )
 258     {
 259         /* Stream discontinuity, for which we haven't received a
 260          * warning from the stream control facilities (dd-edited
 261          * stream ?). */
 262         msg_Warn( p_log, "clock gap, unexpected stream discontinuity" );
 263         cl->i_ts_max = VLC_TS_INVALID;
 264
 265         /* */
 266         msg_Warn( p_log, "feeding synchro with a new reference point trying to recover from clock gap" );
 267         b_reset_reference= true;
 268     }
 269
 270     /* */
 271     if( b_reset_reference )
 272     {
 273         cl->i_next_drift_update = VLC_TS_INVALID;
 274         AvgReset( &cl->drift );
 275
 276         /* Feed synchro with a new reference point. */
 277         cl->b_has_reference = true;
 278         cl->ref = clock_point_Create( i_ck_stream,
 279                                       __MAX( cl->i_ts_max + CR_MEAN_PTS_GAP, i_ck_system ) );
 280         cl->b_has_external_clock = false;
 281     }
 282
 283     /* Compute the drift between the stream clock and the system clock
 284      * when we don't control the source pace */
 285     if( !b_can_pace_control && cl->i_next_drift_update < i_ck_system )
 286     {
 287         const mtime_t i_converted = ClockSystemToStream( cl, i_ck_system );
 288
 289         AvgUpdate( &cl->drift, i_converted - i_ck_stream );
 290
 291         cl->i_next_drift_update = i_ck_system + CLOCK_FREQ/5; /* FIXME why that */
 292     }
 293
 294     /* Update the extra buffering value */
 295     if( !b_can_pace_control || b_reset_reference )
 296     {
 297         cl->i_buffering_duration = 0;
 298     }
 299     else if( b_buffering_allowed )
 300     {
 301         /* Try to bufferize more than necessary by reading
 302          * CR_BUFFERING_RATE/256 faster until we have CR_BUFFERING_TARGET.
 303          */
 304         const mtime_t i_duration = __MAX( i_ck_stream - cl->last.i_stream, 0 );
 305
 306         cl->i_buffering_duration += ( i_duration * CR_BUFFERING_RATE + 255 ) / 256;
 307         if( cl->i_buffering_duration > CR_BUFFERING_TARGET )
 308             cl->i_buffering_duration = CR_BUFFERING_TARGET;
 309     }
 310     //fprintf( stderr, "input_clock_Update: %d :: %lld\n", b_buffering_allowed, cl->i_buffering_duration/1000 );
 311
 312     /* */
 313     cl->last = clock_point_Create( i_ck_stream, i_ck_system );
 314
 315     /* It does not take the decoder latency into account but it is not really
 316      * the goal of the clock here */
 317     const mtime_t i_system_expected = ClockStreamToSystem( cl, i_ck_stream + AvgGet( &cl->drift ) );
 318     const mtime_t i_late = ( i_ck_system - cl->i_pts_delay ) - i_system_expected;
 319     *pb_late = i_late > 0;
 320     if( i_late > 0 )
 321     {
 322         cl->late.pi_value[cl->late.i_index] = i_late;
 323         cl->late.i_index = ( cl->late.i_index + 1 ) % INPUT_CLOCK_LATE_COUNT;
 324     }
 325
 326     vlc_mutex_unlock( &cl->lock );
 327 }
 328
 329 /*****************************************************************************
 330  * input_clock_Reset:
 331  *****************************************************************************/
 332 void input_clock_Reset( input_clock_t *cl )
 333 {
 334     vlc_mutex_lock( &cl->lock );
 335
 336     cl->b_has_reference = false;
 337     cl->ref = clock_point_Create( VLC_TS_INVALID, VLC_TS_INVALID );
 338     cl->b_has_external_clock = false;
 339     cl->i_ts_max = VLC_TS_INVALID;
 340
 341     vlc_mutex_unlock( &cl->lock );
 342 }
 343
 344 /*****************************************************************************
 345  * input_clock_ChangeRate:
 346  *****************************************************************************/
 347 void input_clock_ChangeRate( input_clock_t *cl, int i_rate )
 348 {
 349     vlc_mutex_lock( &cl->lock );
 350
 351     if( cl->b_has_reference )
 352     {
 353         /* Move the reference point (as if we were playing at the new rate
 354          * from the start */
 355         cl->ref.i_system = cl->last.i_system - (cl->last.i_system - cl->ref.i_system) * i_rate / cl->i_rate;
 356     }
 357     cl->i_rate = i_rate;
 358
 359     vlc_mutex_unlock( &cl->lock );
 360 }
 361
 362 /*****************************************************************************
 363  * input_clock_ChangePause:
 364  *****************************************************************************/
 365 void input_clock_ChangePause( input_clock_t *cl, bool b_paused, mtime_t i_date )
 366 {
 367     vlc_mutex_lock( &cl->lock );
 368     assert( (!cl->b_paused) != (!b_paused) );
 369
 370     if( cl->b_paused )
 371     {
 372         const mtime_t i_duration = i_date - cl->i_pause_date;
 373
 374         if( cl->b_has_reference && i_duration > 0 )
 375         {
 376             cl->ref.i_system += i_duration;
 377             cl->last.i_system += i_duration;
 378         }
 379     }
 380     cl->i_pause_date = i_date;
 381     cl->b_paused = b_paused;
 382
 383     vlc_mutex_unlock( &cl->lock );
 384 }
 385
 386 /*****************************************************************************
 387  * input_clock_GetWakeup
 388  *****************************************************************************/
 389 mtime_t input_clock_GetWakeup( input_clock_t *cl )
 390 {
 391     mtime_t i_wakeup = 0;
 392
 393     vlc_mutex_lock( &cl->lock );
 394
 395     /* Synchronized, we can wait */
 396     if( cl->b_has_reference )
 397         i_wakeup = ClockStreamToSystem( cl, cl->last.i_stream + AvgGet( &cl->drift ) - cl->i_buffering_duration );
 398
 399     vlc_mutex_unlock( &cl->lock );
 400
 401     return i_wakeup;
 402 }
 403
 404 /*****************************************************************************
 405  * input_clock_ConvertTS
 406  *****************************************************************************/
 407 int input_clock_ConvertTS( vlc_object_t *p_object, input_clock_t *cl,
 408                            int *pi_rate, mtime_t *pi_ts0, mtime_t *pi_ts1,
 409                            mtime_t i_ts_bound )
 410 {
 411     assert( pi_ts0 );
 412     vlc_mutex_lock( &cl->lock );
 413
 414     if( pi_rate )
 415         *pi_rate = cl->i_rate;
 416
 417     if( !cl->b_has_reference )
 418     {
 419         vlc_mutex_unlock( &cl->lock );
 420         msg_Err(p_object, "Timestamp conversion failed for %"PRId64": "
 421                 "no reference clock", *pi_ts0);
 422         *pi_ts0 = VLC_TS_INVALID;
 423         if( pi_ts1 )
 424             *pi_ts1 = VLC_TS_INVALID;
 425         return VLC_EGENERIC;
 426     }
 427
 428     /* */
 429     const mtime_t i_ts_buffering = cl->i_buffering_duration * cl->i_rate / INPUT_RATE_DEFAULT;
 430     const mtime_t i_ts_delay = cl->i_pts_delay + ClockGetTsOffset( cl );
 431
 432     /* */
 433     if( *pi_ts0 > VLC_TS_INVALID )
 434     {
 435         *pi_ts0 = ClockStreamToSystem( cl, *pi_ts0 + AvgGet( &cl->drift ) );
 436         if( *pi_ts0 > cl->i_ts_max )
 437             cl->i_ts_max = *pi_ts0;
 438         *pi_ts0 += i_ts_delay;
 439     }
 440
 441     /* XXX we do not update i_ts_max on purpose */
 442     if( pi_ts1 && *pi_ts1 > VLC_TS_INVALID )
 443     {
 444         *pi_ts1 = ClockStreamToSystem( cl, *pi_ts1 + AvgGet( &cl->drift ) ) +
 445                   i_ts_delay;
 446     }
 447
 448     vlc_mutex_unlock( &cl->lock );
 449
 450     /* Check ts validity */
 451     if (i_ts_bound != INT64_MAX && *pi_ts0 > VLC_TS_INVALID) {
 452         if (*pi_ts0 >= mdate() + i_ts_delay + i_ts_buffering + i_ts_bound) {
 453             msg_Err(p_object,
 454                 "Timestamp conversion failed (delay %"PRId64", buffering "
 455                 "%"PRId64", bound %"PRId64")",
 456                 i_ts_delay, i_ts_buffering, i_ts_bound);
 457             return VLC_EGENERIC;
 458         }
 459     }
 460
 461     return VLC_SUCCESS;
 462 }
 463 /*****************************************************************************
 464  * input_clock_GetRate: Return current rate
 465  *****************************************************************************/
 466 int input_clock_GetRate( input_clock_t *cl )
 467 {
 468     int i_rate;
 469
 470     vlc_mutex_lock( &cl->lock );
 471     i_rate = cl->i_rate;
 472     vlc_mutex_unlock( &cl->lock );
 473
 474     return i_rate;
 475 }
 476
 477 int input_clock_GetState( input_clock_t *cl,
 478                           mtime_t *pi_stream_start, mtime_t *pi_system_start,
 479                           mtime_t *pi_stream_duration, mtime_t *pi_system_duration )
 480 {
 481     vlc_mutex_lock( &cl->lock );
 482
 483     if( !cl->b_has_reference )
 484     {
 485         vlc_mutex_unlock( &cl->lock );
 486         return VLC_EGENERIC;
 487     }
 488
 489     *pi_stream_start = cl->ref.i_stream;
 490     *pi_system_start = cl->ref.i_system;
 491
 492     *pi_stream_duration = cl->last.i_stream - cl->ref.i_stream;
 493     *pi_system_duration = cl->last.i_system - cl->ref.i_system;
 494
 495     vlc_mutex_unlock( &cl->lock );
 496
 497     return VLC_SUCCESS;
 498 }
 499
 500 void input_clock_ChangeSystemOrigin( input_clock_t *cl, bool b_absolute, mtime_t i_system )
 501 {
 502     vlc_mutex_lock( &cl->lock );
 503
 504     assert( cl->b_has_reference );
 505     mtime_t i_offset;
 506     if( b_absolute )
 507     {
 508         i_offset = i_system - cl->ref.i_system - ClockGetTsOffset( cl );
 509     }
 510     else
 511     {
 512         if( !cl->b_has_external_clock )
 513         {
 514             cl->b_has_external_clock = true;
 515             cl->i_external_clock     = i_system;
 516         }
 517         i_offset = i_system - cl->i_external_clock;
 518     }
 519
 520     cl->ref.i_system += i_offset;
 521     cl->last.i_system += i_offset;
 522
 523     vlc_mutex_unlock( &cl->lock );
 524 }
 525
 526 void input_clock_GetSystemOrigin( input_clock_t *cl, mtime_t *pi_system, mtime_t *pi_delay )
 527 {
 528     vlc_mutex_lock( &cl->lock );
 529
 530     assert( cl->b_has_reference );
 531
 532     *pi_system = cl->ref.i_system;
 533     if( pi_delay )
 534         *pi_delay  = cl->i_pts_delay;
 535
 536     vlc_mutex_unlock( &cl->lock );
 537 }
 538
 539 #warning "input_clock_SetJitter needs more work"
 540 void input_clock_SetJitter( input_clock_t *cl,
 541                             mtime_t i_pts_delay, int i_cr_average )
 542 {
 543     vlc_mutex_lock( &cl->lock );
 544
 545     /* Update late observations */
 546     const mtime_t i_delay_delta = i_pts_delay - cl->i_pts_delay;
 547     mtime_t pi_late[INPUT_CLOCK_LATE_COUNT];
 548     for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ )
 549         pi_late[i] = __MAX( cl->late.pi_value[(cl->late.i_index + 1 + i)%INPUT_CLOCK_LATE_COUNT] - i_delay_delta, 0 );
 550
 551     for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ )
 552         cl->late.pi_value[i] = 0;
 553     cl->late.i_index = 0;
 554
 555     for( int i = 0; i < INPUT_CLOCK_LATE_COUNT; i++ )
 556     {
 557         if( pi_late[i] <= 0 )
 558             continue;
 559         cl->late.pi_value[cl->late.i_index] = pi_late[i];
 560         cl->late.i_index = ( cl->late.i_index + 1 ) % INPUT_CLOCK_LATE_COUNT;
 561     }
 562
 563     /* TODO always save the value, and when rebuffering use the new one if smaller
 564      * TODO when increasing -> force rebuffering
 565      */
 566     if( cl->i_pts_delay < i_pts_delay )
 567         cl->i_pts_delay = i_pts_delay;
 568
 569     /* */
 570     if( i_cr_average < 10 )
 571         i_cr_average = 10;
 572
 573     if( cl->drift.i_divider != i_cr_average )
 574         AvgRescale( &cl->drift, i_cr_average );
 575
 576     vlc_mutex_unlock( &cl->lock );
 577 }
 578
 579 mtime_t input_clock_GetJitter( input_clock_t *cl )
 580 {
 581     vlc_mutex_lock( &cl->lock );
 582
 583 #if INPUT_CLOCK_LATE_COUNT != 3
 584 #   error "unsupported INPUT_CLOCK_LATE_COUNT"
 585 #endif
 586     /* Find the median of the last late values
 587      * It works pretty well at rejecting bad values
 588      *
 589      * XXX we only increase pts_delay over time, decreasing it is
 590      * not that easy if we want to be robust.
 591      */
 592     const mtime_t *p = cl->late.pi_value;
 593     mtime_t i_late_median = p[0] + p[1] + p[2] - __MIN(__MIN(p[0],p[1]),p[2]) - __MAX(__MAX(p[0],p[1]),p[2]);
 594     mtime_t i_pts_delay = cl->i_pts_delay ;
 595
 596     vlc_mutex_unlock( &cl->lock );
 597
 598     return i_pts_delay + i_late_median;
 599 }
 600
 601 /*****************************************************************************
 602  * ClockStreamToSystem: converts a movie clock to system date
 603  *****************************************************************************/
 604 static mtime_t ClockStreamToSystem( input_clock_t *cl, mtime_t i_stream )
 605 {
 606     if( !cl->b_has_reference )
 607         return VLC_TS_INVALID;
 608
 609     return ( i_stream - cl->ref.i_stream ) * cl->i_rate / INPUT_RATE_DEFAULT +
 610            cl->ref.i_system;
 611 }
 612
 613 /*****************************************************************************
 614  * ClockSystemToStream: converts a system date to movie clock
 615  *****************************************************************************
 616  * Caution : a valid reference point is needed for this to operate.
 617  *****************************************************************************/
 618 static mtime_t ClockSystemToStream( input_clock_t *cl, mtime_t i_system )
 619 {
 620     assert( cl->b_has_reference );
 621     return ( i_system - cl->ref.i_system ) * INPUT_RATE_DEFAULT / cl->i_rate +
 622             cl->ref.i_stream;
 623 }
 624
 625 /**
 626  * It returns timestamp display offset due to ref/last modfied on rate changes
 627  * It ensures that currently converted dates are not changed.
 628  */
 629 static mtime_t ClockGetTsOffset( input_clock_t *cl )
 630 {
 631     return cl->i_pts_delay * ( cl->i_rate - INPUT_RATE_DEFAULT ) / INPUT_RATE_DEFAULT;
 632 }
 633
 634 /*****************************************************************************
 635  * Long term average helpers
 636  *****************************************************************************/
 637 static void AvgInit( average_t *p_avg, int i_divider )
 638 {
 639     p_avg->i_divider = i_divider;
 640     AvgReset( p_avg );
 641 }
 642 static void AvgClean( average_t *p_avg )
 643 {
 644     VLC_UNUSED(p_avg);
 645 }
 646 static void AvgReset( average_t *p_avg )
 647 {
 648     p_avg->i_value = 0;
 649     p_avg->i_residue = 0;
 650     p_avg->i_count = 0;
 651 }
 652 static void AvgUpdate( average_t *p_avg, mtime_t i_value )
 653 {
 654     const int i_f0 = __MIN( p_avg->i_divider - 1, p_avg->i_count );
 655     const int i_f1 = p_avg->i_divider - i_f0;
 656
 657     const mtime_t i_tmp = i_f0 * p_avg->i_value + i_f1 * i_value + p_avg->i_residue;
 658
 659     p_avg->i_value   = i_tmp / p_avg->i_divider;
 660     p_avg->i_residue = i_tmp % p_avg->i_divider;
 661
 662     p_avg->i_count++;
 663 }
 664 static mtime_t AvgGet( average_t *p_avg )
 665 {
 666     return p_avg->i_value;
 667 }
 668 static void AvgRescale( average_t *p_avg, int i_divider )
 669 {
 670     const mtime_t i_tmp = p_avg->i_value * p_avg->i_divider + p_avg->i_residue;
 671
 672     p_avg->i_divider = i_divider;
 673     p_avg->i_value   = i_tmp / p_avg->i_divider;
 674     p_avg->i_residue = i_tmp % p_avg->i_divider;
 675 }