Return to global.c CVS log

Up to [DVB] / multiplexer

Annotation of multiplexer/global.c, revision 1.5

1.1       oskar       1: /*
                      2:  * ISO 13818 stream multiplexer
                      3:  * Copyright (C) 2001 Convergence Integrated Media GmbH Berlin
                      4:  * Author: Oskar Schirmer (oskar@convergence.de)
                      5:  */
                      6: 
                      7: /*
                      8:  * Module:  Global
                      9:  * Purpose: Service functions.
                     10:  */
                     11: 
                     12: #include "global.h"
                     13: #include "error.h"
                     14: 
                     15: boolean timed_io;
                     16: boolean accept_weird_scr;
1.3       oskar      17: t_msec global_delta;
1.1       oskar      18: 
                     19: #ifdef DEBUG_TIMEPOLL
                     20: timepoll logtp [max_timepoll];
                     21: long logtpc;
                     22: timepoll *ltp;
                     23: #endif
                     24: 
1.4       oskar      25: /* Provide the present system time in relative milliseconds.
                     26:  * The zero point may be moved as unconditional waiting is proposed
                     27:  * in the dispatcher, but timed_io=FALSE.
                     28:  * Return: milliseconds
                     29:  */
1.3       oskar      30: t_msec msec_now (void)
1.1       oskar      31: {
1.3       oskar      32: #define MSEC_EXPONENT 21
1.1       oskar      33:   static long last;
                     34:   static int local_delta;
                     35:   struct timeval tv;
                     36:   register int now;
                     37:   gettimeofday (&tv,NULL);
                     38: #ifdef DEBUG_TIMEPOLL
                     39:   ltp->tv.tv_sec = tv.tv_sec;
                     40:   ltp->tv.tv_usec = tv.tv_usec;
                     41: #endif
1.3       oskar      42:   if ((tv.tv_sec & (~((1L << MSEC_EXPONENT) - 1))) != last) {
                     43:     last = tv.tv_sec & (~((1L << MSEC_EXPONENT) - 1));
                     44:     local_delta += 1000 * (1L << MSEC_EXPONENT);
1.1       oskar      45:   }
1.3       oskar      46:   now = (tv.tv_sec & ((1L << MSEC_EXPONENT) - 1)) * 1000
                     47:       + tv.tv_usec / 1000 + local_delta;
1.1       oskar      48:   warn (LDEB,"msec_now",EGLO,3,0,now);
                     49: #ifdef DEBUG_TIMEPOLL
                     50:   ltp->cnt_msecnow += 1;
                     51:   ltp->msec_now = now + global_delta;
                     52: #endif
                     53:   return (now + global_delta);
1.2       oskar      54: }
                     55: 
1.5     ! oskar      56: /* Convert a clock reference value (90kHz) to milliseconds,
1.4       oskar      57:  * using a conversion base to avoid wrap around errors.
                     58:  */
1.2       oskar      59: void cref2msec (conversion_base *b,
                     60:     clockref c,
1.3       oskar      61:     t_msec *m)
1.2       oskar      62: {
                     63: #define CREF2MSEC_LIMIT (90 * 1024 * 16) /* 16 sec */
                     64:   unsigned long d;
                     65:   d = c.base - b->base;
                     66:   if (d >= (2 * CREF2MSEC_LIMIT)) {
                     67:     if (d >= (3 * CREF2MSEC_LIMIT)) {
1.3       oskar      68:       warn (LDEB,"cref2msec",EGLO,4,1,d);
1.2       oskar      69:       b->base = c.base - CREF2MSEC_LIMIT;
                     70:       b->msec = b->base / 90;
                     71:     } else {
1.3       oskar      72:       warn (LDEB,"cref2msec",EGLO,4,2,d);
1.2       oskar      73:       b->base += CREF2MSEC_LIMIT;
                     74:       b->msec += CREF2MSEC_LIMIT / 90;
                     75:     }
                     76:     d = c.base - b->base;
                     77:   }
                     78:   *m = (d / 90) + b->msec;
                     79: }
                     80:  
1.4       oskar      81: /* Convert milliseconds to a clock reference value (90kHz),
                     82:  * using a conversion base to avoid wrap around errors.
                     83:  */
1.2       oskar      84: void msec2cref (conversion_base *b,
1.3       oskar      85:     t_msec m,
1.2       oskar      86:     clockref *c)
                     87: {
                     88: #define MSEC2CREF_LIMIT (1024 * 10) /* 10 sec */
                     89:   unsigned int d;
                     90:   d = m - b->msec;
                     91:   if (d >= (2 * MSEC2CREF_LIMIT)) {
                     92:     if (d >= (3 * MSEC2CREF_LIMIT)) {
1.3       oskar      93:       warn (LDEB,"msec2cref",EGLO,5,1,d);
1.2       oskar      94:       b->msec = m - MSEC2CREF_LIMIT;
                     95:       b->base = b->msec * 45;
                     96:     } else {
1.3       oskar      97:       warn (LDEB,"msec2cref",EGLO,5,2,d);
1.2       oskar      98:       b->msec += MSEC2CREF_LIMIT;
                     99:       b->base += MSEC2CREF_LIMIT * 45;
                    100:     }
                    101:     d = m - b->msec;
                    102:   }
                    103:   d = (d * 45) + b->base;
                    104:   c->base = d * 2;
                    105:   c->ba33 = (d >> 31) & 0x01;
                    106:   c->ext = 0;
                    107:   c->valid = TRUE;
1.1       oskar     108: }
                    109: 
                    110: void global_init (void)
                    111: {
                    112: #ifdef DEBUG_TIMEPOLL
                    113:   {
                    114:     struct timeval tv;
                    115:     memset (&logtp[0],0,sizeof(logtp));
                    116:     gettimeofday (&tv,NULL);
                    117:     logtp[0].usec = tv.tv_usec;
                    118:     logtpc = 0;
                    119:     ltp = &logtp[0];
                    120:   }
                    121: #endif
                    122:   verbose_level = LWAR;
                    123:   global_delta = 0;
                    124:   global_delta = - msec_now ();
                    125:   timed_io = FALSE;
                    126:   accept_weird_scr = FALSE;
                    127: }
                    128: