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