Annotation of multiplexer/dispatch.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:  Dispatch
                      9:  * Purpose: Main dispatching loop.
                     10:  *
                     11:  * The first two buffer stages (raw file data and input stream data)
                     12:  * are filled gready, the following two stages (from input stream to
                     13:  * output data buffer, and further to stdout) are timing controlled.
                     14:  */
                     15: 
                     16: #include "global.h"
                     17: #include "error.h"
                     18: #include "splice.h"
                     19: #include "input.h"
                     20: #include "output.h"
                     21: #include "command.h"
                     22: #include "dispatch.h"
                     23: 
                     24: boolean fatal_error;
                     25: boolean force_quit;
                     26: boolean busy_work;
                     27: 
                     28: boolean dispatch_init (void)
                     29: {
                     30:   fatal_error = FALSE;
                     31:   force_quit = FALSE;
                     32:   busy_work = FALSE;
                     33:   return (TRUE);
                     34: }
                     35: 
                     36: void dispatch (void)
                     37: {
                     38:   boolean bi, bo, bs;
                     39:   stream_descr *st;
1.2     ! oskar      40:   t_msec tmo;
1.1       oskar      41:   unsigned int nfds, onfds, infds;
                     42:   struct pollfd ufds [MAX_POLLFD];
                     43:   warn (LDEB,"Dispatch",EDIS,0,0,0);
                     44:   bs = FALSE;
                     45:   st = input_available ();
                     46:   nfds = 0;
                     47:   command_expected (&nfds, &ufds[0]);
                     48:   onfds = nfds;
                     49:   bo = output_available (&nfds, &ufds[onfds], &tmo);
                     50:   while ((bo
                     51:        || bs
                     52:        || (st != NULL)
                     53:        || input_expected ()
                     54:        || ((tmo >= 0) && (tmo <= MAX_MSEC_OUTDELAY))
                     55:        || busy_work)
                     56:       && (!fatal_error)
                     57:       && (!force_quit)) {
                     58:     infds = nfds;
                     59:     bi = input_acceptable (&nfds, &ufds[infds], &tmo, output_acceptable ());
                     60:     if (bs) {
                     61:       tmo = 0;
                     62:     }
                     63:     warn (LDEB,"Poll",EDIS,0,1,tmo);
                     64: #ifdef DEBUG_TIMEPOLL
                     65:     ltp->tmo = tmo;
                     66: #endif
                     67:     if (!timed_io) {
                     68:       if (tmo > 0) {
                     69:         global_delta += tmo;
                     70:         tmo = 0;
                     71:         warn (LDEB,"Global Delta",EDIS,0,3,global_delta);
                     72: #ifdef DEBUG_TIMEPOLL
                     73:         ltp->flags |= LTP_FLAG_DELTASHIFT;
                     74: #endif
                     75:       }
                     76:     }
                     77: #ifdef DEBUG_TIMEPOLL
                     78:     if (ltp->usec != 0) {
                     79:       struct timeval tv;
                     80:       gettimeofday (&tv,NULL);
                     81:       ltp->usec -= tv.tv_usec;
                     82:     }
                     83:     ltp->nfdso = infds - onfds;
                     84:     ltp->nfdsi = nfds - infds;
                     85:     ltp->flags |=
                     86:       (bo ? LTP_FLAG_OUTPUT : 0) |
                     87:       (bi ? LTP_FLAG_INPUT : 0) |
                     88:       (bs ? LTP_FLAG_SPLIT : 0) |
                     89:       (st != NULL ? LTP_FLAG_PROCESS : 0);
                     90:     ltp->sr = deb_inraw_free (0);
                     91:     ltp->si = deb_instr_free (1);
                     92:     ltp->so = output_free ();
                     93:     ltp->nfdsrevent =
                     94: #endif
                     95:     poll (&ufds[0], nfds, tmo);
                     96: #ifdef DEBUG_TIMEPOLL
                     97:     if (logtpc < (max_timepoll-1)) {
                     98:       struct timeval tv;
                     99:       logtpc += 1;
                    100:       ltp++;
                    101:       gettimeofday (&tv,NULL);
                    102:       ltp->usec = tv.tv_usec;
                    103:     }
                    104: #endif
                    105:     warn (LDEB,"Poll done",EDIS,0,2,nfds);
                    106:     if ((0 < onfds)
                    107:      && (ufds[0].revents & (POLLIN | POLLHUP | POLLERR))) {
                    108:       command_process (ufds[0].revents & POLLIN);
                    109:     }
                    110:     if (bo
                    111:      && (ufds[onfds].revents & (POLLOUT | POLLHUP | POLLERR))) {
                    112:       output_something (ufds[onfds].revents & POLLOUT);
                    113:     }
                    114:     if (bi) {
                    115:       while (infds < nfds) {
                    116:         if (ufds[infds].revents & (POLLIN | POLLHUP | POLLERR)) {
                    117:           input_something (input_filehandle (ufds[infds].fd),
                    118:               ufds[infds].revents & POLLIN);
                    119:           bi = FALSE;
                    120:           bs = TRUE;
                    121:         }
                    122:         infds += 1;
                    123:       }
                    124:       if (!bi) {
                    125:         if (st == NULL) {
                    126:           st = input_available ();
                    127:         }
                    128:       }
                    129:     }
                    130:     if (bs) {
                    131:       bs = split_something ();
                    132:     }
                    133:     if ((st != NULL) && output_acceptable ()) {
                    134:       st = process_something (st);
                    135:       bs = TRUE;
                    136:     }
                    137:     if (st == NULL) {
                    138:       st = input_available ();
                    139:     }
                    140:     nfds = 0;
                    141:     command_expected (&nfds, &ufds[0]);
                    142:     onfds = nfds;
                    143:     bo = output_available (&nfds, &ufds[onfds], &tmo);
                    144:   }
                    145:   process_finish ();
1.2     ! oskar     146:   output_finish ();
1.1       oskar     147:   while ((output_available (&nfds, &ufds[0], &tmo)
                    148:        || (tmo >= 0))
                    149:       && (!fatal_error)) {
                    150:     output_something (TRUE);
                    151:   }
                    152: #ifdef DEBUG_TIMEPOLL
                    153:   {
                    154:     int i, u, s;
                    155:     i = 0;
                    156:     s = 0;
                    157:     fprintf (stderr,"lines: %8d\n",(int)logtpc);
                    158:     while (i < logtpc) {
                    159:       u = (logtp[i].usec > 0 ? 1000000 : 0) - logtp[i].usec;
                    160:       s += u;
                    161:       fprintf (stderr,
                    162:         "%08d %10d.%06d:%8d (%6d) %c%5d %d %d/%d %c%c%c%c %d (F:%6d,S:%6d,O:%6d)\n",
                    163:         i,
                    164:         (int)logtp[i].tv.tv_sec,
                    165:         (int)logtp[i].tv.tv_usec,
                    166:         logtp[i].msec_now,
                    167:         u,
                    168:         logtp[i].flags & LTP_FLAG_DELTASHIFT ? 'D' : ' ',
                    169:         logtp[i].tmo,
                    170:         logtp[i].cnt_msecnow,
                    171:         logtp[i].nfdsi,
                    172:         logtp[i].nfdso,
                    173:         logtp[i].flags & LTP_FLAG_INPUT ? 'I' : ' ',
                    174:         logtp[i].flags & LTP_FLAG_SPLIT ? 'S' : ' ',
                    175:         logtp[i].flags & LTP_FLAG_PROCESS ? 'P' : ' ',
                    176:         logtp[i].flags & LTP_FLAG_OUTPUT ? 'O' : ' ',
                    177:         logtp[i].nfdsrevent,
                    178:         logtp[i].sr,
                    179:         logtp[i].si,
                    180:         logtp[i].so
                    181:         );
                    182:       i += 1;
                    183:     }
                    184:     fprintf (stderr,"%43d\n",s);
                    185:   }
                    186: #endif
                    187: }
                    188: 

LinuxTV legacy CVS <linuxtv.org/cvs>