Return to global.c CVS log

Up to [DVB] / multiplexer

Annotation of multiplexer/global.c, revision 1.2

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;
                     17: int global_delta;
                     18: 
                     19: #ifdef DEBUG_TIMEPOLL
                     20: timepoll logtp [max_timepoll];
                     21: long logtpc;
                     22: timepoll *ltp;
                     23: #endif
                     24: 
                     25: int msec_now (void)
                     26: {
                     27:   static long last;
                     28:   static int local_delta;
                     29:   struct timeval tv;
                     30:   register int now;
                     31:   gettimeofday (&tv,NULL);
                     32: #ifdef DEBUG_TIMEPOLL
                     33:   ltp->tv.tv_sec = tv.tv_sec;
                     34:   ltp->tv.tv_usec = tv.tv_usec;
                     35: #endif
                     36:   if ((tv.tv_sec & (~0x001FFFFFL)) != last) {
                     37:     last = tv.tv_sec & (~0x001FFFFFL);
                     38:     local_delta += 1000 * 0x00200000L;
                     39:   }
                     40:   now = (tv.tv_sec & 0x001FFFFFL) * 1000 + tv.tv_usec / 1000 + local_delta;
                     41:   warn (LDEB,"msec_now",EGLO,3,0,now);
                     42: #ifdef DEBUG_TIMEPOLL
                     43:   ltp->cnt_msecnow += 1;
                     44:   ltp->msec_now = now + global_delta;
                     45: #endif
                     46:   return (now + global_delta);
1.2     ! oskar      47: }
        !            48: 
        !            49: void cref2msec (conversion_base *b,
        !            50:     clockref c,
        !            51:     int *m)
        !            52: {
        !            53: #define CREF2MSEC_LIMIT (90 * 1024 * 16) /* 16 sec */
        !            54:   unsigned long d;
        !            55:   d = c.base - b->base;
        !            56:   if (d >= (2 * CREF2MSEC_LIMIT)) {
        !            57:     if (d >= (3 * CREF2MSEC_LIMIT)) {
        !            58:       b->base = c.base - CREF2MSEC_LIMIT;
        !            59:       b->msec = b->base / 90;
        !            60:     } else {
        !            61:       b->base += CREF2MSEC_LIMIT;
        !            62:       b->msec += CREF2MSEC_LIMIT / 90;
        !            63:     }
        !            64:     d = c.base - b->base;
        !            65:   }
        !            66:   *m = (d / 90) + b->msec;
        !            67: }
        !            68:  
        !            69: void msec2cref (conversion_base *b,
        !            70:     int m,
        !            71:     clockref *c)
        !            72: {
        !            73: #define MSEC2CREF_LIMIT (1024 * 10) /* 10 sec */
        !            74:   unsigned int d;
        !            75:   d = m - b->msec;
        !            76:   if (d >= (2 * MSEC2CREF_LIMIT)) {
        !            77:     if (d >= (3 * MSEC2CREF_LIMIT)) {
        !            78:       b->msec = m - MSEC2CREF_LIMIT;
        !            79:       b->base = b->msec * 45;
        !            80:     } else {
        !            81:       b->msec += MSEC2CREF_LIMIT;
        !            82:       b->base += MSEC2CREF_LIMIT * 45;
        !            83:     }
        !            84:     d = m - b->msec;
        !            85:   }
        !            86:   d = (d * 45) + b->base;
        !            87:   c->base = d * 2;
        !            88:   c->ba33 = (d >> 31) & 0x01;
        !            89:   c->ext = 0;
        !            90:   c->valid = TRUE;
1.1       oskar      91: }
                     92: 
                     93: void global_init (void)
                     94: {
                     95: #ifdef DEBUG_TIMEPOLL
                     96:   {
                     97:     struct timeval tv;
                     98:     memset (&logtp[0],0,sizeof(logtp));
                     99:     gettimeofday (&tv,NULL);
                    100:     logtp[0].usec = tv.tv_usec;
                    101:     logtpc = 0;
                    102:     ltp = &logtp[0];
                    103:   }
                    104: #endif
                    105:   verbose_level = LWAR;
                    106:   global_delta = 0;
                    107:   global_delta = - msec_now ();
                    108:   timed_io = FALSE;
                    109:   accept_weird_scr = FALSE;
                    110: }
                    111: