Return to descref.c CVS log

Up to [DVB] / multiplexer

Annotation of multiplexer/descref.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:  Descref
                      9:  * Purpose: Put descriptor data into map stream buffers.
                     10:  */
                     11: 
                     12: #include "global.h"
                     13: #include "error.h"
                     14: 
                     15: static mapreference mapref;
                     16: static int din;
                     17: 
                     18: void alloc_descriptor (stream_descr *s,
                     19:     int sourceid,
                     20:     int programnumber,
                     21:     byte version)
                     22: {
                     23:   if (s != NULL) {
                     24:     warn (LINF,"Alloc Descriptor",EDES,1,version,sourceid);
                     25:     mapref.sourceid = sourceid;
                     26:     mapref.programnumber = programnumber;
                     27:     mapref.version = version;
                     28:     memset (&mapref.elemdnew,0,sizeof(mapref.elemdnew));
                     29:     din = s->data.in;
                     30:     while (list_free (s->data) < 2*(sizeof(mapreference) + MAX_PSI_SIZE) + 1) {
                     31:       list_incr (s->ctrl.out,s->ctrl,1);
                     32:       s->data.out = s->ctrl.ptr[s->ctrl.out].index;
                     33:     }
                     34:     if (list_freeinend (s->data) < sizeof(mapreference) + MAX_PSI_SIZE) {
                     35:       din = 0;
                     36:     }
                     37:     s->ctrl.ptr[s->ctrl.in].index = din;
                     38:     s->ctrl.ptr[s->ctrl.in].length = sizeof(mapreference);
                     39:     din += sizeof(mapreference);
                     40:   }
                     41: }
                     42: 
                     43: int put_descriptor (file_descr *f,
                     44:   stream_descr *s,
                     45:   int index,
                     46:   int *infolen)
                     47: {
                     48:   byte t, l;
                     49:   if ((t = f->data.ptr[index]) >= NUMBER_ELEMD) {
                     50:     warn (LWAR,"Bad Descriptor Tag",EDES,2,1,t);
                     51:     *infolen = -1;
                     52:     return (index);
                     53:   }
                     54:   warn (LINF,"Put Descriptor",EDES,2,0,t);
                     55:   list_incr (index,f->data,1);
                     56:   l = f->data.ptr[index];
                     57:   if ((*infolen -= (l + 2)) >= 0) {
                     58:     if (s != NULL) {
                     59:       mapref.elemdnew[t] = &s->data.ptr[din];
                     60:       s->ctrl.ptr[s->ctrl.in].length += (l + 2);
                     61:       s->data.ptr[din++] = t;
                     62:       s->data.ptr[din++] = l;
                     63:       while (l > 0) {
                     64:         list_incr (index,f->data,1);
                     65:         s->data.ptr[din++] = f->data.ptr[index];
                     66:         l -= 1;
                     67:       }
                     68:       list_incr (index,f->data,1);
                     69:     } else {
                     70:       list_incr (index,f->data,l+1);
                     71:     }
                     72:   }
                     73:   return (index);
                     74: }
                     75: 
                     76: byte *put_descriptor_s (byte *d,
                     77:   stream_descr *s,
                     78:   int *infolen)
                     79: {
                     80:   byte t, l;
                     81:   if ((t = *d++) >= NUMBER_ELEMD) {
                     82:     warn (LWAR,"Bad Descriptor Tag",EDES,3,1,t);
                     83:     *infolen = -1;
                     84:     return (d);
                     85:   }
                     86:   warn (LINF,"Put Descriptor",EDES,3,0,t);
                     87:   l = *d++;
                     88:   if ((*infolen -= (l + 2)) >= 0) {
                     89:     if (s != NULL) {
                     90:       mapref.elemdnew[t] = &s->data.ptr[din];
                     91:       s->ctrl.ptr[s->ctrl.in].length += (l + 2);
                     92:       s->data.ptr[din++] = t;
                     93:       s->data.ptr[din++] = l;
                     94:       while (l > 0) {
                     95:         s->data.ptr[din++] = *d++;
                     96:         l -= 1;
                     97:       }
                     98:     } else {
                     99:       d += l;
                    100:     }
                    101:   }
                    102:   return (d);
                    103: }
                    104: 
                    105: void finish_descriptor (stream_descr *s)
                    106: {
                    107:   if (s != NULL) {
                    108:     warn (LINF,"Finish Descriptor",EDES,4,
                    109:         s->fdescr->sequence,s->ctrl.ptr[s->ctrl.in].length);
                    110:     memcpy (&s->data.ptr[s->ctrl.ptr[s->ctrl.in].index],&mapref,sizeof(mapref));
                    111:     s->data.in = din;
                    112:     warn (LDEB,"Sequence",EDES,4,1,s->fdescr->sequence);
                    113:     s->ctrl.ptr[s->ctrl.in].sequence = s->fdescr->sequence++;
                    114:     list_incr (s->ctrl.in,s->ctrl,1);
                    115:     if (s->ctrl.out == s->ctrl.in) {
                    116:       list_incr (s->ctrl.out,s->ctrl,1);
                    117:       s->data.out = s->ctrl.ptr[s->ctrl.out].index;
                    118:     }
                    119:   }
                    120: }
                    121: 
                    122: static void save_mapreference (mapreference *map,
                    123:     byte *dscr,
                    124:     int size,
                    125:     stream_descr *s)
                    126: {
                    127:   int i;
                    128:   warn (LINF,"Save Mapref",EDES,5,0,size);
                    129:   s->version = map->version;
                    130:   /* ... = map->programnumber */
                    131:   memcpy (&s->elemdescr[0],dscr,size);
                    132:   i = NUMBER_ELEMD;
                    133:   while (--i >= 0) {
                    134:     if (map->elemdnew[i] == NULL) {
                    135:       s->elemdvld[i] = NULL;
                    136:     } else {
                    137:       s->elemdvld[i] = map->elemdnew[i] + ((&s->elemdescr[0]) - dscr);
                    138:     }
                    139:   }
                    140: }
                    141: 
                    142: void validate_mapref (stream_descr *m)
                    143: {
                    144:   stream_descr *s;
                    145:   int l;
                    146:   mapreference *pmapref;
                    147:   pmapref = (mapreference *)&m->data.ptr[m->data.out];
                    148:   if (m->sourceid == pmapref->sourceid) {
                    149:     s = m;
                    150:   } else {
                    151:     switch (m->fdescr->content) {
                    152:       case ct_program:
                    153:         s = m->fdescr->u.ps.stream[pmapref->sourceid];
                    154:         break;
                    155:       case ct_transport:
                    156:         s = m->fdescr->u.ts.stream[pmapref->sourceid];
                    157:         break;
                    158:       default:
                    159:         warn (LERR,"Mapref NULL",EDES,6,1,m->fdescr->content);
                    160:         s = NULL;
                    161:         break;
                    162:     }
                    163:   }
                    164:   if (s != NULL) {
                    165:     if (s->version != pmapref->version) {
                    166:       save_mapreference (pmapref,
                    167:           &m->data.ptr[m->data.out+sizeof(mapreference)],
                    168:           m->ctrl.ptr[m->ctrl.out].length-sizeof(mapreference),s);
                    169:       if (s->isamap) {
                    170:         warn (LDEB,"Mapref isamap",EDES,6,3,pmapref->sourceid);
                    171:         /* must do something, if input program is related to output prog */
                    172:       } else {
                    173:         s->u.d.mention = TRUE;
                    174:         l = s->u.d.progs;
                    175:         while (--l >= 0) {
                    176:           s->u.d.pdescr[l]->changed = TRUE;
                    177:         }
                    178:       }
                    179:     }
                    180:   } else {
                    181:     warn (LDEB,"Mapref NULL",EDES,6,2,pmapref->sourceid);
                    182:   }
                    183:   list_incr (m->ctrl.out,m->ctrl,1);
                    184:   m->data.out = m->ctrl.ptr[m->ctrl.out].index;
                    185: }
                    186: