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