Annotation of multiplexer/en300468ts.c, revision 1.23
1.1 oskar 1: /*
2: * SI table generator (EN 300468)
1.3 oskar 3: * Copyright (C) 2004,2005 Oskar Schirmer (schirmer@scara.com)
1.1 oskar 4: *
5: * This program is free software; you can redistribute it and/or modify
6: * it under the terms of the GNU General Public License as published by
7: * the Free Software Foundation; either version 2 of the License, or
8: * (at your option) any later version.
9: *
10: * This program is distributed in the hope that it will be useful,
11: * but WITHOUT ANY WARRANTY; without even the implied warranty of
12: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: * GNU General Public License for more details.
14: *
15: * You should have received a copy of the GNU General Public License
16: * along with this program; if not, write to the Free Software
17: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18: */
19:
20: /*
21: * Module: SI table generator
1.5 oskar 22: * Purpose: From a list of descriptive files generate SI tables and feed
1.1 oskar 23: * them to stdout.
24: * known bug: missing check for section length <= 1021
25: */
26:
27: //#define DEBUG
28:
29: #include <limits.h>
30: #include <unistd.h>
31: #include <stdio.h>
32: #include <stdlib.h>
1.6 oskar 33: #include <stdint.h>
1.1 oskar 34: #include <sys/stat.h>
35: #include <fcntl.h>
36: #include <signal.h>
37: #include <sys/poll.h>
38: #include <errno.h>
39: #include <string.h>
40: #include <ctype.h>
41: #include <sys/time.h>
42:
43: #include "crc32.h"
44:
45: #ifdef PATH_MAX
46: #define MY_PATH_MAX PATH_MAX
47: #else
48: #define MY_PATH_MAX 4096
49: #endif
50:
51: static struct pollfd *pfd = NULL;
52: static int npfd = 0;
53: static int ipfd;
54:
55: #define TABLE_PID_FIRST 0x10
56: #define TABLE_PID_LAST 0x1F
57: #define TABBUF_SIZE (1<<15)
58: #define MAX_PSI_SIZE (4096+1)
59:
1.21 oskar 60: static struct {
61: unsigned char *tabbuf;
62: unsigned int tabin;
63: unsigned int tabout;
64: unsigned char tabinold;
65: unsigned char conticnt;
66: } perpid[TABLE_PID_LAST-TABLE_PID_FIRST+1];
1.1 oskar 67:
68: #define TABLEID_FIRST 0x40
69: #define TABLEID_LAST 0x7F
70:
71: static unsigned char nextversion[TABLEID_LAST-TABLEID_FIRST+1];
72:
73: #define TS_PACKET_SIZE 188
74: #define TS_HEADSLEN 3
75: #define TS_PACKET_HEADSIZE 4
1.4 oskar 76: #define TS_PFIELDLEN 1
1.1 oskar 77: #define TS_SYNC_BYTE 0x47
78: #define OUTBUF_PACKETS 256
79: #define OUTBUF_SIZE (TS_PACKET_SIZE*OUTBUF_PACKETS)
80:
81: static unsigned int outin = 0;
82: static unsigned int outout = 0;
83: static unsigned char outbuf[OUTBUF_SIZE];
84:
85: static void pollfd_init()
86: {
87: ipfd = 0;
88: }
89:
90: static int pollfd_add(int f, short e)
91: {
92: if (npfd <= ipfd) {
93: npfd = 2*npfd+1;
94: pfd = realloc(pfd, npfd * sizeof(struct pollfd));
95: }
96: pfd[ipfd].fd = f;
97: pfd[ipfd].events = e;
98: return ipfd++;
99: }
100:
101: static int pollfd_poll(int timeout)
102: {
103: return poll(pfd, ipfd, timeout);
104: }
105:
106: static int pollfd_rev(int i)
107: {
108: return pfd[i].revents;
109: }
110:
111: static void signalhandler(int sig)
112: {
113: exit(0);
114: }
115:
116: static void system_init()
117: {
118: signal(SIGINT, (void *) (*signalhandler));
119: signal(SIGPIPE, SIG_IGN);
120: }
121:
122: static void unblockf(int f)
123: {
124: int r;
125: r = fcntl(f, F_GETFL);
126: if (r >= 0) {
127: r = fcntl(f, F_SETFL, r | O_NONBLOCK);
128: }
129: if (r < 0) {
130: fprintf(stderr, "fcntl failed(%d): %d\n", errno, f);
131: }
132: }
133:
134: enum enumsi {
1.5 oskar 135: #define ENDEF_BEGIN(name,pid,tableid) name ,
136: #define ENDEF_END
137: #define ENDEF_NUMBER0(name)
138: #define ENDEF_NUMBER1(name)
139: #define ENDEF_DESCR
140: #define ENDEF_DATETIME
141: #define ENDEF_LOOP
142: #define ENDEF_LOOPEND0
143: #include "en300468ts.table"
144: #undef ENDEF_BEGIN
145: #undef ENDEF_END
146: #undef ENDEF_NUMBER0
147: #undef ENDEF_NUMBER1
148: #undef ENDEF_DESCR
149: #undef ENDEF_DATETIME
150: #undef ENDEF_LOOP
151: #undef ENDEF_LOOPEND0
1.1 oskar 152: num_si,
153: si_none = -1
154: };
155:
156: #define DESCR_FIRST 0x40
157: #define DESCR_LAST 0x6E
158: #define PMT_POSS 0
159:
160: static unsigned char descrcnt[DESCR_LAST-DESCR_FIRST+1];
161:
162: const static unsigned char possible_descr[DESCR_LAST-DESCR_FIRST+1] = {
163: (1<<nit),
164: (1<<nit) | (1<<bat),
165: 0 /* (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit) */,
166: (1<<nit),
167: (1<<nit),
168: PMT_POSS,
169: PMT_POSS,
170: (1<<bat) | (1<<sdt) | (1<<sit),
171: (1<<sdt) | (1<<sit),
172: (1<<bat) | (1<<sdt) | (1<<sit),
173: (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit),
174: (1<<sdt) | (1<<sit),
175: (1<<sdt) | (1<<sit),
176: (1<<eit) | (1<<sit),
177: (1<<eit) | (1<<sit),
178: (1<<eit) | (1<<sit),
179: (1<<eit) | (1<<sit),
180: (1<<sdt) | PMT_POSS | (1<<sit),
181: PMT_POSS,
182: (1<<bat) | (1<<sdt) | (1<<eit) | (1<<sit),
183: (1<<eit) | (1<<sit),
184: (1<<eit) | (1<<sit),
185: PMT_POSS,
186: (1<<sdt) | (1<<eit) | (1<<sit),
187: (1<<tot),
188: PMT_POSS,
189: (1<<nit),
190: (1<<nit),
191: (1<<bat),
192: (1<<sdt) | (1<<sit),
193: (1<<eit) | (1<<sit),
194: (1<<nit) | (1<<bat) | (1<<sdt) | (1<<eit) | PMT_POSS | (1<<sit),
195: PMT_POSS,
196: (1<<eit) | (1<<sit),
197: (1<<nit),
198: (1<<sit),
199: (1<<sdt) | (1<<eit) | (1<<sit),
200: PMT_POSS,
201: PMT_POSS,
202: 0,
203: 0,
204: (1<<eit),
205: PMT_POSS,
206: PMT_POSS,
207: (1<<nit),
208: (1<<nit),
209: (1<<nit)
210: };
211:
212: #define LOOP_DEPTH 4
213: #define REALLOC_CHUNK 32
214:
1.17 oskar 215: static struct {
216: int tablen;
217: int itab;
218: int fd;
219: int isdescr; /* 0: main table, >0: descr loop depth */
220: int descrtag;
221: int isyn;
222: int isyntab;
223: int numcount;
224: int loopbegin[LOOP_DEPTH];
225: int loopcount[LOOP_DEPTH];
226: int ibuf;
227: char buf[2048];
228: } tabnew;
229:
1.1 oskar 230: struct sitab {
231: struct sitab *next;
232: unsigned char version;
233: unsigned char tableid;
1.23 ! oskar 234: unsigned short tableid_ext;
1.1 oskar 235: long pid;
236: long freqmsec;
237: enum enumsi esi;
238: unsigned long *tab;
1.16 oskar 239: struct timeval soon;
1.1 oskar 240: unsigned char descrnum[DESCR_LAST-DESCR_FIRST+1];
241: };
242:
243: static struct sitab *newtab = NULL;
244: static struct sitab *runtab = NULL;
245:
246: #define SYNTAX_END 0
247: #define SYNTAX_LOOPEND 1
248: #define SYNTAX_LOOP 2
249: #define SYNTAX_DESCR 3
250: #define SYNTAX_DESCRTAG 4
251: #define SYNTAX_DATETIME 5
252: #define SYNTAX_STRING 6
1.5 oskar 253: #define SYNTAX_NUMBER -1
1.1 oskar 254:
1.5 oskar 255: #define ENDEF_BEGIN(name,tag) \
256: const static signed char syntax_##name [] = {SYNTAX_DESCRTAG,
257: #define ENDEF_END SYNTAX_END};
258: #define ENDEF_NUMBER0(name) SYNTAX_NUMBER
259: #define ENDEF_NUMBER1(name) SYNTAX_NUMBER,
260: #define ENDEF_DATETIME SYNTAX_DATETIME,
261: #define ENDEF_LOOP SYNTAX_LOOP,
262: #define ENDEF_LOOPEND0
263: #define ENDEF_LOOPEND1 SYNTAX_LOOPEND,
264: #define ENDEF_STRING(name) SYNTAX_STRING,
265: #define ENDEF_STRING3(name) SYNTAX_STRING,
266: #include "en300468ts.descr"
267: #undef ENDEF_BEGIN
268: #undef ENDEF_END
269: #undef ENDEF_NUMBER0
270: #undef ENDEF_NUMBER1
271: #undef ENDEF_DATETIME
272: #undef ENDEF_LOOP
273: #undef ENDEF_LOOPEND0
274: #undef ENDEF_LOOPEND1
275: #undef ENDEF_STRING
276: #undef ENDEF_STRING3
1.1 oskar 277:
278: static unsigned char *gen_network_name(struct sitab *st, unsigned char *p,
279: unsigned long **tt)
280: {
281: unsigned char *d = p;
282: unsigned long *t = *tt;
283: int i;
284: i = *t++;
285: memcpy(d, t, i);
286: d += i;
287: t += (i + sizeof(long) - 1) / sizeof(long);
288: *tt = t;
289: return d;
290: }
291:
292: static unsigned char *gen_service_list(struct sitab *st, unsigned char *p,
293: unsigned long **tt)
294: {
295: unsigned char *d = p;
296: unsigned long *t = *tt;
297: int i;
298: i = *t++;
299: while (i > 0) {
300: *d++ = *t >> 8;
301: *d++ = *t++;
302: *d++ = *t++;
303: i -= 1;
304: }
305: *tt = t;
306: return d;
307: }
308:
309: static unsigned char *gen_satellite_delivery_system(struct sitab *st,
310: unsigned char *p, unsigned long **tt)
311: {
312: unsigned char *d = p;
313: unsigned long *t = *tt;
314: unsigned char c;
315: *d++ = *t >> 24;
316: *d++ = *t >> 16;
317: *d++ = *t >> 8;
318: *d++ = *t++;
319: *d++ = *t >> 8;
320: *d++ = *t++;
321: c = *t++ << 7;
322: c |= (*t++ & 0x03) << 5;
323: *d++ = c | (*t++ & 0x1F);
324: *d++ = *t >> 20;
325: *d++ = *t >> 12;
326: *d++ = *t >> 4;
327: c = *t++ << 4;
328: *d++ = c | (*t++ & 0x0F);
329: *tt = t;
330: return d;
331: }
332:
333: static unsigned char *gen_cable_delivery_system(struct sitab *st,
334: unsigned char *p, unsigned long **tt)
335: {
336: unsigned char *d = p;
337: unsigned long *t = *tt;
338: unsigned char c;
339: *d++ = *t >> 24;
340: *d++ = *t >> 16;
341: *d++ = *t >> 8;
342: *d++ = *t++;
343: *d++ = 0xFF;
344: *d++ = 0xF0 | *t++;
345: *d++ = *t++;
346: *d++ = *t >> 20;
347: *d++ = *t >> 12;
348: *d++ = *t >> 4;
349: c = *t++ << 4;
350: *d++ = c | (*t++ & 0x0F);
351: *tt = t;
352: return d;
353: }
354:
355: static unsigned char *gen_bouquet_name(struct sitab *st, unsigned char *p,
356: unsigned long **tt)
357: {
358: unsigned char *d = p;
359: unsigned long *t = *tt;
360: int i;
361: i = *t++;
362: memcpy(d, t, i);
363: d += i;
364: t += (i + sizeof(long) - 1) / sizeof(long);
365: *tt = t;
366: return d;
367: }
368:
369: static unsigned char *gen_service(struct sitab *st, unsigned char *p,
370: unsigned long **tt)
371: {
372: unsigned char *d = p;
373: unsigned long *t = *tt;
374: int i;
375: *d++ = *t++;
376: *d++ = i = *t++;
377: memcpy(d, t, i);
378: d += i;
379: t += (i + sizeof(long) - 1) / sizeof(long);
380: *d++ = i = *t++;
381: memcpy(d, t, i);
382: d += i;
383: t += (i + sizeof(long) - 1) / sizeof(long);
384: *tt = t;
385: return d;
386: }
387:
388: static unsigned char *gen_country_availability(struct sitab *st,
389: unsigned char *p, unsigned long **tt)
390: {
391: unsigned char *d = p;
392: unsigned long *t = *tt;
393: int i, j;
394: *d++ = (*t++ << 7) | 0x7F;
395: i = *t++;
396: while (i > 0) {
397: j = *t++;
398: memcpy(d, t, 3);
399: d += 3;
400: t += (j + sizeof(long) - 1) / sizeof(long);
401: i -= 1;
402: }
403: *tt = t;
404: return d;
405: }
406:
407: static unsigned char *gen_linkage(struct sitab *st, unsigned char *p,
408: unsigned long **tt)
409: {
410: unsigned char *d = p;
411: unsigned long *t = *tt;
412: int i;
413: unsigned char l, h, o;
414: unsigned long n, s;
415: *d++ = *t >> 8;
416: *d++ = *t++;
417: *d++ = *t >> 8;
418: *d++ = *t++;
419: *d++ = *t >> 8;
420: *d++ = *t++;
421: *d++ = l = *t++;
422: h = *t++ & 0x0F;
423: o = *t++ & 0x01;
424: n = *t++;
425: s = *t++;
426: if (l == 8) {
427: *d++ = (h << 4) | 0x0E | o;
428: if ((h >= 1) && (h <= 3)) {
429: *d++ = n >> 8;
430: *d++ = n;
431: }
432: if (o == 0) {
433: *d++ = s >> 8;
434: *d++ = s;
435: }
436: }
437: i = *t++;
438: while (i > 0) {
439: *d++ = *t++;
440: i -= 1;
441: }
442: *tt = t;
443: return d;
444: }
445:
446: static unsigned char *gen_nvod_reference(struct sitab *st, unsigned char *p,
447: unsigned long **tt)
448: {
449: unsigned char *d = p;
450: unsigned long *t = *tt;
451: int i;
452: i = *t++;
453: while (i > 0) {
454: *d++ = *t >> 8;
455: *d++ = *t++;
456: *d++ = *t >> 8;
457: *d++ = *t++;
458: *d++ = *t >> 8;
459: *d++ = *t++;
460: i -= 1;
461: }
462: *tt = t;
463: return d;
464: }
465:
466: static unsigned char *gen_time_shifted_service(struct sitab *st,
467: unsigned char *p, unsigned long **tt)
468: {
469: unsigned char *d = p;
470: unsigned long *t = *tt;
471: *d++ = *t >> 8;
472: *d++ = *t++;
473: *tt = t;
474: return d;
475: }
476:
477: static unsigned char *gen_short_event(struct sitab *st, unsigned char *p,
478: unsigned long **tt)
479: {
480: unsigned char *d = p;
481: unsigned long *t = *tt;
482: int i;
483: i = *t++;
484: memcpy(d, t, 3);
485: d += 3;
486: t += (i + sizeof(long) - 1) / sizeof(long);
487: *d++ = i = *t++;
488: memcpy(d, t, i);
489: d += i;
490: t += (i + sizeof(long) - 1) / sizeof(long);
491: *d++ = i = *t++;
492: memcpy(d, t, i);
493: d += i;
494: t += (i + sizeof(long) - 1) / sizeof(long);
495: *tt = t;
496: return d;
497: }
498:
499: static unsigned char *gen_extended_event(struct sitab *st, unsigned char *p,
500: unsigned long **tt)
501: {
502: unsigned char *d = p;
503: unsigned long *t = *tt;
504: int i, j;
505: *d++ = (descrcnt[0x4E - DESCR_FIRST] << 4)
506: | (st->descrnum[0x4E - DESCR_FIRST] & 0x0F);
507: i = *t++;
508: memcpy(d, t, 3);
509: d += 4;
510: t += (i + sizeof(long) - 1) / sizeof(long);
511: i = *t++;
512: while (i > 0) {
513: *d++ = j = *t++;
514: memcpy(d, t, j);
515: d += j;
516: t += (j + sizeof(long) - 1) / sizeof(long);
517: *d++ = j = *t++;
518: memcpy(d, t, j);
519: d += j;
520: t += (j + sizeof(long) - 1) / sizeof(long);
521: i -= 1;
522: }
523: p[4] = d-p-5;
524: *d++ = i = *t++;
525: memcpy(d, t, i);
526: d += i;
527: t += (i + sizeof(long) - 1) / sizeof(long);
528: *tt = t;
529: return d;
530: }
531:
532: static unsigned char *gen_time_shifted_event(struct sitab *st, unsigned char *p,
533: unsigned long **tt)
534: {
535: unsigned char *d = p;
536: unsigned long *t = *tt;
537: *d++ = *t >> 8;
538: *d++ = *t++;
539: *d++ = *t >> 8;
540: *d++ = *t++;
541: *tt = t;
542: return d;
543: }
544:
545: static unsigned char *gen_component(struct sitab *st, unsigned char *p,
546: unsigned long **tt)
547: {
548: unsigned char *d = p;
549: unsigned long *t = *tt;
550: int i;
551: *d++ = 0xF0 | *t++;
552: *d++ = *t++;
553: *d++ = *t++;
554: i = *t++;
555: memcpy(d, t, 3);
556: d += 3;
557: t += (i + sizeof(long) - 1) / sizeof(long);
558: i = *t++;
559: memcpy(d, t, i);
560: d += i;
561: t += (i + sizeof(long) - 1) / sizeof(long);
562: *tt = t;
563: return d;
564: }
565:
566: static unsigned char *gen_mosaic(struct sitab *st, unsigned char *p,
567: unsigned long **tt)
568: {
569: unsigned char *d = p;
570: unsigned long *t = *tt;
571: unsigned char *e;
572: unsigned char c;
573: int i, j;
574: c = *t++ << 7;
575: c = c | ((*t++ & 0x07) << 4);
576: *d++ = c | 0x08 | (*t++ & 0x07);
577: i = *t++;
578: while (i > 0) {
579: *d++ = (*t++ << 2) | 0x03;
580: *d++ = 0xF8 | *t++;
581: e = d++;
582: j = *t++;
583: while (j > 0) {
584: *d++ = 0xC0 | *t++;
585: j -= 1;
586: }
587: *e = d-e-1;
588: switch (*d++ = *t++) {
589: case 0x01:
590: *d++ = t[0] >> 8;
591: *d++ = t[0];
592: break;
593: case 0x02:
594: case 0x03:
595: *d++ = t[1] >> 8;
596: *d++ = t[1];
597: *d++ = t[2] >> 8;
598: *d++ = t[2];
599: *d++ = t[3] >> 8;
600: *d++ = t[3];
601: break;
602: case 0x04:
603: *d++ = t[1] >> 8;
604: *d++ = t[1];
605: *d++ = t[2] >> 8;
606: *d++ = t[2];
607: *d++ = t[3] >> 8;
608: *d++ = t[3];
609: *d++ = t[4] >> 8;
610: *d++ = t[4];
611: break;
612: }
613: t += 5;
614: i -= 1;
615: }
616: *tt = t;
617: return d;
618: }
619:
620: static unsigned char *gen_ca_identifier(struct sitab *st, unsigned char *p,
621: unsigned long **tt)
622: {
623: unsigned char *d = p;
624: unsigned long *t = *tt;
625: int i;
626: i = *t++;
627: while (i > 0) {
628: *d++ = *t >> 8;
629: *d++ = *t++;
630: i -= 1;
631: }
632: *tt = t;
633: return d;
634: }
635:
636: static unsigned char *gen_content(struct sitab *st, unsigned char *p,
637: unsigned long **tt)
638: {
639: unsigned char *d = p;
640: unsigned long *t = *tt;
641: int i;
642: i = *t++;
643: while (i > 0) {
644: *d++ = *t++;
645: *d++ = *t++;
646: i -= 1;
647: }
648: *tt = t;
649: return d;
650: }
651:
652: static unsigned char *gen_parental_rating(struct sitab *st, unsigned char *p,
653: unsigned long **tt)
654: {
655: unsigned char *d = p;
656: unsigned long *t = *tt;
657: int i, j;
658: i = *t++;
659: while (i > 0) {
660: j = *t++;
661: memcpy(d, t, 3);
662: d += 3;
663: t += (j + sizeof(long) - 1) / sizeof(long);
664: *d++ = *t++;
665: i -= 1;
666: }
667: *tt = t;
668: return d;
669: }
670:
671: static unsigned char *gen_telephone(struct sitab *st, unsigned char *p,
672: unsigned long **tt)
673: {
674: unsigned char *d = p;
675: unsigned long *t = *tt;
676: unsigned char c;
677: int i;
678: c = *t++ << 5;
679: *d = 0xC0 | c | (*t++ & 0x1F);
680: d += 3;
681: i = *t++;
682: c = i << 5;
683: memcpy(d, t, i);
684: d += i;
685: t += (i + sizeof(long) - 1) / sizeof(long);
686: i = *t++;
687: c |= (i & 0x07) << 2;
688: memcpy(d, t, i);
689: d += i;
690: t += (i + sizeof(long) - 1) / sizeof(long);
691: i = *t++;
692: p[1] = 0x80 | c | (i & 0x03);
693: memcpy(d, t, i);
694: d += i;
695: t += (i + sizeof(long) - 1) / sizeof(long);
696: i = *t++;
697: c = i << 4;
698: memcpy(d, t, i);
699: d += i;
700: t += (i + sizeof(long) - 1) / sizeof(long);
701: i = *t++;
702: p[2] = 0x80 | c | (i & 0x0F);
703: memcpy(d, t, i);
704: d += i;
705: t += (i + sizeof(long) - 1) / sizeof(long);
706: *tt = t;
707: return d;
708: }
709:
710: static unsigned char *gen_local_time_offset(struct sitab *st, unsigned char *p,
711: unsigned long **tt)
712: {
713: unsigned char *d = p;
714: unsigned long *t = *tt;
715: unsigned char c;
716: int i, j;
717: i = *t++;
718: while (i > 0) {
719: j = *t++;
720: memcpy(d, t, 3);
721: d += 3;
722: t += (j + sizeof(long) - 1) / sizeof(long);
723: c = *t++ << 2;
724: *d++ = c | 0x02 | (*t++ & 0x01);
725: *d++ = *t >> 8;
726: *d++ = *t++;
727: *d++ = *t >> 8;
728: *d++ = *t++;
729: *d++ = *t >> 16;
730: *d++ = *t >> 8;
731: *d++ = *t++;
732: *d++ = *t >> 8;
733: *d++ = *t++;
734: i -= 1;
735: }
736: *tt = t;
737: return d;
738: }
739:
740: static unsigned char *gen_terrestrial_delivery_system(struct sitab *st,
741: unsigned char *p, unsigned long **tt)
742: {
743: unsigned char *d = p;
744: unsigned long *t = *tt;
745: unsigned char c;
746: *d++ = *t >> 24;
747: *d++ = *t >> 16;
748: *d++ = *t >> 8;
749: *d++ = *t++;
750: *d++ = (*t++ << 5) | 0x1F;
751: c = *t++ << 6;
752: c |= (*t++ & 0x07) << 3;
753: *d++ = c | (*t++ & 0x07);
754: c = *t++ << 5;
755: c |= (*t++ & 0x03) << 3;
756: c |= (*t++ & 0x03) << 1;
757: *d++ = c | (*t++ & 0x01);
758: *d++ = 0xFF;
759: *d++ = 0xFF;
760: *d++ = 0xFF;
761: *d++ = 0xFF;
762: *tt = t;
763: return d;
764: }
765:
766: static unsigned char *gen_multilingual_network_name(struct sitab *st,
767: unsigned char *p, unsigned long **tt)
768: {
769: unsigned char *d = p;
770: unsigned long *t = *tt;
771: int i, j;
772: i = *t++;
773: while (i > 0) {
774: j = *t++;
775: memcpy(d, t, 3);
776: d += 3;
777: t += (j + sizeof(long) - 1) / sizeof(long);
778: *d++ = j = *t++;
779: memcpy(d, t, j);
780: d += j;
781: t += (j + sizeof(long) - 1) / sizeof(long);
782: i -= 1;
783: }
784: *tt = t;
785: return d;
786: }
787:
788: static unsigned char *gen_multilingual_bouquet_name(struct sitab *st,
789: unsigned char *p, unsigned long **tt)
790: {
791: unsigned char *d = p;
792: unsigned long *t = *tt;
793: int i, j;
794: i = *t++;
795: while (i > 0) {
796: j = *t++;
797: memcpy(d, t, 3);
798: d += 3;
799: t += (j + sizeof(long) - 1) / sizeof(long);
800: *d++ = j = *t++;
801: memcpy(d, t, j);
802: d += j;
803: t += (j + sizeof(long) - 1) / sizeof(long);
804: i -= 1;
805: }
806: *tt = t;
807: return d;
808: }
809:
810: static unsigned char *gen_multilingual_service_name(struct sitab *st,
811: unsigned char *p, unsigned long **tt)
812: {
813: unsigned char *d = p;
814: unsigned long *t = *tt;
815: int i, j;
816: i = *t++;
817: while (i > 0) {
818: j = *t++;
819: memcpy(d, t, 3);
820: d += 3;
821: t += (j + sizeof(long) - 1) / sizeof(long);
822: *d++ = j = *t++;
823: memcpy(d, t, j);
824: d += j;
825: t += (j + sizeof(long) - 1) / sizeof(long);
826: *d++ = j = *t++;
827: memcpy(d, t, j);
828: d += j;
829: t += (j + sizeof(long) - 1) / sizeof(long);
830: i -= 1;
831: }
832: *tt = t;
833: return d;
834: }
835:
836: static unsigned char *gen_multilingual_component(struct sitab *st,
837: unsigned char *p, unsigned long **tt)
838: {
839: unsigned char *d = p;
840: unsigned long *t = *tt;
841: int i, j;
842: *d++ = *t++;
843: i = *t++;
844: while (i > 0) {
845: j = *t++;
846: memcpy(d, t, 3);
847: d += 3;
848: t += (j + sizeof(long) - 1) / sizeof(long);
849: *d++ = j = *t++;
850: memcpy(d, t, j);
851: d += j;
852: t += (j + sizeof(long) - 1) / sizeof(long);
853: i -= 1;
854: }
855: *tt = t;
856: return d;
857: }
858:
859: static unsigned char *gen_private_data_specifier(struct sitab *st,
860: unsigned char *p, unsigned long **tt)
861: {
862: unsigned char *d = p;
863: unsigned long *t = *tt;
864: *d++ = *t >> 24;
865: *d++ = *t >> 16;
866: *d++ = *t >> 8;
867: *d++ = *t++;
868: *tt = t;
869: return d;
870: }
871:
872: static unsigned char *gen_short_smoothing_buffer(struct sitab *st,
873: unsigned char *p, unsigned long **tt)
874: {
875: unsigned char *d = p;
876: unsigned long *t = *tt;
877: unsigned char c;
878: c = *t++ << 6;
879: *d++ = c | (*t++ & 0x3F);
880: *tt = t;
881: return d;
882: }
883:
884: static unsigned char *gen_frequency_list(struct sitab *st, unsigned char *p,
885: unsigned long **tt)
886: {
887: unsigned char *d = p;
888: unsigned long *t = *tt;
889: int i;
890: *d++ = 0xFC | *t++;
891: i = *t++;
892: while (i > 0) {
893: *d++ = *t >> 24;
894: *d++ = *t >> 16;
895: *d++ = *t >> 8;
896: *d++ = *t++;
897: i -= 1;
898: }
899: *tt = t;
900: return d;
901: }
902:
903: static unsigned char *gen_partial_transport_stream(struct sitab *st,
904: unsigned char *p, unsigned long **tt)
905: {
906: unsigned char *d = p;
907: unsigned long *t = *tt;
908: *d++ = 0xC0 | (*t >> 16);
909: *d++ = *t >> 8;
910: *d++ = *t++;
911: *d++ = 0xC0 | (*t >> 16);
912: *d++ = *t >> 8;
913: *d++ = *t++;
914: *d++ = 0xC0 | (*t >> 8);
915: *d++ = *t++;
916: *tt = t;
917: return d;
918: }
919:
920: static unsigned char *gen_data_broadcast(struct sitab *st, unsigned char *p,
921: unsigned long **tt)
922: {
923: unsigned char *d = p;
924: unsigned long *t = *tt;
925: int i;
926: *d++ = *t >> 8;
927: *d++ = *t++;
928: *d++ = *t++;
929: *d++ = i = *t++;
930: while (i > 0) {
931: *d++ = *t++;
932: i -= 1;
933: }
934: i = *t++;
935: memcpy(d, t, 3);
936: d += 3;
937: t += (i + sizeof(long) - 1) / sizeof(long);
938: *d++ = i = *t++;
939: memcpy(d, t, i);
940: d += i;
941: t += (i + sizeof(long) - 1) / sizeof(long);
942: *tt = t;
943: return d;
944: }
945:
946: static unsigned char *gen_pdc(struct sitab *st, unsigned char *p,
947: unsigned long **tt)
948: {
949: unsigned char *d = p;
950: unsigned long *t = *tt;
951: *d++ = 0xF0 | (*t >> 16);
952: *d++ = *t >> 8;
953: *d++ = *t++;
954: *tt = t;
955: return d;
956: }
957:
958: static unsigned char *gen_cell_list(struct sitab *st, unsigned char *p,
959: unsigned long **tt)
960: {
961: unsigned char *d = p;
962: unsigned long *t = *tt;
963: unsigned char c;
964: int i, j;
965: i = *t++;
966: while (i > 0) {
967: *d++ = *t >> 8;
968: *d++ = *t++;
969: *d++ = *t >> 8;
970: *d++ = *t++;
971: *d++ = *t >> 8;
972: *d++ = *t++;
973: *d++ = *t >> 4;
974: c = *t++ << 4;
1.22 oskar 975: *d++ = c | ((*t >> 8) & 0x0F);
1.1 oskar 976: *d++ = *t++;
977: j = *t++;
978: *d++ = 8 * j;
979: while (j > 0) {
980: *d++ = *t++;
981: *d++ = *t >> 8;
982: *d++ = *t++;
983: *d++ = *t >> 8;
984: *d++ = *t++;
985: *d++ = *t >> 4;
986: c = *t++ << 4;
1.22 oskar 987: *d++ = c | ((*t >> 8) & 0x0F);
1.1 oskar 988: *d++ = *t++;
989: j -= 1;
990: }
991: i -= 1;
992: }
993: *tt = t;
994: return d;
995: }
996:
997: static unsigned char *gen_cell_frequency_link(struct sitab *st,
998: unsigned char *p, unsigned long **tt)
999: {
1000: unsigned char *d = p;
1001: unsigned long *t = *tt;
1002: int i, j;
1003: i = *t++;
1004: while (i > 0) {
1005: *d++ = *t >> 8;
1006: *d++ = *t++;
1007: *d++ = *t >> 24;
1008: *d++ = *t >> 16;
1009: *d++ = *t >> 8;
1010: *d++ = *t++;
1011: j = *t++;
1012: *d++ = 5 * j;
1013: while (j > 0) {
1014: *d++ = *t++;
1015: *d++ = *t >> 24;
1016: *d++ = *t >> 16;
1017: *d++ = *t >> 8;
1018: *d++ = *t++;
1019: j -= 1;
1020: }
1021: i -= 1;
1022: }
1023: *tt = t;
1024: return d;
1025: }
1026:
1027: static unsigned char *gen_announcement_support(struct sitab *st,
1028: unsigned char *p, unsigned long **tt)
1029: {
1030: unsigned char *d = p;
1031: unsigned long *t = *tt;
1032: unsigned char c, v;
1033: int i;
1034: *d++ = *t >> 8;
1035: *d++ = *t++;
1036: i = *t++;
1037: while (i > 0) {
1038: c = *t++ << 4;
1039: v = *t++ & 0x07;
1040: *d++ = c | 0x08 | v;
1041: switch (v) {
1042: case 0x01:
1043: case 0x02:
1044: case 0x03:
1045: *d++ = *t >> 8;
1046: *d++ = *t++;
1047: *d++ = *t >> 8;
1048: *d++ = *t++;
1049: *d++ = *t >> 8;
1050: *d++ = *t++;
1051: *d++ = *t++;
1052: break;
1053: }
1054: i -= 1;
1055: }
1056: *tt = t;
1057: return d;
1058: }
1059:
1060: const static signed char *const descr_syntax[DESCR_LAST-DESCR_FIRST+1] = {
1061: &syntax_network_name[0],
1062: &syntax_service_list[0],
1063: NULL,
1064: &syntax_satellite_delivery_system[0],
1065: &syntax_cable_delivery_system[0],
1066: NULL,
1067: NULL,
1068: &syntax_bouquet_name[0],
1069: &syntax_service[0],
1070: &syntax_country_availability[0],
1071: &syntax_linkage[0],
1072: &syntax_nvod_reference[0],
1073: &syntax_time_shifted_service[0],
1074: &syntax_short_event[0],
1075: &syntax_extended_event[0],
1076: &syntax_time_shifted_event[0],
1077: &syntax_component[0],
1078: &syntax_mosaic[0],
1079: NULL,
1080: &syntax_ca_identifier[0],
1081: &syntax_content[0],
1082: &syntax_parental_rating[0],
1083: NULL,
1084: &syntax_telephone[0],
1085: &syntax_local_time_offset[0],
1086: NULL,
1087: &syntax_terrestrial_delivery_system[0],
1088: &syntax_multilingual_network_name[0],
1089: &syntax_multilingual_bouquet_name[0],
1090: &syntax_multilingual_service_name[0],
1091: &syntax_multilingual_component[0],
1092: &syntax_private_data_specifier[0],
1093: NULL,
1094: &syntax_short_smoothing_buffer[0],
1095: &syntax_frequency_list[0],
1096: &syntax_partial_transport_stream[0],
1097: &syntax_data_broadcast[0],
1098: NULL,
1099: NULL,
1100: NULL,
1101: NULL,
1102: &syntax_pdc[0],
1103: NULL,
1104: NULL,
1105: &syntax_cell_list[0],
1106: &syntax_cell_frequency_link[0],
1107: &syntax_announcement_support[0]
1108: };
1109:
1110: static unsigned char *gendescr(struct sitab *st, unsigned char *p,
1111: unsigned long **tt, unsigned char msb)
1112: {
1113: unsigned char *d = p+2;
1114: unsigned long *t = *tt;
1115: unsigned char *b;
1116: unsigned char v;
1117: int i;
1118: i = *t++;
1119: while (i > 0) {
1120: b = d+2;
1121: switch (*d = v = *t++) {
1.5 oskar 1122: #define ENDEF_BEGIN(name,tag) case tag : d = gen_##name (st, b, &t); break;
1123: #define ENDEF_END
1124: #define ENDEF_NUMBER0(name)
1125: #define ENDEF_NUMBER1(name)
1126: #define ENDEF_DATETIME
1127: #define ENDEF_LOOP
1128: #define ENDEF_LOOPEND0
1129: #define ENDEF_LOOPEND1
1130: #define ENDEF_STRING(name)
1131: #define ENDEF_STRING3(name)
1132: #include "en300468ts.descr"
1133: #undef ENDEF_BEGIN
1134: #undef ENDEF_END
1135: #undef ENDEF_NUMBER0
1136: #undef ENDEF_NUMBER1
1137: #undef ENDEF_DATETIME
1138: #undef ENDEF_LOOP
1139: #undef ENDEF_LOOPEND0
1140: #undef ENDEF_LOOPEND1
1141: #undef ENDEF_STRING
1142: #undef ENDEF_STRING3
1.1 oskar 1143: default:
1144: fprintf(stderr, "error: descr not implemented (%02x)\n", *d);
1145: exit(1);
1146: }
1147: descrcnt[v-DESCR_FIRST] += 1;
1148: b[-1] = d-b;
1149: i -= 1;
1150: }
1151: i = d-p-2;
1152: p[0] = msb | (i >> 8);
1153: p[1] = i;
1154: *tt = t;
1155: return d;
1156: }
1157:
1.5 oskar 1158: #define ENDEF_BEGIN(name,pid,tableid) \
1159: const static signed char syntax_##name [] = {
1160: #define ENDEF_END SYNTAX_END};
1161: #define ENDEF_NUMBER0(name) SYNTAX_NUMBER
1162: #define ENDEF_NUMBER1(name) SYNTAX_NUMBER,
1163: #define ENDEF_DESCR SYNTAX_DESCR,
1164: #define ENDEF_DATETIME SYNTAX_DATETIME,
1165: #define ENDEF_LOOP SYNTAX_LOOP,
1166: #define ENDEF_LOOPEND0
1167: #include "en300468ts.table"
1168: #undef ENDEF_BEGIN
1169: #undef ENDEF_END
1170: #undef ENDEF_NUMBER0
1171: #undef ENDEF_NUMBER1
1172: #undef ENDEF_DESCR
1173: #undef ENDEF_DATETIME
1174: #undef ENDEF_LOOP
1175: #undef ENDEF_LOOPEND0
1.1 oskar 1176:
1177: static int gentab_nit(struct sitab *st, unsigned char *b)
1178: {
1179: unsigned char *p = b;
1180: unsigned long *t = st->tab;
1181: unsigned char *q;
1182: int i;
1183: *p = st->tableid;
1184: p += 3;
1185: *p++ = *t >> 8;
1186: *p++ = *t++;
1187: *p++ = 0xC0 | (st->version << 1) | 0x01;
1188: *p++ = 0;
1189: *p++ = 0;
1190: p = gendescr(st, p, &t, 0xF0);
1191: q = p;
1192: p += 2;
1193: i = *t++;
1194: while (i > 0) {
1195: *p++ = *t >> 8;
1196: *p++ = *t++;
1197: *p++ = *t >> 8;
1198: *p++ = *t++;
1199: p = gendescr(st, p, &t, 0xF0);
1200: i -= 1;
1201: }
1202: i = p-q-2;
1203: q[0] = 0xF0 | (i >> 8);
1204: q[1] = i;
1205: i = p-b+1;
1206: b[1] = 0xF0 | (i >> 8);
1207: b[2] = i;
1208: crc32_calc(b, i-1, p);
1209: return p-b+4;
1210: }
1211:
1212: static int gentab_sdt(struct sitab *st, unsigned char *b)
1213: {
1214: unsigned char *p = b;
1215: unsigned long *t = st->tab;
1216: int i;
1217: unsigned char c;
1218: *p = st->tableid;
1219: p += 3;
1220: *p++ = *t >> 8;
1221: *p++ = *t++;
1222: *p++ = 0xC0 | (st->version << 1) | 0x01;
1223: *p++ = 0;
1224: *p++ = 0;
1225: *p++ = *t >> 8;
1226: *p++ = *t++;
1227: *p++ = 0xFF;
1228: i = *t++;
1229: while (i > 0) {
1230: *p++ = *t >> 8;
1231: *p++ = *t++;
1232: c = *t++ << 1;
1233: *p++ = 0xFC | c | (*t++ & 1);
1234: c = *t++ << 5;
1235: p = gendescr(st, p, &t, c);
1236: i -= 1;
1237: }
1238: i = p-b+1;
1239: b[1] = 0xF0 | (i >> 8);
1240: b[2] = i;
1241: crc32_calc(b, i-1, p);
1242: return p-b+4;
1243: }
1244:
1245: static int gentab_bat(struct sitab *st, unsigned char *b)
1246: {
1247: unsigned char *p = b;
1248: unsigned long *t = st->tab;
1249: unsigned char *q;
1250: int i;
1251: *p = st->tableid;
1252: p += 3;
1253: *p++ = *t >> 8;
1254: *p++ = *t++;
1255: *p++ = 0xC0 | (st->version << 1) | 0x01;
1256: *p++ = 0;
1257: *p++ = 0;
1258: p = gendescr(st, p, &t, 0xF0);
1259: q = p;
1260: p += 2;
1261: i = *t++;
1262: while (i > 0) {
1263: *p++ = *t >> 8;
1264: *p++ = *t++;
1265: *p++ = *t >> 8;
1266: *p++ = *t++;
1267: p = gendescr(st, p, &t, 0xF0);
1268: i -= 1;
1269: }
1270: i = p-q-2;
1271: q[0] = 0xF0 | (i >> 8);
1272: q[1] = i;
1273: i = p-b+1;
1274: b[1] = 0xF0 | (i >> 8);
1275: b[2] = i;
1276: crc32_calc(b, i-1, p);
1277: return p-b+4;
1278: }
1279:
1280: static int gentab_eit(struct sitab *st, unsigned char *b)
1281: {
1282: unsigned char *p = b;
1283: unsigned long *t = st->tab;
1284: int i;
1.8 oskar 1285: unsigned char c;
1.1 oskar 1286: struct sitab *gt;
1287: *p = i = st->tableid;
1288: p += 3;
1289: *p++ = *t >> 8;
1290: *p++ = *t++;
1291: *p++ = 0xC0 | (st->version << 1) | 0x01;
1292: *p++ = 0;
1293: *p++ = 0;
1294: *p++ = *t >> 8;
1295: *p++ = *t++;
1296: *p++ = *t >> 8;
1297: *p++ = *t++;
1298: *p++ = 0;
1299: gt = runtab;
1300: while (gt != NULL) {
1301: if ((gt->esi == eit) && (gt->tableid > i)) {
1302: i = gt->tableid;
1303: }
1304: gt = gt->next;
1305: }
1306: *p++ = i;
1307: i = *t++;
1.8 oskar 1308: while (i > 0) {
1309: *p++ = *t >> 8;
1310: *p++ = *t++;
1311: *p++ = *t >> 8;
1312: *p++ = *t++;
1313: *p++ = *t >> 16;
1314: *p++ = *t >> 8;
1315: *p++ = *t++;
1316: *p++ = *t >> 16;
1317: *p++ = *t >> 8;
1318: *p++ = *t++;
1319: c = *t++ << 5;
1320: p = gendescr(st, p, &t, c);
1321: i -= 1;
1322: }
1.1 oskar 1323: i = p-b+1;
1324: b[1] = 0xF0 | (i >> 8);
1325: b[2] = i;
1326: crc32_calc(b, i-1, p);
1327: return p-b+4;
1328: }
1329:
1330: static int gentab_rst(struct sitab *st, unsigned char *b)
1331: {
1332: unsigned char *p = b;
1333: unsigned long *t = st->tab;
1334: int i;
1335: *p = st->tableid;
1336: p += 3;
1337: i = *t++;
1338: while (i > 0) {
1339: *p++ = *t >> 8;
1340: *p++ = *t++;
1341: *p++ = *t >> 8;
1342: *p++ = *t++;
1343: *p++ = *t >> 8;
1344: *p++ = *t++;
1345: *p++ = *t >> 8;
1346: *p++ = *t++;
1347: *p++ = 0xF8 | *t++;
1348: i -= 1;
1349: }
1350: i = p-b-3;
1351: b[1] = 0xF0 | (i >> 8);
1352: b[2] = i;
1353: return p-b;
1354: }
1355:
1356: static unsigned char *gentvdatetime(unsigned char *p, struct timeval *tv)
1357: {
1358: unsigned long d, s;
1359: s = tv->tv_sec;
1360: d = s / 86400;
1361: s = s % 86400;
1362: d += 40587;
1363: *p++ = d >> 8;
1364: *p++ = d;
1365: d = s / 3600;
1366: s = s % 3600;
1367: d += (d / 10) * 6;
1368: *p++ = d;
1369: d = s / 60;
1370: s = s % 60;
1371: d += (d / 10) * 6;
1372: *p++ = d;
1373: s += (s / 10) * 6;
1374: *p++ = s;
1375: return p;
1376: }
1377:
1378: static int gentab_tdt(struct sitab *st, unsigned char *b, struct timeval *tv)
1379: {
1380: unsigned char *p = b;
1381: *p++ = st->tableid;
1382: *p++ = 0xF0;
1383: *p++ = 0x05;
1384: p = gentvdatetime(p, tv);
1385: return p-b;
1386: }
1387:
1388: static int gentab_tot(struct sitab *st, unsigned char *b, struct timeval *tv)
1389: {
1390: unsigned char *p = b;
1391: unsigned long *t = st->tab;
1392: int i;
1393: *p = st->tableid;
1394: p += 3;
1395: p = gentvdatetime(p, tv);
1396: p = gendescr(st, p, &t, 0xF0);
1397: i = p-b+1;
1398: b[1] = 0xF0 | (i >> 8);
1399: b[2] = i;
1400: crc32_calc(b, i-1, p);
1401: return p-b+4;
1402: }
1403:
1404: static int gentab_sit(struct sitab *st, unsigned char *b)
1405: {
1406: unsigned char *p = b;
1407: unsigned long *t = st->tab;
1.3 oskar 1408: unsigned char c;
1409: int i;
1.1 oskar 1410: *p = st->tableid;
1.3 oskar 1411: p += 3;
1412: *p++ = 0xFF;
1413: *p++ = 0xFF;
1414: *p++ = 0xC0 | (st->version << 1) | 0x01;
1415: *p++ = 0;
1416: *p++ = 0;
1417: p = gendescr(st, p, &t, 0xF0);
1418: i = *t++;
1419: while (i > 0) {
1420: *p++ = *t >> 8;
1421: *p++ = *t++;
1422: c = *t++ << 4;
1423: p = gendescr(st, p, &t, 0x80 | c);
1424: i -= 1;
1425: }
1426: i = p-b+1;
1427: b[1] = 0xF0 | (i >> 8);
1428: b[2] = i;
1429: crc32_calc(b, i-1, p);
1430: return p-b+4;
1.1 oskar 1431: }
1432:
1433: static int gentab_dit(struct sitab *st, unsigned char *b)
1434: {
1435: unsigned char *p = b;
1436: unsigned long *t = st->tab;
1.3 oskar 1437: *p++ = st->tableid;
1438: *p++ = 0xF0;
1439: *p++ = 0x01;
1440: *p++ = (*t++ << 7) | 0x7F;
1.1 oskar 1441: return p-b;
1442: }
1443:
1444: const static signed char *const tab_syntax[num_si] = {
1.5 oskar 1445: #define ENDEF_BEGIN(name,pid,tableid) &syntax_##name [0],
1446: #define ENDEF_END
1447: #define ENDEF_NUMBER0(name)
1448: #define ENDEF_NUMBER1(name)
1449: #define ENDEF_DESCR
1450: #define ENDEF_DATETIME
1451: #define ENDEF_LOOP
1452: #define ENDEF_LOOPEND0
1453: #include "en300468ts.table"
1454: #undef ENDEF_BEGIN
1455: #undef ENDEF_END
1456: #undef ENDEF_NUMBER0
1457: #undef ENDEF_NUMBER1
1458: #undef ENDEF_DESCR
1459: #undef ENDEF_DATETIME
1460: #undef ENDEF_LOOP
1461: #undef ENDEF_LOOPEND0
1.1 oskar 1462: };
1463:
1464: const static signed char *const *const syntax[2] = {
1465: &tab_syntax[0],
1466: &descr_syntax[0]
1467: };
1468:
1469: static void gentab(struct sitab *st, struct timeval *tv)
1470: {
1.10 oskar 1471: int i, l;
1.1 oskar 1472: unsigned char *b;
1473: memset(&descrcnt[0], 0, sizeof(descrcnt));
1.10 oskar 1474: i = st->pid - TABLE_PID_FIRST;
1.21 oskar 1475: b = &perpid[i].tabbuf[perpid[i].tabin];
1.1 oskar 1476: *b++ = st->pid >> 8;
1477: *b++ = st->pid;
1478: switch (st->esi) {
1479: case nit: l = gentab_nit(st, b); break;
1480: case sdt: l = gentab_sdt(st, b); break;
1481: case bat: l = gentab_bat(st, b); break;
1482: case eit: l = gentab_eit(st, b); break;
1483: case rst: l = gentab_rst(st, b); break;
1484: case tdt: l = gentab_tdt(st, b, tv); break;
1485: case tot: l = gentab_tot(st, b, tv); break;
1486: case sit: l = gentab_sit(st, b); break;
1487: case dit: l = gentab_dit(st, b); break;
1488: default:
1489: fprintf(stderr, "internal error (gentab, %d)\n", st->esi);
1490: exit(1);
1491: }
1.21 oskar 1492: perpid[i].tabin += l+2;
1.1 oskar 1493: }
1494:
1.23 ! oskar 1495: static enum enumsi alloctab(long pid, long tid, int *hastableidext)
1.1 oskar 1496: {
1497: enum enumsi e = si_none;
1498: switch (pid) {
1499: case 0x0010:
1.23 ! oskar 1500: if (tid == 0x40) {
1.1 oskar 1501: e = nit;
1.23 ! oskar 1502: } else if (tid == 0x41) {
! 1503: e = nit;
! 1504: *hastableidext = 1;
1.1 oskar 1505: } else {
1506: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1507: }
1508: break;
1509: case 0x0011:
1.23 ! oskar 1510: if (tid == 0x42) {
! 1511: e = sdt;
! 1512: } else if (tid == 0x46) {
1.1 oskar 1513: e = sdt;
1.23 ! oskar 1514: *hastableidext = 1;
1.1 oskar 1515: } else if (tid == 0x4A) {
1516: e = bat;
1.23 ! oskar 1517: *hastableidext = 1;
1.1 oskar 1518: } else {
1519: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1520: }
1521: break;
1522: case 0x0012:
1523: if ((tid >= 0x4E) && (tid <= 0x6F)) {
1524: e = eit;
1.23 ! oskar 1525: *hastableidext = 1;
1.1 oskar 1526: } else {
1527: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1528: }
1529: break;
1530: case 0x0013:
1531: if (tid == 0x71) {
1532: e = rst;
1533: } else {
1534: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1535: }
1536: break;
1537: case 0x0014:
1538: if (tid == 0x70) {
1539: e = tdt;
1540: } else if (tid == 0x73) {
1541: e = tot;
1542: } else {
1543: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1544: }
1545: break;
1546: case 0x001E:
1547: if (tid == 0x7E) {
1548: e = dit;
1549: } else {
1550: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1551: }
1552: break;
1553: case 0x001F:
1554: if (tid == 0x7F) {
1555: e = sit;
1556: } else {
1557: fprintf(stderr, "bad tableid: 0x%02lx (pid: 0x%04lx)\n", tid, pid);
1558: }
1559: break;
1560: default:
1561: fprintf(stderr, "bad pid: 0x%04lx\n", pid);
1562: break;
1563: }
1564: return e;
1565: }
1566:
1567: static void droptab(long pid, long tableid)
1568: {
1569: struct sitab **pst;
1570: struct sitab *st;
1571: pst = &runtab;
1.20 oskar 1572: while ((st = *pst)) {
1573: if ((st->pid == pid) && (st->tableid == tableid)) {
1574: *pst = st->next;
1575: nextversion[st->tableid - TABLEID_FIRST] = (st->version + 1) & 0x1F;
1576: free(st->tab);
1577: free(st);
1578: } else {
1579: pst = &st->next;
1580: }
1.1 oskar 1581: }
1582: }
1583:
1.19 oskar 1584: static void maketab(long pid, long tableid, long freqmsec, int fd)
1.1 oskar 1585: {
1586: struct sitab *t;
1587: enum enumsi e;
1.23 ! oskar 1588: int hastableidext = 0;
! 1589: e = alloctab(pid, tableid, &hastableidext);
1.1 oskar 1590: if (e >= 0) {
1.20 oskar 1591: t = malloc(sizeof(struct sitab));
1592: if (t != NULL) {
1.1 oskar 1593: t->pid = pid;
1594: t->tableid = tableid;
1.23 ! oskar 1595: t->tableid_ext = hastableidext;
1.20 oskar 1596: t->freqmsec = freqmsec;
1597: t->esi = e;
1598: t->tab = NULL;
1599: memset(&t->descrnum[0], 0, sizeof(t->descrnum));
1600: memset(&tabnew, 0, sizeof(tabnew));
1601: tabnew.fd = fd;
1602: newtab = t;
1603: }
1.1 oskar 1604: }
1605: }
1606:
1607: static int tabline(char *b, int n)
1608: {
1609: char *e, *a, *z;
1610: int i;
1611: long v[3];
1612: char c;
1613: if ((n <= 0) || ((e = memchr(b, '\n', n)) == NULL)) {
1614: return 0;
1615: }
1616: *e = 0;
1.13 oskar 1617: if (b < e) {
1.1 oskar 1618: z = b+1;
1619: i = 0;
1620: c = toupper(*b);
1621: switch (c) {
1622: case '-':
1623: do {
1624: a = z;
1625: v[i] = strtol(a, &z, 0);
1626: } while ((a != z) && (++i < 2));
1627: if (a == z) {
1628: fprintf(stderr, "invalid line(%d): %s\n", a-b, b);
1629: } else {
1630: droptab(v[0], v[1]);
1631: }
1632: break;
1633: case 'S':
1634: do {
1635: a = z;
1636: v[i] = strtol(a, &z, 0);
1637: } while ((a != z) && (++i < 3));
1638: if (a == z) {
1639: fprintf(stderr, "invalid line(%d): %s\n", a-b, b);
1640: } else {
1641: while (isspace(*z)) {
1642: z += 1;
1643: }
1644: i = open(z, O_RDONLY | O_NONBLOCK);
1645: if (i < 0) {
1646: fprintf(stderr, "open failed(%d): %s\n", errno, z);
1647: } else {
1648: #ifdef DEBUG
1649: fprintf(stderr, "table: %c, %ld, %ld, %ld, <%s>\n",
1650: c, v[0], v[1], v[2], z);
1651: #endif
1.19 oskar 1652: maketab(v[0], v[1], v[2], i);
1.1 oskar 1653: }
1654: }
1655: break;
1656: }
1657: }
1658: return e-b+1;
1659: }
1660:
1661: static int taballoc(struct sitab *st, int cnt)
1662: {
1.17 oskar 1663: while (tabnew.tablen < (tabnew.itab + cnt)) {
1664: tabnew.tablen += REALLOC_CHUNK;
1665: st->tab = realloc(st->tab, tabnew.tablen * sizeof(unsigned long));
1.1 oskar 1666: if (st->tab == NULL) {
1667: return -ENOMEM;
1668: }
1669: }
1670: return 0;
1671: }
1672:
1673: static long longval(char **n, int d)
1674: {
1675: long v;
1676: int i;
1677: char c;
1678: v = 0;
1679: for (i = 0; i < d; i++) {
1680: c = *(*n)++;
1681: if (!isdigit(c)) {
1682: return -ENOMEM;
1683: }
1684: v = 10*v+c-'0';
1685: }
1686: return v;
1687: }
1688:
1689: static int siline(struct sitab *st, char *b, int n)
1690: {
1691: char *e, *a, *z;
1692: long v;
1693: int s, i;
1.17 oskar 1694: s = syntax[(tabnew.isdescr > 0) ? 1 : 0]
1695: [(tabnew.isdescr > 0) ? tabnew.descrtag : st->esi][tabnew.isyn];
1.1 oskar 1696: if ((s == SYNTAX_END) || (s == SYNTAX_LOOPEND)) {
1697: int lc;
1698: #ifdef DEBUG
1699: fprintf(stderr, "end:\n");
1700: #endif
1.17 oskar 1701: if ((lc = --tabnew.loopcount[0]) <= 0) {
1.1 oskar 1702: if (lc == 0) {
1703: for (i = 0; i < LOOP_DEPTH-1; i++) {
1.17 oskar 1704: tabnew.loopbegin[i] = tabnew.loopbegin[i+1];
1705: tabnew.loopcount[i] = tabnew.loopcount[i+1];
1.1 oskar 1706: }
1.17 oskar 1707: tabnew.loopcount[LOOP_DEPTH-1] = 0;
1.1 oskar 1708: if (s == SYNTAX_LOOPEND) {
1.17 oskar 1709: tabnew.isyn += 1;
1710: } else if (tabnew.isdescr > 0) {
1711: if (--tabnew.isdescr == 0) {
1712: tabnew.isyn = tabnew.isyntab;
1.1 oskar 1713: }
1714: }
1715: return 0;
1716: } else {
1.17 oskar 1717: tabnew.tablen = tabnew.itab;
1718: st->tab = realloc(st->tab, tabnew.itab * sizeof(unsigned long));
1.1 oskar 1719: return -ENOBUFS;
1720: }
1721: } else {
1.17 oskar 1722: tabnew.isyn = tabnew.loopbegin[0];
1.1 oskar 1723: return 0;
1724: }
1725: }
1726: if ((n <= 0) || ((e = memchr(b, '\n', n)) == NULL)) {
1727: return -EAGAIN;
1728: }
1729: *e = 0;
1730: a = b;
1731: while (isspace(*a)) {
1732: a += 1;
1733: }
1734: if (taballoc(st, 1)) {
1735: return -ENOMEM;
1736: }
1737: if (a != e) {
1738: switch (s) {
1739: default:
1740: if (s > 0) {
1741: fprintf(stderr, "internal syntax error\n");
1742: exit(1);
1743: }
1.17 oskar 1744: if (tabnew.numcount == 0) {
1745: tabnew.numcount = s;
1.1 oskar 1746: }
1747: v = strtoul(a, &z, 0);
1748: if (a == z) {
1749: return -EINVAL;
1750: }
1751: #ifdef DEBUG
1752: fprintf(stderr, "number: %ld, %d..%d\n", v, a-b, z-b);
1753: #endif
1.17 oskar 1754: st->tab[tabnew.itab++] = v;
1755: if (++tabnew.numcount == 0) {
1756: tabnew.isyn += 1;
1.1 oskar 1757: }
1758: *e = '\n';
1759: return z-b;
1760: case SYNTAX_LOOP:
1761: v = strtol(a, &z, 0);
1762: if (a == z) {
1763: return -EINVAL;
1764: }
1765: #ifdef DEBUG
1766: fprintf(stderr, "loop: %ld, %d..%d\n", v, a-b, z-b);
1767: #endif
1.17 oskar 1768: st->tab[tabnew.itab++] = v;
1.1 oskar 1769: if (v != 0) {
1.17 oskar 1770: if (tabnew.isdescr > 0) {
1771: tabnew.isdescr += 1;
1.1 oskar 1772: }
1.7 oskar 1773: for (i = LOOP_DEPTH-2; i >= 0; i--) {
1.17 oskar 1774: tabnew.loopbegin[i+1] = tabnew.loopbegin[i];
1775: tabnew.loopcount[i+1] = tabnew.loopcount[i];
1.1 oskar 1776: }
1.17 oskar 1777: tabnew.loopbegin[0] = ++tabnew.isyn;
1778: tabnew.loopcount[0] = v;
1.1 oskar 1779: } else {
1780: do {
1.17 oskar 1781: tabnew.isyn += 1;
1782: s = syntax[(tabnew.isdescr > 0) ? 1 : 0]
1783: [(tabnew.isdescr > 0) ? tabnew.descrtag : st->esi]
1784: [tabnew.isyn];
1.1 oskar 1785: if (s == SYNTAX_LOOP) {
1786: v += 1;
1787: }
1788: } while ((s != SYNTAX_END) && ((s != SYNTAX_LOOPEND) || (--v >= 0)));
1789: if (s == SYNTAX_LOOPEND) {
1.17 oskar 1790: tabnew.isyn += 1;
1.1 oskar 1791: }
1792: }
1793: *e = '\n';
1794: return z-b;
1795: case SYNTAX_DESCR:
1796: v = strtol(a, &z, 0);
1797: if (a == z) {
1798: return -EINVAL;
1799: }
1800: #ifdef DEBUG
1801: fprintf(stderr, "descr: %ld, %d..%d\n", v, a-b, z-b);
1802: #endif
1.17 oskar 1803: st->tab[tabnew.itab++] = v;
1804: tabnew.isyn += 1;
1.1 oskar 1805: if (v != 0) {
1.17 oskar 1806: tabnew.isdescr = 1;
1807: tabnew.descrtag = 0;
1.7 oskar 1808: for (i = LOOP_DEPTH-2; i >= 0; i--) {
1.17 oskar 1809: tabnew.loopbegin[i+1] = tabnew.loopbegin[i];
1810: tabnew.loopcount[i+1] = tabnew.loopcount[i];
1.1 oskar 1811: }
1.17 oskar 1812: tabnew.loopbegin[0] = 0;
1813: tabnew.loopcount[0] = v;
1814: tabnew.isyntab = tabnew.isyn;
1815: tabnew.isyn = 0;
1.1 oskar 1816: }
1817: *e = '\n';
1818: return z-b;
1819: case SYNTAX_DESCRTAG:
1820: v = strtol(a, &z, 0);
1821: if (a == z) {
1822: return -EINVAL;
1823: }
1824: #ifdef DEBUG
1825: fprintf(stderr, "descrtag: %ld, %d..%d\n", v, a-b, z-b);
1826: #endif
1.17 oskar 1827: st->tab[tabnew.itab++] = v;
1.1 oskar 1828: v -= DESCR_FIRST;
1829: if ((v < 0) || (v > (DESCR_LAST - DESCR_FIRST))) {
1830: return -EINVAL;
1831: }
1832: st->descrnum[v] += 1;
1833: if (!((1 << st->esi) & possible_descr[v])) {
1834: return -EINVAL;
1835: }
1.17 oskar 1836: tabnew.descrtag = v;
1837: tabnew.isyn += 1;
1.1 oskar 1838: *e = '\n';
1839: return z-b;
1840: case SYNTAX_DATETIME:
1841: /* yyyy/mm/dd hh:mm:ss */
1842: z = a;
1843: i = e-z;
1844: if (i < 19) {
1845: return -EINVAL;
1846: }
1847: if (taballoc(st, 2)) {
1848: return -ENOMEM;
1849: }
1850: if ((v = longval(&z, 4)) < 0) {
1851: return v;
1852: }
1853: if ((v < 1582) || (*z++ != '/')) {
1854: return -EINVAL;
1855: }
1856: if ((s = longval(&z, 2)) < 0) {
1857: return s;
1858: }
1859: s -= 1;
1860: if ((s < 0) || (s > 11) || (*z++ != '/')) {
1861: return -EINVAL;
1862: }
1863: s -= 2;
1864: if (s < 0) {
1865: s += 12;
1866: v -= 1;
1867: }
1868: v = (1461*v)/4 - ((v/100+1)*3)/4 + (153*s)/5;
1869: if ((s = longval(&z, 2)) < 0) {
1870: return s;
1871: }
1872: if ((s <= 0) || (s > 31)) {
1873: return -EINVAL;
1874: }
1875: v += s - 678912;
1.17 oskar 1876: st->tab[tabnew.itab++] = v;
1.1 oskar 1877: v = 0;
1878: s = ' ';
1879: for (i = 2; i >= 0; i--) {
1880: if (*z++ != s) {
1881: return -EINVAL;
1882: }
1883: s = *z++;
1884: if (!isdigit(s)) {
1885: return -EINVAL;
1886: }
1887: v = (v<<4) + (s-'0');
1888: s = *z++;
1889: if (!isdigit(s)) {
1890: return -EINVAL;
1891: }
1892: v = (v<<4) + (s-'0');
1893: s = ':';
1894: }
1.17 oskar 1895: st->tab[tabnew.itab++] = v;
1.1 oskar 1896: #ifdef DEBUG
1897: fprintf(stderr, "datetime: %04lx %06lx, %d..%d\n",
1.17 oskar 1898: st->tab[tabnew.itab-2], v, a-b, z-b);
1.1 oskar 1899: #endif
1.17 oskar 1900: tabnew.isyn += 1;
1.1 oskar 1901: *e = '\n';
1902: return z-b;
1903: case SYNTAX_STRING:
1904: if (*a++ != '"') {
1905: return -EINVAL;
1906: }
1907: v = 0;
1908: z = strchr(a, '"');
1909: if (z == NULL) {
1910: return -EINVAL;
1911: }
1912: i = v;
1913: v += z-a;
1914: taballoc(st, 1 + (v + sizeof(long) - 1) / sizeof(long));
1.17 oskar 1915: memcpy(((char *)&st->tab[tabnew.itab+1]) + i, a, z-a);
1.1 oskar 1916: z += 1;
1917: while (*z == '"') {
1918: a = z;
1919: z = strchr(a+1, '"');
1920: if (z == NULL) {
1921: return -EINVAL;
1922: }
1923: i = v;
1924: v += z-a;
1925: taballoc(st, 1 + (v + sizeof(long) - 1) / sizeof(long));
1.17 oskar 1926: memcpy(((char *)&st->tab[tabnew.itab+1]) + i, a, z-a);
1.1 oskar 1927: z += 1;
1928: }
1.17 oskar 1929: st->tab[tabnew.itab] = v;
1.1 oskar 1930: #ifdef DEBUG
1931: fprintf(stderr, "string: %ld, %d..%d\n", v, a-b, z-b);
1932: #endif
1.17 oskar 1933: tabnew.itab += 1 + (v + sizeof(long) - 1) / sizeof(long);
1934: tabnew.isyn += 1;
1.1 oskar 1935: *e = '\n';
1936: return z-b;
1937: }
1938: } else {
1939: return e-b+1;
1940: }
1941: }
1942:
1943: static unsigned int tab2ts(unsigned char *t, unsigned char *conticnt)
1944: {
1945: unsigned int l, d;
1946: unsigned char *i = &t[2];
1947: unsigned char *o;
1948: unsigned char c = *conticnt;
1.4 oskar 1949: l = ((t[3] & 0x0F) << 8) + t[4] + TS_HEADSLEN + TS_PFIELDLEN;
1.1 oskar 1950: d = (l-1) % (TS_PACKET_SIZE - TS_PACKET_HEADSIZE) + 1;
1951: if (outin >= OUTBUF_SIZE) {
1952: outin = 0;
1953: }
1.9 oskar 1954: #ifdef DEBUG
1955: fprintf(stderr, "tab2ts(%02x,%02x,%02x,%02x,%02x; %2d), l=%d, d=%d, o:%d\n",
1956: t[0], t[1], t[2], t[3], t[4], c, l, d, outin);
1957: #endif
1.1 oskar 1958: o = &outbuf[outin];
1959: if (d <= (TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1)) {
1960: if (d < (TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1)) {
1961: o[5] = 0; /* no indicators, no flags, padding: */
1962: memset(&o[6], -1, TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 2 - d);
1963: }
1964: o[4] = TS_PACKET_SIZE - TS_PACKET_HEADSIZE - 1 - d;
1965: o[3] = (0x00 << 6) | (0x03 << 4) | c;
1966: } else {
1967: o[3] = (0x00 << 6) | (0x01 << 4) | c;
1968: }
1.4 oskar 1969: o[TS_PACKET_SIZE - d] = 0; /* pointer_field */
1970: d -= TS_PFIELDLEN;
1.1 oskar 1971: memcpy(&o[TS_PACKET_SIZE - d], i, d);
1972: i += d;
1.4 oskar 1973: d = l - d - TS_PFIELDLEN;
1.1 oskar 1974: o[1] = (0 << 7) | (1 << 6) | (0 << 5) | t[0];
1975: o[2] = t[1];
1976: o[0] = TS_SYNC_BYTE;
1977: c = (c + 1) & 0x0F;
1978: outin += TS_PACKET_SIZE;
1979: while (d > 0) {
1980: if (outin >= OUTBUF_SIZE) {
1981: outin = 0;
1982: }
1983: o = &outbuf[outin];
1984: o[3] = (0x00 << 6) | (0x01 << 4) | c;
1985: memcpy(&o[4], i, TS_PACKET_SIZE-TS_PACKET_HEADSIZE);
1986: i += (TS_PACKET_SIZE - TS_PACKET_HEADSIZE);
1987: d -= (TS_PACKET_SIZE - TS_PACKET_HEADSIZE);
1988: o[1] = (0 << 7) | (0 << 6) | (0 << 5) | t[0];
1989: o[2] = t[1];
1990: o[0] = TS_SYNC_BYTE;
1991: c = (c + 1) & 0x0F;
1992: outin += TS_PACKET_SIZE;
1993: }
1994: *conticnt = c;
1.11 oskar 1995: return l+1;
1.1 oskar 1996: }
1997:
1998: static void argloop(int f0)
1999: {
2000: int i0 = 0;
1.12 oskar 2001: int o0 = 0;
1.1 oskar 2002: char buf0[PATH_MAX];
2003: do {
2004: int i, n, r, n0, n1, nst, tmo;
2005: struct timeval tv;
2006: struct sitab *st;
2007: struct sitab **pst;
2008: pollfd_init();
1.12 oskar 2009: tmo = -1;
2010: n0 = -1;
2011: nst = -1;
2012: if (newtab != NULL) {
1.17 oskar 2013: nst = pollfd_add(tabnew.fd, POLLIN);
1.18 oskar 2014: } else if ((r = tabline(&buf0[o0], i0 - o0))) {
1.12 oskar 2015: o0 += r;
2016: tmo = 0;
1.1 oskar 2017: } else {
1.18 oskar 2018: if ((o0 > 0) && (i0 > o0)) {
2019: memmove(&buf0[0], &buf0[o0], i0 - o0);
1.12 oskar 2020: }
1.18 oskar 2021: i0 -= o0;
2022: o0 = 0;
1.12 oskar 2023: if (i0 == sizeof(buf0)-1) {
2024: buf0[sizeof(buf0)-1] = '\n';
2025: i0 += 1;
2026: tmo = 0;
2027: } else if (f0 >= 0) {
2028: n0 = pollfd_add(f0, POLLIN);
1.1 oskar 2029: }
2030: }
2031: if (outin == 0) {
2032: r = OUTBUF_SIZE;
2033: n1 = -1;
2034: } else {
2035: r = outout - outin;
2036: if (r < 0) {
2037: r += OUTBUF_SIZE;
2038: }
2039: n1 = pollfd_add(STDOUT_FILENO, POLLOUT);
2040: }
1.12 oskar 2041: i = 0;
2042: while (tmo != 0 && i <= TABLE_PID_LAST-TABLE_PID_FIRST) {
1.21 oskar 2043: if ((perpid[i].tabin > perpid[i].tabout)
2044: && (r >= (((((perpid[i].tabbuf[perpid[i].tabout+3] & 0x0F) << 8)
2045: + perpid[i].tabbuf[perpid[i].tabout+4] + TS_HEADSLEN
2046: + TS_PFIELDLEN + TS_PACKET_SIZE - TS_PACKET_HEADSIZE)
2047: * 131) / 128))) {
1.1 oskar 2048: tmo = 0;
1.9 oskar 2049: #ifdef DEBUG
2050: {
2051: int x;
1.21 oskar 2052: fprintf(stderr, "tabbuf[%d..%d-1]:\n",
2053: perpid[i].tabout, perpid[i].tabin);
2054: for (x = perpid[i].tabout; x < perpid[i].tabin; x++) {
2055: fprintf(stderr, "%02x ", perpid[i].tabbuf[x]);
1.9 oskar 2056: }
2057: fprintf(stderr, "\n");
2058: }
2059: #endif
1.1 oskar 2060: }
1.12 oskar 2061: i += 1;
1.1 oskar 2062: }
2063: gettimeofday(&tv, NULL);
2064: st = runtab;
2065: while (st != NULL) {
2066: i = st->pid - TABLE_PID_FIRST;
2067: if ((i < 0) || (i >= (TABLE_PID_LAST-TABLE_PID_FIRST))) {
2068: fprintf(stderr, "internal error (pid)\n");
2069: exit(1);
2070: }
1.21 oskar 2071: perpid[i].tabinold = perpid[i].tabin ? 1 : 0;
1.1 oskar 2072: if (tmo != 0) {
1.21 oskar 2073: if (perpid[i].tabin == 0) {
1.16 oskar 2074: i = (st->soon.tv_sec - tv.tv_sec) * 1000
2075: + (st->soon.tv_usec - tv.tv_usec) / 1000;
1.1 oskar 2076: if (i <= 0) {
2077: tmo = 0;
2078: } else if ((tmo < 0) || (i < tmo)) {
2079: tmo = i;
2080: }
2081: }
2082: }
2083: st = st->next;
2084: }
2085: n = pollfd_poll(tmo);
2086: gettimeofday(&tv, NULL);
2087: for (i = 0; i <= TABLE_PID_LAST-TABLE_PID_FIRST; i++) {
1.21 oskar 2088: while ((perpid[i].tabin > perpid[i].tabout)
2089: && (r >= (((((perpid[i].tabbuf[perpid[i].tabout+3] & 0x0F) << 8)
2090: + perpid[i].tabbuf[perpid[i].tabout+4] + TS_HEADSLEN
2091: + TS_PFIELDLEN + TS_PACKET_SIZE - TS_PACKET_HEADSIZE)
2092: * 131) / 128))) {
2093: perpid[i].tabout +=
2094: tab2ts(&perpid[i].tabbuf[perpid[i].tabout], &perpid[i].conticnt);
1.1 oskar 2095: r = outout - outin;
2096: if (r < 0) {
2097: r += OUTBUF_SIZE;
2098: }
2099: }
1.21 oskar 2100: if (perpid[i].tabin <= perpid[i].tabout) {
2101: perpid[i].tabin = perpid[i].tabout = 0;
1.1 oskar 2102: }
2103: }
2104: if ((n > 0) && (n1 >= 0) && (r = pollfd_rev(n1))) {
2105: if (r & (POLLNVAL | POLLERR)) {
2106: fprintf(stderr, "poll error: %x\n", r);
2107: return;
2108: }
2109: if (outout >= OUTBUF_SIZE) {
2110: outout = 0;
2111: }
2112: r = ((outin > outout) ? outin : OUTBUF_SIZE) - outout;
2113: r = write(STDOUT_FILENO, &outbuf[outout], r);
2114: if (r < 0) {
2115: fprintf(stderr, "write error(%d)\n", errno);
2116: return;
2117: }
2118: if (r == 0) {
2119: exit(0);
2120: }
2121: outout += r;
2122: if (outout == outin) {
2123: outin = outout = 0;
2124: }
2125: }
2126: pst = &runtab;
2127: while ((st = *pst) != NULL) {
2128: i = st->pid - TABLE_PID_FIRST;
1.21 oskar 2129: if ((perpid[i].tabinold == 0)
2130: && (perpid[i].tabin < (TABBUF_SIZE-MAX_PSI_SIZE+1-2))
1.16 oskar 2131: && ((st->soon.tv_sec < tv.tv_sec)
2132: || ((st->soon.tv_sec == tv.tv_sec)
2133: && (st->soon.tv_usec <= tv.tv_usec)))) {
1.1 oskar 2134: if (st->freqmsec > 0) {
1.16 oskar 2135: i = (st->soon.tv_sec - tv.tv_sec) * 1000
2136: + (st->soon.tv_usec - tv.tv_usec) / 1000;
1.1 oskar 2137: if (i < -st->freqmsec) {
1.16 oskar 2138: st->soon = tv;
1.1 oskar 2139: } else {
1.16 oskar 2140: st->soon.tv_sec += st->freqmsec / 1000;
2141: st->soon.tv_usec += (st->freqmsec % 1000) * 1000;
2142: if (st->soon.tv_usec > 1000000) {
2143: st->soon.tv_usec -= 1000000;
2144: st->soon.tv_sec += 1;
1.1 oskar 2145: }
2146: }
2147: }
2148: #ifdef DEBUG
2149: fprintf(stderr, "do tab: %ld.%06ld: %ld, %u\n", tv.tv_sec, tv.tv_usec,
2150: st->pid, st->tableid);
2151: #endif
2152: gentab(st, &tv);
2153: if (st->freqmsec <= 0) {
2154: *pst = st->next;
2155: nextversion[st->tableid - TABLEID_FIRST] = (st->version + 1) & 0x1F;
2156: free(st->tab);
2157: free(st);
2158: } else {
2159: pst = &st->next;
2160: }
2161: } else {
2162: pst = &st->next;
2163: }
2164: }
1.15 oskar 2165: if ((n > 0) && (nst >= 0) && (r = pollfd_rev(nst))) {
2166: if (r & (POLLNVAL | POLLERR)) {
2167: fprintf(stderr, "poll error: %x\n", r);
1.17 oskar 2168: close(tabnew.fd);
1.15 oskar 2169: free(newtab->tab);
2170: free(newtab);
2171: newtab = NULL;
2172: } else {
1.17 oskar 2173: i = tabnew.ibuf;
2174: r = read(tabnew.fd, &tabnew.buf[i], sizeof(tabnew.buf) - i - 1);
1.15 oskar 2175: if (r <= 0) {
1.17 oskar 2176: fprintf(stderr, "read error(%d): %d\n", errno, tabnew.fd);
2177: close(tabnew.fd);
1.15 oskar 2178: free(newtab->tab);
2179: free(newtab);
2180: newtab = NULL;
2181: } else {
2182: int j = 0;
2183: i += r;
1.17 oskar 2184: while ((r = siline(newtab, &tabnew.buf[j], i)) >= 0) {
1.15 oskar 2185: j += r;
2186: i -= r;
2187: }
2188: switch (r) {
2189: case -ENOBUFS:
1.17 oskar 2190: close(tabnew.fd);
1.15 oskar 2191: #ifdef DEBUG
1.17 oskar 2192: fprintf(stderr, "done, itab=%d\n", tabnew.itab);
2193: for (i = 0; i < tabnew.itab; i++) {
1.15 oskar 2194: fprintf(stderr, "%lu,", newtab->tab[i]);
2195: }
2196: fprintf(stderr, "\n");
2197: #endif
2198: i = newtab->pid - TABLE_PID_FIRST;
1.21 oskar 2199: if ((perpid[i].tabbuf == NULL)
2200: && ((perpid[i].tabbuf = malloc(TABBUF_SIZE)) == NULL)) {
1.15 oskar 2201: fprintf(stderr, "malloc failed for table buffer pid=%02lx\n",
2202: newtab->pid);
2203: free(newtab->tab);
2204: free(newtab);
1.1 oskar 2205: } else {
1.23 ! oskar 2206: if (newtab->tableid_ext) {
! 2207: newtab->tableid_ext = newtab->tab[0];
! 2208: }
1.20 oskar 2209: droptab(newtab->pid, newtab->tableid);
2210: newtab->version = nextversion[newtab->tableid - TABLEID_FIRST];
1.16 oskar 2211: newtab->soon = tv;
1.15 oskar 2212: newtab->next = runtab;
2213: runtab = newtab;
2214: }
1.20 oskar 2215: newtab = NULL;
1.15 oskar 2216: break;
2217: case -EAGAIN:
2218: if (i > 0) {
1.17 oskar 2219: memmove(&tabnew.buf[0], &tabnew.buf[j], i);
1.1 oskar 2220: }
1.17 oskar 2221: tabnew.ibuf = i;
1.15 oskar 2222: break;
2223: default:
2224: fprintf(stderr, "eval error: %d\n", r);
1.17 oskar 2225: close(tabnew.fd);
1.15 oskar 2226: free(newtab->tab);
2227: free(newtab);
2228: newtab = NULL;
2229: break;
1.1 oskar 2230: }
2231: }
1.15 oskar 2232: }
2233: n -= 1;
1.1 oskar 2234: }
2235: if ((n > 0) && (n0 >= 0) && (r = pollfd_rev(n0))) {
2236: if (r & (POLLNVAL | POLLERR)) {
2237: fprintf(stderr, "poll error: %x\n", r);
2238: return;
2239: }
2240: r = read(f0, &buf0[i0], sizeof(buf0) - i0 - 1);
2241: if (r < 0) {
2242: fprintf(stderr, "read error(%d): %d\n", errno, f0);
2243: return;
2244: }
2245: if (r == 0) {
2246: return;
2247: }
2248: i0 += r;
2249: n -= 1;
2250: }
2251: } while (1);
2252: }
2253:
2254: int main(int argc, char *argv[])
2255: {
2256: int f = -1;
2257: int a;
2258: if (sizeof(unsigned) != sizeof(struct loop_descr *)) {
2259: fprintf(stderr, "data type prerequisites not met\n");
2260: return 1;
2261: }
2262: gen_crc32_table();
2263: system_init();
2264: unblockf(STDIN_FILENO);
2265: unblockf(STDOUT_FILENO);
2266: memset(&nextversion[0], 0, sizeof(nextversion));
1.21 oskar 2267: memset(&perpid[0], 0, sizeof(perpid));
1.1 oskar 2268: a = 1;
2269: do {
2270: if ((a < argc) && (strcmp(argv[a], "-"))) {
2271: f = open(argv[a], O_RDONLY | O_NONBLOCK);
2272: if (f < 0) {
2273: fprintf(stderr, "open failed(%d): %s\n", errno, argv[a]);
2274: }
2275: } else {
2276: f = STDIN_FILENO;
2277: }
2278: argloop(f);
2279: } while (++a < argc);
2280: argloop(-1);
2281: return 0;
2282: }
LinuxTV legacy CVS <linuxtv.org/cvs>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to en300468ts.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [DVB] / multiplexer