/* (C) 2015-16 Digital Devices GmbH. Octoscan is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Octoscan is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with octoserve. If not, see . */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define container_of(p, st, field) (st*)((char*)(p) - offsetof(st, field)) #include "list.h" #include time_t mtime(time_t *t) { struct timespec ts; if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts)) return 0; if (t) *t = ts.tv_sec; return ts.tv_sec; } static int done = 0; static int eit_size = 0; static int eit_services = 0; static int eit_sections = 0; static int eit_events = 0; static int eit_shortsize = 0; static int eit_extsize = 0; static int eit_events_deleted = 0; char *pol2str[] = {"v", "h", "r", "l", NULL}; char *msys2str [] = {"undef", "dvbc", "dvbcb", "dvbt", "dss", "dvbs", "dvbs2", "dvbh", "isdbt", "isdbs", "isdbc", "atsc", "atscmh", "dtmb", "cmmb", "dab", "dvbt2", "turbo", "dvbcc", "dvbc2", NULL}; char *mtype2str [] = {"qpsk", "16qam", "32qam", "64qam", "128qam", "256qam", "autoqam", "8vsb", "16vsb", "8psk", "16apsk", "32apsk", "dqpsk", "4qamnr", NULL}; char *pilot2str [] = {"on", "off", "auto", NULL}; char *roll2str [] = {"0.35", "0.20", "0.25", NULL}; char *fec2str [] = {"none", "12", "23", "34", "56", "78", "89", "35", "45", "910", "25", NULL}; char *bw2str [] = {"8", "7", "6", "auto", "5", "10", "1.712", NULL }; char *tmode2str [] = { "2k", "8k", "auto", "4k", "1k", "16k", "32k", "c1", "c3780", NULL}; char *gi2str [] = { "132", "116", "18", "14", "auto", "1128", "19128", "19256", "pn420", "pn595", "pn945", NULL}; char *num2str [] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL}; struct sfilter { struct pid_info *pidi; struct list_head link; struct list_head tslink; uint8_t tid; uint16_t ext; //int (*cb) (struct sfilter *sf); uint8_t vnr; unsigned int todo_set : 1; unsigned int done : 1; unsigned int use_ext : 2; unsigned int vnr_set : 1; uint32_t todo[8]; time_t timeout; uint32_t timeout_len; }; struct pid_info { struct list_head link; struct ts_info *tsi; struct list_head sfilters; uint16_t pid; int add_ext; int done; uint8_t used; uint8_t cc; uint16_t bufp; uint16_t len; uint8_t *buf; }; struct satipcon { char *host; char *port; char tune[256]; char sid[64]; uint32_t strid; int seq; int sock; int usock; int nsport; }; struct ts_info { struct list_head pids; struct list_head sfilters; struct scantp *stp; uint16_t tsid; time_t timeout; int done; struct pid_info pidi[0x2000]; }; #define MAX_ANUM 32 struct service { struct list_head link; struct tp_info *tpi; struct list_head events; char name[80]; char pname[80]; unsigned int got_pmt : 1; unsigned int got_sdt : 1; unsigned int ca_mode : 1; unsigned int eit_pf : 1; unsigned int eit_sched : 1; uint16_t sid; uint16_t tsid; uint16_t onid; uint16_t pmt; uint16_t pcr; uint16_t vpid; uint16_t apid[MAX_ANUM]; uint16_t sub; uint16_t ttx; uint8_t anum; }; struct event { struct list_head link; //~ struct tp_info *tpi; uint16_t onid; uint16_t tsid; uint16_t sid; uint16_t eid; uint16_t mjd; uint8_t sh; uint8_t sm; uint8_t ss; uint8_t dh; uint8_t dm; uint8_t ds; uint8_t s_lang[3]; uint8_t *s_name; uint8_t *s_text; // uint8_t *extented; uint8_t content; uint8_t tid; }; #define MAX_EIT_SID 64 struct tp_info { struct list_head link; struct list_head services; int type; unsigned int use_nit : 1; unsigned int scan_eit : 1; uint32_t src; uint16_t nid; uint16_t onid; uint16_t tsid; uint32_t pos; uint32_t east; uint16_t id; uint32_t msys; uint32_t freq; uint32_t freq_frac; uint32_t pol; uint32_t sr; uint32_t ro; uint32_t mod; uint32_t bw; uint32_t fec; uint32_t isi; uint16_t eit_sid[MAX_EIT_SID]; }; struct scantp { struct scanip *sip; struct tp_info *tpi; time_t timeout; struct list_head sfilters; struct ts_info tsi; struct satipcon scon; }; struct scanip { char *host; struct list_head tps; struct list_head tps_done; struct scantp stp; int done; }; static void free_event(struct event *e) { if (e->s_name) free(e->s_name); if (e->s_text) free(e->s_text); free(e); } static void free_service(struct service *s) { struct event *pe,*npe; list_for_each_entry_safe(pe, npe, &s->events, link) { list_del(&pe->link); free_event(pe); } free(s); } static void free_tp_info(struct tp_info *p) { struct service *ps,*nps; list_for_each_entry_safe(ps, nps, &p->services, link) { list_del(&ps->link); free_service(ps); } free(p); } static struct service *get_service(struct tp_info *tpi, uint16_t sid) { struct service *s; list_for_each_entry(s, &tpi->services, link) { if (s->sid == sid) return s; } s = calloc(1, sizeof(struct service)); list_head_init(&s->events); s->sid = sid; snprintf(s->name, sizeof(s->name), "Service %d", sid); snprintf(s->pname, sizeof(s->name), "~"); list_add(&s->link, &tpi->services); return s; } /****************************************************************************/ /****************************************************************************/ void dump(const uint8_t *b, int l) { int i, j; for (j = 0; j < l; j += 16, b += 16) { for (i = 0; i < 16; i++) if (i + j < l) fprintf(stderr, "%02x ", b[i]); else fprintf(stderr, " "); fprintf(stderr, " | "); for (i = 0; i < 16; i++) if (i + j < l) fputc((b[i] > 31 && b[i] < 127) ? b[i] : '.', stderr); fprintf(stderr, "\n"); } } int sendlen(int sock, char *buf, int len) { int done, todo; for (todo = len; todo; todo -= done, buf += done) if ((done = send(sock, buf, todo, 0)) < 0) return done; return len; } static int udpsock(struct sockaddr *sadr, char *port) { int one=1, sock; struct addrinfo *ais, *ai, hints = { .ai_flags = AI_PASSIVE, .ai_family = AF_INET, .ai_socktype = SOCK_DGRAM, .ai_protocol = 0, .ai_addrlen = 0, .ai_addr = sadr, .ai_canonname = NULL, .ai_next = NULL, }; if (getaddrinfo(NULL, port, &hints, &ais) < 0) return -1; for (ai = ais; ai; ai = ai->ai_next) { sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (sock == -1) continue; if (!setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) && !bind(sock, ai->ai_addr, ai->ai_addrlen)) break; close(sock); sock = -1; } freeaddrinfo(ais); return sock; } static int streamsock(const char *name, const char *port, struct sockaddr *sadr) { int one=1, sock; struct addrinfo *ais, *ai, hints = { .ai_flags = 0, .ai_family = AF_UNSPEC, .ai_socktype = SOCK_STREAM, .ai_protocol = 0, .ai_addrlen = 0, .ai_addr = NULL, .ai_canonname = NULL, .ai_next = NULL, }; if (getaddrinfo(name, port, &hints, &ais) < 0) return -1; for (ai = ais; ai; ai = ai->ai_next) { sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (sock == -1) continue; if (!connect(sock, ai->ai_addr, ai->ai_addrlen)) { *sadr = *ai->ai_addr; break; } close(sock); sock = -1; } freeaddrinfo(ais); return sock; } static const char *sockname(struct sockaddr *sadr, char *name) { void *adr; if (sadr->sa_family == AF_INET) adr = &((struct sockaddr_in *) sadr)->sin_addr; else adr = &((struct sockaddr_in6 *) sadr)->sin6_addr; return inet_ntop(sadr->sa_family, adr, name, INET6_ADDRSTRLEN); } static void send_setup(int s, char *host, char *port, char *tune, int *seq, uint16_t cport, int mc) { uint8_t buf[256], opt[256] = { 0 }; int len; if (mc) len = snprintf(buf, sizeof(buf), "SETUP rtsp://%s:%s/?%s RTSP/1.0\r\n" "CSeq: %d\r\n" "Transport: RTP/AVP;multicast;port=%d-%d;ttl=3\r\n" "\r\n", host, port, tune, *seq , cport, cport + 1); else len = snprintf(buf, sizeof(buf), "SETUP rtsp://%s:%s/?%s RTSP/1.0\r\n" "CSeq: %d\r\n" "Transport: RTP/AVP;unicast;client_port=%d-%d\r\n" "\r\n", host, port, tune, *seq , cport, cport + 1); (*seq)++; if (len > 0 && len < sizeof(buf)) { sendlen(s, buf, len); //fprintf(stderr, "Send: %s\n", buf); } } static void send_play(int s, char *host, char *port, uint32_t strid, int *seq, char *sid) { uint8_t buf[1024]; int len; len = snprintf(buf, sizeof(buf), "PLAY rtsp://%s:%s/stream=%u RTSP/1.0\r\n" "CSeq: %d\r\n" "Session: %s\r\n" "\r\n", host, port, strid, *seq , sid); (*seq)++; if (len > 0 && len < sizeof(buf)) { sendlen(s, buf, len); //fprintf(stderr, "Send: %s\n", buf); } } static void send_teardown(int s, char *host, char *port, uint32_t strid, int *seq, char *sid) { uint8_t buf[1024]; int len; len = snprintf(buf, sizeof(buf), "TEARDOWN rtsp://%s:%s/stream=%u RTSP/1.0\r\n" "CSeq: %d\r\n" "Session: %s\r\n" "\r\n", host, port, strid, *seq , sid); (*seq)++; if (len > 0 && len < sizeof(buf)) { sendlen(s, buf, len); //fprintf(stderr, "Send: %s\n", buf); } } static int get_url(char *url, char **a) { struct sockaddr_in sa; char sname[INET_ADDRSTRLEN]; int s; struct sockaddr sadr; char host[1024], port[1024], dport[] = "554"; char *u, *e; if (strncasecmp(url, "rtsp://", 7)) return -1; e = url + 7; for (u = e; *u && *u != ':' && *u != '/'; u++); if (u == e || !*u) return -1; memcpy(host, e, u - e); host[u - e] = '\0'; if (*u == ':') { e = u + 1; for (u++; *u && *u != '/'; u++); if (!*u) return -1; memcpy(port, e, u - e); port[u - e] = '\0'; } else if (*u == '/') { strcpy(port, dport); } *a = u + 1; //fprintf(stderr, "host %s, port %s\n", host, port); s = streamsock(host, port, &sadr); if (s < 0) return -1; if (!sockname(&sadr, sname)) return -1; //fprintf(stderr, "%s\n", sname); return s; } static void getarg(char *b, char **a, char **ae) { while (isspace(*b)) b++; *a = b; while (*b && *b != ';') b++; *ae = b; **ae = 0; } static int check_ok(int s, char *sid, uint32_t *strid) { char b[4096], *a, *ae; int n, bl = 0, bs = sizeof(b); char *l, *e; uint32_t sport, sport2; while (1) { n = recv(s, b + bl, bs - bl, 0); if (n <= 0) return 0; if (n + bl > bs) return -1; bl += n; if (bl >=4 && b[bl - 4] == '\r' && b[bl - 3] == '\n' && b[bl - 2] == '\r' && b[bl - 1] == '\n') break; } b[bl-2] = 0; if (strncasecmp(b, "RTSP/1.0 200 OK\r\n", 17)) return -1; //dump(b, bl); for (l = b + 17; *l; l = e + 1) { for (e = l; *e && *e != '\r' && *e != '\n'; e++); if (e == l) continue; *e = 0; //fprintf(stderr, "%s\n", l); if (!strncasecmp(l, "Session:", 8)) { getarg(l + 8, &a, &ae); *ae = 0; //fprintf(stderr, "session = %s\n", a); strcpy(sid, a); } else if (!strncasecmp(l, "Transport:", 10)) { char *k; for (k = l + 10; k < e; k = ae + 1) { getarg(k, &a, &ae); if (!strncasecmp(a, "server_port=", 12)) { a += 12; sport = strtoul(a, &a, 10); if (*a != '-') return -1; a++; sport2 = strtoul(a, &a, 10); //fprintf(stderr, "sports = %d-%d\n", sport, sport2); } } } else if (!strncasecmp(l, "com.ses.streamID:", 17)) { *strid = strtoul(l + 17, NULL, 10); //fprintf(stderr, "stream id = %d\n", *strid); } } return 0; } /****************************************************************************/ void add_fd(int fd, int *mfd, fd_set *fds) { FD_SET(fd, fds); if (fd > *mfd) *mfd = fd; } static inline uint16_t seclen(const uint8_t *buf) { return 3+((buf[1]&0x0f)<<8)+buf[2]; } static inline uint16_t tspid(const uint8_t *buf) { return ((buf[1]&0x1f)<<8)+buf[2]; } static inline int tspayload(const uint8_t *tsp) { if (!(tsp[3] & 0x10)) return 0; if (tsp[3] & 0x20) { if (tsp[4] > 183) return 0; else return 183 - tsp[4]; } return 184; } static inline int tspaystart(const uint8_t *tsp) { if (!(tsp[3]&0x10)) return 188; if (tsp[3]&0x20) { if (tsp[4]>=184) return 188; else return tsp[4]+5; } return 4; } /****************************************************************************/ static uint32_t dvb_crc_table[256] = { 0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba, 0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec, 0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4}; uint32_t dvb_crc32(uint8_t *data, int len) { int i; uint32_t crc=0xffffffff; for (i = 0; i < len; i++) crc = (crc << 8) ^ dvb_crc_table[((crc >> 24) ^ *data++) & 0xff]; return crc; } static void pid_info_init(struct pid_info *pidi, uint16_t pid, struct ts_info *tsi) { memset(pidi, 0, sizeof(struct pid_info)); list_head_init(&pidi->sfilters); pidi->pid=pid; pidi->tsi=tsi; } static void pid_info_release(struct pid_info *pidi) { struct sfilter *p, *n; list_for_each_entry_safe(p, n, &pidi->sfilters, link) { list_del(&p->link); free(p); } if (pidi->buf) free(pidi->buf); } static inline void pid_info_reset(struct pid_info *pidi) { pidi->bufp = pidi->len = 0; } static int update_pids(struct ts_info *tsi); static int del_sfilter(struct sfilter *sf) { list_del(&sf->link); free(sf); return 0; } int cmp_tp(struct tp_info *a, struct tp_info *b) { if (a->msys != b->msys) return 0; if (a->src != b->src) return 0; if (a->freq != b->freq) { if (a->freq != b->freq + 1 && a->freq != b->freq - 1) return 0; } //~ if (a->mod != b->mod ) //~ return 0; if (a->pol != b->pol ) return 0; return 1; } int add_tp(struct scanip *sip, struct tp_info *tpi_new) { struct tp_info *tpi, *p; list_for_each_entry(p, &sip->tps, link) { if (cmp_tp(p, tpi_new)) return -1; } list_for_each_entry(p, &sip->tps_done, link) { if (cmp_tp(p, tpi_new)) return -1; } tpi = malloc(sizeof(struct tp_info)); if (!tpi) return -1; memcpy(tpi, tpi_new, sizeof(struct tp_info)); //fprintf(stderr, "added tp freq = %u\n", tpi->freq); list_add_tail(&tpi->link, &sip->tps); list_head_init(&tpi->services); return 0; } static int add_pid(struct ts_info *tsi, uint16_t pid, int add_ext) { struct pid_info *pidi = &tsi->pidi[pid]; if (!tsi->pidi[pid].used) { pid_info_init(pidi, pid, tsi); pidi->used = 1; update_pids(tsi); list_add_tail(&pidi->link, &tsi->pids); } pidi->add_ext = add_ext; return 0; } static int add_sfilter(struct ts_info *tsi, uint16_t pid, uint8_t tid, uint16_t ext, int use_ext, uint32_t timeout) { struct pid_info *pidi; struct sfilter *sf; add_pid(tsi, pid, use_ext ? 1 : 0); pidi = &tsi->pidi[pid]; list_for_each_entry(sf, &pidi->sfilters, link) { if (sf->tid == tid && sf->ext == ext) return -1; } sf = calloc(1, sizeof(struct sfilter)); if (!sf) return -1; sf->pidi = pidi; sf->tid = tid; sf->ext = ext; sf->use_ext = use_ext; sf->vnr = 0xff; sf->timeout_len = timeout; sf->timeout = mtime(NULL) + sf->timeout_len; list_add_tail(&sf->link, &pidi->sfilters); list_add_tail(&sf->tslink, &pidi->tsi->sfilters); //fprintf(stderr, "add_sfilter PID=%u TID=%u EXT=%u\n", pidi->pid, tid, ext); return 0; } void ts_info_init(struct ts_info *tsi) { int i; list_head_init(&tsi->pids); list_head_init(&tsi->sfilters); for (i=0; i<0x2000; i++) pid_info_init(&tsi->pidi[i], i, tsi); } void ts_info_release(struct ts_info *tsi) { int i; for (i=0; i<0x2000; i++) pid_info_release(&tsi->pidi[i]); } static uint32_t getbcd(uint8_t *p, int l) { int i; uint32_t val = 0, t; for (i = 0; i < l / 2; i++) { t = (p[i] >> 4) * 10 + (p[i] & 0x0f); val = val * 100 + t; } if (l & 1) val = val * 10 + (p[i] >> 4); return val; } static uint16_t get16(uint8_t *p) { return (p[0] << 8) | p[1]; } static uint16_t get12(uint8_t *p) { return ((p[0] & 0x0f) << 8) | p[1]; } static uint16_t get_pid(uint8_t *pid) { uint16_t pp; pp = (pid[0] & 0x1f) << 8; pp |= pid[1] &0xff; return pp; } static int get_desc(struct pid_info *p, uint8_t *buf, int length) { int dlength; int c=0; uint16_t casys; uint16_t capid; while (c < length) { dlength = buf[c+1]; switch(buf[c]){ case 0x02: break; case 0x03: break; case 0x09: if (!dlength) break; casys =(buf[c+2]<<8)|buf[c+3]; capid = get_pid(buf+c+4); break; default: break; } c += dlength + 2; } return length; } static int update_pids(struct ts_info *tsi) { struct satipcon *scon = &tsi->stp->scon; uint8_t buf[1024]; char pids[512]; int len, len2, plen; uint32_t pid; //fprintf(stderr, "tune=%s\n", &scon->tune[0]); for (pid = 0, plen = 0; pid < 8192; pid++) { if (tsi->pidi[pid].used) { len2 = snprintf(pids + plen, sizeof(pids) - plen, ",%u", pid); if (len2 < 0) return -1; if (plen + len2 >= 300) break; plen += len2; } } pids[0] = '='; if (!plen) snprintf(pids, sizeof(pids), "=none"); //fprintf(stderr, "pids%s\n",pids); len = snprintf(buf, sizeof(buf), "PLAY rtsp://%s:%s/stream=%u?%s&pids%s RTSP/1.0\r\n" "CSeq: %d\r\n" "Session: %s\r\n" "\r\n", scon->host, scon->port, scon->strid, &scon->tune[0], pids, scon->seq , scon->sid); scon->seq++; if (len > 0 && len < sizeof(buf)) { sendlen(scon->sock, buf, len); //fprintf(stderr, "Send: %s\n", buf); } } static int hasdesc(uint8_t stag, uint8_t *b, int dll) { int i; for (i = 0; i < dll; i += b[i + 1] + 2) { if (stag == b[i]) return 1; } return 0; } static int pmt_cb(struct sfilter *sf) { struct pid_info *p = sf->pidi; uint8_t *buf=p->buf; int slen, ilen, eslen, c; uint16_t epid, pnr; struct service *s; slen = get12(buf + 1) + 3; pnr = get16(buf + 3); if (pnr != sf->ext) return 0; //fprintf(stderr, "PMT %04x: PNR %04x\n", p->pid, pnr); //fprintf(stderr, " snr %02x lsnr %02x", buf[6], buf[7]); //dump(buf, p->len); c = 12; if ((ilen = get12(buf + 10))) c += get_desc(p, buf + c, ilen); if (c != 12 + ilen) return 0; s = get_service(p->tsi->stp->tpi, pnr); s->pcr = get_pid(buf + 8); s->anum = 0; s->pmt = p->pid; while (c < slen - 4) { eslen = get12(buf + c + 3); epid = get_pid(buf + c + 1); //fprintf(stderr, " TYPE %02x PID %04x len %u\n", buf[c], epid, eslen, eslen); //dump(buf + c, eslen + 5); switch (buf[c]) { case 0x01: // MPEG1 case 0x02: // MPEG2 case 0x10: // MPEG4 case 0x1b: // H264 case 0x24: // HEVC case 0x42: // CAVS case 0xea: // VC1 case 0xd1: // DIRAC s->vpid = epid; break; case 0x03: // MPEG1 case 0x04: // MPEG2 case 0x0F: // AAC case 0x11: // AAC_LATM case 0x81: // AC3 case 0x82: // DTS case 0x83: // TRUEHD if (s->anum < MAX_ANUM) s->apid[s->anum++] = epid; //fprintf(stderr, " APID %04x", epid); break; case 0x06: if (hasdesc(0x56, buf + c + 5, eslen)) s->ttx = epid; else if (hasdesc(0x59, buf + c + 5, eslen)) s->sub = epid; else if (hasdesc(0x6a, buf + c + 5, eslen) || hasdesc(0x7a, buf + c + 5, eslen)) { if (s->anum < MAX_ANUM) s->apid[s->anum++] = epid; } break; case 0x05: // PRIVATE break; default: break; } c += 5; c += eslen; //if (eslen) // c+=get_desc(p, buf+c, eslen); } s->got_pmt = 1; //fprintf(stderr, "\n"); return 0; } static int nit_cb(struct sfilter *sf) { struct pid_info *p = sf->pidi; struct scanip *sip = p->tsi->stp->sip; uint8_t *buf = p->buf; int slen, tsp, c; uint16_t pid, pnr, nid; uint16_t ndl, tsll, tdl; uint16_t tsid, onid; struct tp_info t; slen = get12(buf + 1) + 3; if (buf[1] & 0x80) slen -= 4; nid = get16(buf + 3); ndl = get12(buf + 8); tsp = 10 + ndl; for (c = 10; c < tsp; c++) { } tsll = get12(buf + tsp); //fprintf(stderr, "NIT(%02x): len %u nid %u snr %02x lsnr %02x", buf[0], slen, nid, buf[6], buf[7]); //fprintf(stderr, " ndl %02x tsll %02x\n", ndl, tsll); if (p->tsi->stp->tpi->use_nit) { for (c = tsp + 2; c < slen; c += tdl) { //dump(buf + c + 6, tdl); memset(&t, 0, sizeof(struct tp_info)); t.tsid = get16(buf + c); t.onid = get16(buf + c + 2); t.nid = nid; t.use_nit = p->tsi->stp->tpi->use_nit; t.scan_eit = p->tsi->stp->tpi->scan_eit; tdl = get12(buf + c + 4); //fprintf(stderr, " tsid %02x onid %02x tdl %02x\n", tsid, onid, tdl); c += 6; switch (buf[c]) { case 0x43: t.freq = getbcd(buf + c + 2, 8) / 100; t.freq_frac = 0; t.pos = getbcd(buf + c + 6, 4); t.sr = getbcd(buf + c + 9, 7) / 10; t.east = (buf[c + 8] & 0x80) >> 7; t.pol = 1 ^ ((buf[c + 8] & 0x60) >> 5); // H V L R t.ro = (buf[c + 8] & 0x18) >> 3; // 35 25 20 t.type = t.msys = ((buf[c + 8] & 0x04) >> 2) ? 6 : 5; t.mod = buf[c + 8] & 0x03; // auto qpsk 8psk 16-qam t.fec = buf[c + 12] & 0x0f; // undef 1/2 2/3 3/4 5/6 7/8 8/9 3/5 4/5 9/10 //fprintf(stderr, " freq = %u pos = %u sr = %u fec = %u \n", freq, pos, sr, fec); //fprintf(stderr, "freq=%u&pol=%s&msys=%s&sr=%u\n", //t.freq, pol2str[t.pol&3], t.type == 6 ? "dvbs2" : "dvbs", t.sr); t.src = p->tsi->stp->tpi->src; add_tp(sip, &t); break; case 0x44: { uint32_t freq = getbcd(buf + c + 2, 8); t.freq = freq / 10000; t.freq_frac = freq % 10000; } t.sr = getbcd(buf + c + 9, 7) / 10; t.mod = buf[c + 8]; // undef 16 32 64 128 256 t.msys = 1; t.type = 1; //fprintf(stderr, " freq = %u pos = %u sr = %u fec = %u \n", freq, pos, sr, fec); //fprintf(stderr, "freq=%u&msys=dvbc&mtype=%s\n", t.freq, mtype2str[t.mod]); if( t.freq >= 50 && t.freq <= 1000 && t.sr >= 1000 && t.sr <= 7100 && t.mod >= 1 && t.mod <= 5 ) add_tp(sip, &t); else { fprintf(stderr, " ************************* freq = %u sr = %u mod = %u \n", t.freq, t.sr, t.mod); fprintf(stderr, " ************************* buffer start:\n" ); dump(buf, 32); fprintf(stderr, " ************************* buffer position (c-32,c+16) c = %d, slen = %d\n", c, slen); dump(buf + c - 32, 48); } break; } } } return 0; } static int pat_cb(struct sfilter *sf) { struct pid_info *p = sf->pidi; uint8_t *buf = p->buf; int slen, ilen, eslen, c; uint16_t pid, pnr; uint8_t snr, lsnr; uint16_t nit_pid = 0x10; slen = (((buf[1]&0x03)<<8)|buf[2])+3; sf->ext = ((buf[3]<<8)|buf[4]); p->tsi->tsid = sf->ext; //fprintf(stderr, "PAT: TSID %04x sn %u lsn %u todo %08x vnr %u", p->tsi->tsid, snr, lsnr, sf->todo, sf->vnr); c = 8; for (c = 8; c < slen - 4; c +=4) { pnr = (buf[c] << 8) | buf[c + 1]; pid = get_pid(buf + c + 2); //fprintf(stderr, " PNR %04x PID %04x", pnr, pid); if (pnr) { add_sfilter(p->tsi, pid, 0x02, pnr, 2, 5); add_sfilter(p->tsi, 0x11, 0x42, pnr, 2, 5); } else { nit_pid = pid; } } add_sfilter(p->tsi, nit_pid, 0x40, 0, 1, 15); //add_sfilter(p->tsi, nit_pid, 0x41, 0, 1, 15); //fprintf(stderr, "\n"); return 0; } #define CHARACTER_RESERVED_80 0x80 #define CHARACTER_RESERVED_81 0x81 #define CHARACTER_RESERVED_82 0x82 #define CHARACTER_RESERVED_83 0x83 #define CHARACTER_RESERVED_84 0x84 #define CHARACTER_RESERVED_85 0x85 #define CHARACTER_EMPHASIS_ON 0x86 #define CHARACTER_EMPHASIS_OFF 0x87 #define CHARACTER_RESERVED_88 0x88 #define CHARACTER_RESERVED_89 0x89 #define CHARACTER_CR_LF 0x8A #define CHARACTER_USER_8B 0x8B #define CHARACTER_USER_9F 0x9F uint16_t codetable_00[96] = { 0x00A0,0x00A1,0x00A2,0x00A3, 0x20AC,0x00A5,0x0000,0x00A7, 0x00A4,0x2018,0x201C,0x00AB, 0x2190,0x2191,0x2192,0x2193, 0x00B0,0x00B1,0x00B2,0x00B3, 0x00B4,0x00B5,0x00B6,0x00B7, 0x00F7,0x2019,0x201D,0x00BB, 0x00BC,0x00BD,0x00BE,0x00BF, 0x0000,0x0300,0x0301,0x0302, 0x0303,0x0304,0x0306,0x0307, 0x0308,0x0000,0x030A,0x0327, 0x0000,0x030B,0x0328,0x030C, 0x2015,0x00B9,0x00AE,0x00A9, 0x2122,0x266A,0x00AC,0x00A6, 0x0000,0x0000,0x0000,0x0000, 0x215B,0x215C,0x215D,0x215E, 0x2126,0x00C6,0x0110,0x00AA, 0x0126,0x0000,0x0132,0x013F, 0x0141,0x00D8,0x0152,0x00BA, 0x00DE,0x0166,0x014A,0x0149, 0x0138,0x00E6,0x0111,0x00F0, 0x0127,0x0131,0x0133,0x0140, 0x0142,0x00F8,0x0153,0x00DF, 0x00FE,0x0167,0x014B,0x00AD, }; uint16_t codetable_01[96] = { 0x00A0,0x0401,0x0402,0x0403, 0x0404,0x0405,0x0406,0x0407, 0x0408,0x0409,0x040A,0x040B, 0x040C,0x00AD,0x040E,0x040F, 0x0410,0x0411,0x0412,0x0413, 0x0414,0x0415,0x0416,0x0417, 0x0418,0x0419,0x041A,0x041B, 0x041C,0x041D,0x041E,0x041F, 0x0420,0x0421,0x0422,0x0423, 0x0424,0x0425,0x0426,0x0427, 0x0428,0x0429,0x042A,0x042B, 0x042C,0x042D,0x042E,0x042F, 0x0430,0x0431,0x0432,0x0433, 0x0434,0x0435,0x0436,0x0437, 0x0438,0x0439,0x043A,0x043B, 0x043C,0x043D,0x043E,0x043F, 0x0440,0x0441,0x0442,0x0443, 0x0444,0x0445,0x0446,0x0447, 0x0448,0x0449,0x044A,0x044B, 0x044C,0x044D,0x044E,0x044F, 0x2116,0x0451,0x0452,0x0453, 0x0454,0x0455,0x0456,0x0457, 0x0458,0x0459,0x045A,0x045B, 0x045C,0x00A7,0x045E,0x045F, }; uint16_t codetable_02[96] = { 0x00A0,0x0000,0x0000,0x0000, 0x00A4,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x060C,0x00AD,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x061B, 0x0000,0x0000,0x0000,0x061F, 0x0000,0x0621,0x0622,0x0623, 0x0624,0x0625,0x0626,0x0627, 0x0628,0x0629,0x062A,0x062B, 0x062C,0x062D,0x062E,0x062F, 0x0630,0x0631,0x0632,0x0633, 0x0634,0x0635,0x0636,0x0637, 0x0638,0x0639,0x063A,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0640,0x0641,0x0642,0x0643, 0x0644,0x0645,0x0646,0x0647, 0x0648,0x0649,0x064A,0x064B, 0x064C,0x064D,0x064E, 0x064F, 0x0650,0x0651,0x0652,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, }; uint16_t codetable_03[96] = { 0x00A0,0x2018,0x2019,0x00A3, 0x20AC,0x20AF,0x00A6,0x00A7, 0x00A8,0x00A9,0x037A,0x00AB, 0x00AC,0x00AD,0x0000,0x2015, 0x00B0,0x00B1,0x00B2,0x00B3, 0x0384,0x0385,0x0386,0x00B7, 0x0388,0x0389,0x038A,0x00BB, 0x038C,0x00BD,0x038E,0x038F, 0x0390,0x0391,0x0392,0x0393, 0x0394,0x0395,0x0396,0x0397, 0x0398,0x0399,0x039A,0x039B, 0x039C,0x039D,0x039E,0x039F, 0x03A0,0x03A1,0x0000,0x03A3, 0x03A4,0x03A5,0x03A6,0x03A7, 0x03A8,0x03A9,0x03AA,0x03AB, 0x03AC,0x03AD,0x03AE,0x03AF, 0x03B0,0x03B1,0x03B2,0x03B3, 0x03B4,0x03B5,0x03B6,0x03B7, 0x03B8,0x03B9,0x03BA,0x03BB, 0x03BC,0x03BD,0x03BE,0x03BF, 0x03C0,0x03C1,0x03C2,0x03C3, 0x03C4,0x03C5,0x03C6,0x03C7, 0x03C8,0x03C9,0x03CA,0x03CB, 0x03CC,0x03CD,0x03CE,0x0000, }; uint16_t codetable_04[96] = { 0x00A0,0x0000,0x00A2,0x00A3, 0x00A4,0x00A5,0x00A6,0x00A7, 0x00A8,0x00A9,0x00D7,0x00AB, 0x00AC,0x00AD,0x00AE,0x00AF, 0x00B0,0x00B1,0x00B2,0x00B3, 0x00B4,0x00B5,0x00B6,0x00B7, 0x00B8,0x00B9,0x00F7,0x00BB, 0x00BC,0x00BD,0x00BE,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x0000, 0x0000,0x0000,0x0000,0x2017, 0x05D0,0x05D1,0x05D2,0x05D3, 0x05D4,0x05D5,0x05D6,0x05D7, 0x05D8,0x05D9,0x05DA,0x05DB, 0x05DC,0x05DD,0x05DE,0x05DF, 0x05E0,0x05E1,0x05E2,0x05E3, 0x05E4,0x05E5,0x05E6,0x05E7, 0x05E8,0x05E9,0x05EA,0x0000, 0x0000,0x200E,0x200F,0x0000, }; uint16_t codetable_05[96] = { 0x00A0,0x00A1,0x00A2,0x00A3, 0x00A4,0x00A5,0x00A6,0x00A7, 0x00A8,0x00A9,0x00AA,0x00AB, 0x00AC,0x00AD,0x00AE,0x00AF, 0x00B0,0x00B1,0x00B2,0x00B3, 0x00B4,0x00B5,0x00B6,0x00B7, 0x00B8,0x00B9,0x00BA,0x00BB, 0x00BC,0x00BD,0x00BE,0x00BF, 0x00C0,0x00C1,0x00C2,0x00C3, 0x00C4,0x00C5,0x00C6,0x00C7, 0x00C8,0x00C9,0x00CA,0x00CB, 0x00CC,0x00CD,0x00CE,0x00CF, 0x011E,0x00D1,0x00D2,0x00D3, 0x00D4,0x00D5,0x00D6,0x00D7, 0x00D8,0x00D9,0x00DA,0x00DB, 0x00DC,0x0130,0x015E,0x00DF, 0x00E0,0x00E1,0x00E2,0x00E3, 0x00E4,0x00E5,0x00E6,0x00E7, 0x00E8,0x00E9,0x00EA,0x00EB, 0x00EC,0x00ED,0x00EE,0x00EF, 0x011F,0x00F1,0x00F2,0x00F3, 0x00F4,0x00F5,0x00F6,0x00F7, 0x00F8,0x00F9,0x00FA,0x00FB, 0x00FC,0x0131,0x015F,0x00FF, }; uint16_t codetable_06[96] = { 0x00A0,0x0104,0x0112,0x0122, 0x012A,0x0128,0x0136,0x00A7, 0x013B,0x0110,0x0160,0x0166, 0x017D,0x00AD,0x016A,0x014A, 0x00B0,0x0105,0x0113,0x0123, 0x012B,0x0129,0x0137,0x00B7, 0x013C,0x0111,0x0161,0x0167, 0x017E,0x2015,0x016B,0x014B, 0x0100,0x00C1,0x00C2,0x00C3, 0x00C4,0x00C5,0x00C6,0x012E, 0x010C,0x00C9,0x0118,0x00CB, 0x0116,0x00CD,0x00CE,0x00CF, 0x00D0,0x0145,0x014C,0x00D3, 0x00D4,0x00D5,0x00D6,0x0168, 0x00D8,0x0172,0x00DA,0x00DB, 0x00DC,0x00DD,0x00DE,0x00DF, 0x0101,0x00E1,0x00E2,0x00E3, 0x00E4,0x00E5,0x00E6,0x012F, 0x010D,0x00E9,0x0119,0x00EB, 0x0117,0x00ED,0x00EE,0x00EF, 0x00F0,0x0146,0x014D,0x00F3, 0x00F4,0x00F5,0x00F6,0x0169, 0x00F8,0x0173,0x00FA,0x00FB, 0x00FC,0x00FD,0x00FE,0x0138, }; uint16_t codetable_07[96] = { 0x00A0,0x0E01,0x0E02,0x0E03, 0x0E04,0x0E05,0x0E06,0x0E07, 0x0E08,0x0E09,0x0E0A,0x0E0B, 0x0E0C,0x0E0D,0x0E0E,0x0E0F, 0x0E10,0x0E11,0x0E12,0x0E13, 0x0E14,0x0E15,0x0E16,0x0E17, 0x0E18,0x0E19,0x0E1A,0x0E1B, 0x0E1C,0x0E1D,0x0E1E,0x0E1F, 0x0E20,0x0E21,0x0E22,0x0E23, 0x0E24,0x0E25,0x0E26,0x0E27, 0x0E28,0x0E29,0x0E2A,0x0E2B, 0x0E2C,0x0E2D,0x0E2E,0x0E2F, 0x0E30,0x0E31,0x0E32,0x0E33, 0x0E34,0x0E35,0x0E36,0x0E37, 0x0E38,0x0E39,0x0E3A,0x0000, 0x0000,0x0000,0x0000,0x0E3F, 0x0E40,0x0E41,0x0E42,0x0E43, 0x0E44,0x0E45,0x0E46,0x0E47, 0x0E48,0x0E49,0x0E4A,0x0E4B, 0x0E4C,0x0E4D,0x0E4E,0x0E4F, 0x0E50,0x0E51,0x0E52,0x0E53, 0x0E54,0x0E55,0x0E56,0x0E57, 0x0E58,0x0E59,0x0E5A,0x0E5B, 0x0000,0x0000,0x0000,0x0000, }; uint16_t codetable_09[96] = { 0x00A0,0x201D,0x00A2,0x00A3, 0x00A4,0x201E,0x00A6,0x00A7, 0x00D8,0x00A9,0x0156,0x00AB, 0x00AC,0x00AD,0x00AE,0x00C6, 0x00B0,0x00B1,0x00B2,0x00B3, 0x201C,0x00B5,0x00B6,0x00B7, 0x00F8,0x00B9,0x0157,0x00BB, 0x00BC,0x00BD,0x00BE,0x00E6, 0x0104,0x012E,0x0100,0x0106, 0x00C4,0x00C5,0x0118,0x0112, 0x010C,0x00C9,0x0179,0x0116, 0x0122,0x0136,0x012A,0x013B, 0x0160,0x0143,0x0145,0x00D3, 0x014C,0x00D5,0x00D6,0x00D7, 0x0172,0x0141,0x015A,0x016A, 0x00DC,0x017B,0x017D,0x00DF, 0x0105,0x012F,0x0101,0x0107, 0x00E4,0x00E5,0x0119,0x0113, 0x010D,0x00E9,0x017A,0x0117, 0x0123,0x0137,0x012B,0x013C, 0x0161,0x0144,0x0146,0x00F3, 0x014D,0x00F5,0x00F6,0x00F7, 0x0173,0x0142,0x015B,0x016B, 0x00FC,0x017C,0x017E,0x2019, }; uint16_t codetable_0A[96] = { 0x00A0,0x1E02,0x1E03,0x00A3, 0x010A,0x010B,0x1E0A,0x00A7, 0x1E80,0x00A9,0x1E82,0x1E0B, 0x1EF2,0x00AD,0x00AE,0x0178, 0x1E1E,0x1E1F,0x0120,0x0121, 0x1E40,0x1E41,0x00B6,0x1E56, 0x1E81,0x1E57,0x1E83,0x1E60, 0x1EF3,0x1E84,0x1E85,0x1E61, 0x00C0,0x00C1,0x00C2,0x00C3, 0x00C4,0x00C5,0x00C6,0x00C7, 0x00C8,0x00C9,0x00CA,0x00CB, 0x00CC,0x00CD,0x00CE,0x00CF, 0x0174,0x00D1,0x00D2,0x00D3, 0x00D4,0x00D5,0x00D6,0x1E6A, 0x00D8,0x00D9,0x00DA,0x00DB, 0x00DC,0x00DD,0x0176,0x00DF, 0x00E0,0x00E1,0x00E2,0x00E3, 0x00E4,0x00E5,0x00E6,0x00E7, 0x00E8,0x00E9,0x00EA,0x00EB, 0x00EC,0x00ED,0x00EE,0x00EF, 0x0175,0x00F1,0x00F2,0x00F3, 0x00F4,0x00F5,0x00F6,0x1E6B, 0x00F8,0x00F9,0x00FA,0x00FB, 0x00FC,0x00FD,0x0177,0x00FF, }; uint16_t codetable_0B[96] = { 0x00A0,0x00A1,0x00A2,0x00A3, 0x20AC,0x00A5,0x0160,0x00A7, 0x0161,0x00A9,0x00AA,0x00AB, 0x00AC,0x00AD,0x00AE,0x00AF, 0x00B0,0x00B1,0x00B2,0x00B3, 0x017D,0x00B5,0x00B6,0x00B7, 0x017E,0x00B9,0x00BA,0x00BB, 0x0152,0x0153,0x0178,0x00BF, 0x00C0,0x00C1,0x00C2,0x00C3, 0x00C4,0x00C5,0x00C6,0x00C7, 0x00C8,0x00C9,0x00CA,0x00CB, 0x00CC,0x00CD,0x00CE,0x00CF, 0x00D0,0x00D1,0x00D2,0x00D3, 0x00D4,0x00D5,0x00D6,0x00D7, 0x00D8,0x00D9,0x00DA,0x00DB, 0x00DC,0x00DD,0x00DE,0x00DF, 0x00E0,0x00E1,0x00E2,0x00E3, 0x00E4,0x00E5,0x00E6,0x00E7, 0x00E8,0x00E9,0x00EA,0x00EB, 0x00EC,0x00ED,0x00EE,0x00EF, 0x00F0,0x00F1,0x00F2,0x00F3, 0x00F4,0x00F5,0x00F6,0x00F7, 0x00F8,0x00F9,0x00FA,0x00FB, 0x00FC,0x00FD,0x00FE,0x00FF, }; uint16_t *codetable_LUT[12] = { codetable_00, codetable_01, codetable_02, codetable_03, codetable_04, codetable_05, codetable_06, codetable_07, codetable_00, codetable_09, codetable_0A, codetable_0B, }; void en300468_parse_string_to_utf8(char *dest, const unsigned int destlen, uint8_t *src, const unsigned int len) { uint16_t *codetable = codetable_00; int encoding = 0; int skip = 0; // (src[0] < 0x20) ? 1 : 0; if( src[0] < 0x20 ) { encoding = src[0]; if( encoding < 12 ) codetable = codetable_LUT[encoding]; skip = 1; } if( encoding == 0x1F ) { skip = 2; } if( encoding == 0x10 ) { if( src[1] == 0 ) { codetable = codetable_0B; if( src[1] == 0 && src[2] >= 5 && src[2] <= 15 ) { codetable = codetable_LUT[src[2] - 4]; } } skip = 3; } uint32_t utf8_cc; int dest_pos = 0; int emphasis = 0; int i; for (i = skip; i < len && dest_pos < destlen - 1; i++) { utf8_cc = *(src + i); if (utf8_cc >= 128 && encoding == 0x15 ) { if( (utf8_cc & 0xC0) == 0xC0 ) { i++; utf8_cc &= 0x3F; if( utf8_cc & 0x20 ) utf8_cc &= 0x1F; if( utf8_cc & 0x10 ) utf8_cc &= 0x0F; if( utf8_cc & 0x08 ) utf8_cc &= 0x07; while( i < len && (*(src + i) & 0xC0) == 0x80 ) { utf8_cc = (utf8_cc << 6) | (*(src + i) & 0x3F); i++; } if( utf8_cc > 0x10FFFF ) break; // UTF-8 error } else break; // UTF-8 error } else { if( encoding <= 0x10 && utf8_cc >= 0x80 && utf8_cc < 0xA0 ) utf8_cc |= 0x0100; else if( utf8_cc >= 0xA0 ) { utf8_cc = codetable[utf8_cc-0xA0]; } } if( utf8_cc < 0xA0 ) { switch(utf8_cc) { case 0x00: break; case 0x01 ... 0x7F: dest[dest_pos++] = utf8_cc; break; case CHARACTER_CR_LF: dest[dest_pos++] = '\n'; break; case CHARACTER_EMPHASIS_ON: emphasis = 1; break; case CHARACTER_EMPHASIS_OFF: emphasis = 0; break; default: { if( dest_pos < destlen - 2 ) { dest[dest_pos++] = 0xC2; dest[dest_pos++] = (utf8_cc & 0x3F) | 0x80; } break; } } } else { if( utf8_cc < 0x800 ) { if( dest_pos >= destlen - 2 ) break; dest[dest_pos++] = 0xC0 | ((utf8_cc >> 6) & 0x1F); dest[dest_pos++] = (utf8_cc & 0x3F) | 0x80; } else if( utf8_cc < 0x10000 ) { if( dest_pos >= destlen - 3 ) break; dest[dest_pos++] = 0xE0 | ((utf8_cc >> 12) & 0x0F); dest[dest_pos++] = ((utf8_cc >> 6) & 0x3F) | 0x80; dest[dest_pos++] = (utf8_cc & 0x3F) | 0x80; } else if( utf8_cc < 0x110000 ) { if( dest_pos >= destlen - 4 ) break; dest[dest_pos++] = 0xF0 | ((utf8_cc >> 18) & 0x07); dest[dest_pos++] = ((utf8_cc >> 12) & 0x3F) | 0x80; dest[dest_pos++] = ((utf8_cc >> 6) & 0x3F) | 0x80; dest[dest_pos++] = (utf8_cc & 0x3F) | 0x80; } } } dest[dest_pos] = '\0'; } static void sscopy(char *b, char *a, int len) { while (len--) { if (*a > 0x20 && (*a < 0x80 || *a > 0x9f)) *b++ = *a; a++; } *b = 0; } static int sdt_cb(struct sfilter *sf) { struct pid_info *p = sf->pidi; uint8_t *buf=p->buf, tag; int c, dll, dl, d, doff; uint16_t onid, sid, tsid; struct service *s; tsid = get16(buf + 3); onid = get16(buf + 8); for (c = 11; c < p->len - 4; c += dll + 5) { int spnl, snl; sid = get16(buf + c); dll = get12(buf + c + 3); s = get_service(p->tsi->stp->tpi, sid); s->onid = onid; s->tsid = tsid; s->eit_sched = ( buf[c + 2] & 0x02 ) >> 1; s->eit_pf = ( buf[c + 2] & 0x01 ); s->ca_mode = ( buf[c + 3] & 0x10 ) >> 4; if ( p->tsi->stp->tpi->scan_eit && s->eit_sched /*&& !s->ca_mode*/ ) { int i; for ( i = 0; i < MAX_EIT_SID; i++ ) { if (p->tsi->stp->tpi->eit_sid[0] == 0 || p->tsi->stp->tpi->eit_sid[i] == sid) { eit_services += 1; add_sfilter(p->tsi, 0x12, 0x50, sid, 2, 15); break; } } } //fprintf(stderr, "sid = %04x, dll = %u\n", sid, dll); for (d = 0; d < dll; d += dl + 2) { doff = c + d + 5; tag = buf[doff]; dl = buf[doff + 1]; //fprintf(stderr, "desc %02x: %u\n", tag, dl); if (tag == 0x48) { spnl = buf[doff + 3]; snl = buf[doff + 4 + spnl]; s->pname[79] = 0x00; s->name[79] = 0x00; en300468_parse_string_to_utf8(s->pname, sizeof(s->pname), buf + doff + 4, spnl); if( s->pname[79] != 0 ) fprintf(stderr, "********************************************* PNAME OVERFLOW %d spnl = %d",spnl); en300468_parse_string_to_utf8(s->name, sizeof(s->name), buf + doff + 5 + spnl, snl); if( s->name[79] != 0 ) fprintf(stderr, "********************************************* SNAME OVERFLOW %d snl = %d",snl); s->got_sdt = 1; } } } return 0; } static int eit_cb(struct sfilter *sf,int refresh) { struct pid_info *p = sf->pidi; uint8_t *buf=p->buf, tag; uint16_t tid, onid, sid, tsid; uint8_t snr; int slen, dll, c, dl, d, doff, l; uint16_t eid,mjd,teid; struct service *s; struct event e; struct event *pe; tid = buf[0]; sid = get16(buf + 3); tsid = get16(buf + 8); onid = get16(buf + 10); snr = buf[6]; slen = get12(buf + 1) + 3; if (buf[1] & 0x80) slen -= 4; s = get_service(p->tsi->stp->tpi, sid); if ( refresh ) { fprintf(stderr,"eit_cb refresh %02X %u\n",tid,sid); struct event *npe; list_for_each_entry_safe(pe, npe, &s->events, link) { if( pe->tid == tid ) { list_del(&pe->link); free_event(pe); eit_events_deleted += 1; } } } eit_size += slen; eit_sections += 1; // fprintf(stderr, "EIT %02x %d:%d:%d %d %d\n",tid,onid,tsid,sid,snr,slen); for (c = 14; c < slen; c += dll + 12) { memset(&e, 0, sizeof(struct event)); e.tid = tid; e.sid = sid; e.tsid = tsid; e.onid = onid; e.eid = get16(buf + c + 0); e.mjd = get16(buf + c + 2); e.sh = getbcd(buf + c + 4,2); e.sm = getbcd(buf + c + 5,2); e.ss = getbcd(buf + c + 6,2); e.dh = getbcd(buf + c + 7,2); e.dm = getbcd(buf + c + 8,2); e.ds = getbcd(buf + c + 9,2); // fprintf(stderr, " Event %5d %5d Start %02d:%02d:%02d Duration %02d:%02d:%02d\n",e.eid,e.mjd,e.sh,e.sm,e.ss,e.dh,e.dm,e.ds); dll = get12(buf + c + 10); eit_events += 1; //eit_shortsize += sizeof(struct event) + 16; for (d = 0; d < dll; d += dl + 2) { doff = c + d + 12; tag = buf[doff]; dl = buf[doff + 1]; switch ( tag ) { case 0x42: // Stuffing break; case 0x4A: // linkage if ( buf[doff+8] == 0x0D ) { teid = get16(buf + doff + 9); fprintf(stderr, " LINK SID %5u EID %5u Tag %teid %5u listet = %d, simul = %d\n" ,sid,e.eid,teid,(buf[doff + 11] & 0x80) >> 7, (buf[doff + 11] & 0x80) >> 6 ); } else fprintf(stderr, " LINK SID %5u EID %5u Type 0x%02X len %d\n",sid,e.eid,buf[doff+8],slen); break; case 0x4D: // short if( dl >= 5 ) { e.s_lang[0] = buf[doff + 2]; e.s_lang[1] = buf[doff + 3]; e.s_lang[2] = buf[doff + 4]; doff += 5; l = buf[doff]; if (l > 0) { e.s_name = malloc(l+1); if( e.s_name ) { memcpy(e.s_name,buf + doff, l + 1); } } eit_shortsize += l; doff += l + 1; l = buf[doff]; if (l > 0) { e.s_text = malloc(l+1); if( e.s_text ) { memcpy(e.s_text,buf + doff, l + 1); } } eit_shortsize += l; } break; case 0x4E: // extended break; case 0x4F: // time shift break; case 0x50: // component break; case 0x53: // CA break; case 0x54: // content break; case 0x55: // parental break; case 0x57: // telephone break; case 0x5E: // multilingual break; case 0x5F: // private data break; case 0x61: // short smoothing buffer break; case 0x64: // data broadcast break; case 0x69: // private data break; case 0x75: // TVA id break; case 0x76: // content identifier break; case 0x7D: // XAIT location break; case 0x7E: // FTA content managment break; case 0x7F: // extension break; default: //fprintf(stderr, " SID %5u EID %5u Tag %02x len %d\n",sid,e.eid,tag,slen); break; } } pe = malloc(sizeof(struct event)); if (pe) { memcpy(pe,&e,sizeof(struct event)); list_add_tail(&pe->link, &s->events); } else { if (e.s_name) free(e.s_name); if (e.s_text) free(e.s_text); } } return 0; } static int all_zero_8(uint32_t *p) { return (p[0] | p[1] | p[2] | p[3] | p[4] | p[5] | p[6] | p[7]) ? 0 : 1; } static int proc_sec(struct pid_info *p) { uint8_t *buf=p->buf; uint8_t snr, vnr, lsnr, tid; struct sfilter *sf, *sfn; uint16_t ext; int i, n, res; int refresh; tid = buf[0]; ext = ((buf[3] << 8) | buf[4]); vnr = (buf[5] & 0x3f) >> 1; snr = buf[6]; lsnr = buf[7]; list_for_each_entry_safe(sf, sfn, &p->sfilters, link) { if (tid != sf->tid) continue; if (p->add_ext) { if (sf->use_ext == 2) { if (ext != sf->ext) continue; } else { sf->ext = ext; sf->use_ext = 2; } } refresh = 0; if (!sf->vnr_set) { sf->vnr = vnr; sf->vnr_set = 1; } if (sf->vnr != vnr) { fprintf(stderr, "TID %02x ext %u\n", tid, ext); fprintf(stderr, "VNR change %u->%u\n", sf->vnr, vnr); sf->todo_set = 0; sf->vnr = vnr; refresh = 1; //sf->done = 0; } if (sf->done) break; if (!sf->todo_set) { for (i = 0; i <= lsnr; i++) sf->todo[i >> 5] |= (1UL << (i & 31)); sf->todo_set = 1; if (tid == 0x50 || tid == 0x60) { uint8_t ltid = buf[13] & 0x0F; for (i = 1; i <= ltid; i++) { add_sfilter(p->tsi, 0x12, tid + i, sf->ext, 2, i < 2 ? 15 : 45); } } } if ( sf->todo[snr >> 5] & (1UL << (snr & 31)) ) { switch (tid) { case 0x00: res = pat_cb(sf); break; case 0x02: res = pmt_cb(sf); break; case 0x40: case 0x41: res = nit_cb(sf); break; case 0x42: case 0x46: res = sdt_cb(sf); break; default: if (tid >= 0x4E && tid <= 0x6F) res = eit_cb(sf, refresh); else res = -1; break; } if (res == 0) { sf->todo[snr >> 5] &= ~(1UL << (snr & 31)); if (tid >= 0x4E && tid <= 0x6F) { uint8_t slsnr = buf[12]; for (i = slsnr + 1; i <= (slsnr | 7); i++) sf->todo[i >> 5] &= ~(1UL << (i & 31)); //fprintf(stderr, " %08x%08x%08x%08x%08x%08x%08x%08x\n", // sf->todo[7],sf->todo[6],sf->todo[5],sf->todo[4],sf->todo[3],sf->todo[2],sf->todo[1],sf->todo[0]); } if (all_zero_8(sf->todo)) { sf->done = 1; list_del(&sf->tslink); } else sf->timeout = mtime(NULL) + sf->timeout_len; break; } } } if (&sf->link == &p->sfilters) return -1; return 0; } static int pid_info_proc_section(struct pid_info *p) { struct sfilter *sf, *sfn; uint8_t *buf = p->buf; uint8_t tid; uint16_t ext; int res; if (p->bufp != p->len) { if (p->len && p->bufp > p->len) goto exit; return 0; } if (buf[1] & 0x80) { if (dvb_crc32(buf, p->len)) { fprintf(stderr, "CRC error pid %04x!\n", p->pid); goto exit; } } //fprintf(stderr, "PID %04x SEC[%d]: %02x\n", (int) p->pid, p->len, (int)p->buf[0]); if (p->len < 8) return 0; if (!(buf[5] & 1)) return 0; tid = buf[0]; ext = ((buf[3] << 8) | buf[4]); res = proc_sec(p); if (res && p->add_ext) { if (tid == 0x42 || tid == 0x02) { fprintf(stderr, "section not matched"); fprintf(stderr, "adding %02x:%04x\n", tid, ext); //add_sfilter(p->tsi, p->pid, tid, ext, 1, 5); //proc_sec(p); } } exit: pid_info_reset(p); return 0; } /****************************************************************************/ /****************************************************************************/ static inline void write_secbuf(struct pid_info *p, uint8_t *tsp, int n) { memcpy(p->buf+p->bufp, tsp, n); p->bufp += n; } static inline int validcc(struct pid_info *p, uint8_t *tsp) { uint8_t newcc; int valid; newcc = tsp[3] & 0x0f; valid = (((p->cc + 1) & 0x0f) == newcc) ? 1 : 0; if (p->cc == 0xff) valid=1; p->cc = newcc; if (!valid) { fprintf(stderr, "CC error PID %04x!\n", p->pid); pid_info_reset(p); } return valid; } static inline int pid_info_build_section(struct pid_info *p, uint8_t *tsp) { int pusoff, todo = tspayload(tsp), i = 188 - todo; if (!todo) return -1; pusoff = (tsp[1] & 0x40) ? tsp[i++] : todo; if (pusoff + i > 188) goto error; if (validcc(p, tsp) && pusoff && p->bufp) { int rlen = pusoff; if (p->len) { if (p->bufp + rlen > p->len) rlen = p->len - p->bufp; } else if (p->bufp + rlen > 4096) rlen = 4096 - p->bufp; write_secbuf(p, tsp + i, rlen); if (!p->len && p->bufp >= 3 && (p->len = seclen(p->buf)) > 4096) pid_info_reset(p); else pid_info_proc_section(p); } i += pusoff; while ((todo = 188 - i) > 0 && tsp[i] != 0xff) { pid_info_reset(p); if (todo < 3) fprintf(stderr, "sec start <3 \n"); if (todo < 3 || (p->len = seclen(tsp+i)) > todo) { if (p->len > 4096) goto error; write_secbuf(p, tsp+i, todo); i+=todo; } else { write_secbuf(p, tsp+i, p->len); i+=p->len; pid_info_proc_section(p); } } return 0; error: fprintf(stderr, "error\n"); pid_info_reset(p); return -1; } /****************************************************************************/ void proc_tsp(struct ts_info *tsi, uint8_t *tsp) { uint16_t pid = 0x1fff & ((tsp[1] << 8) | tsp[2]); struct pid_info *pidi = &tsi->pidi[pid]; if (!pidi->used) return; if (!pidi->buf) { pidi->buf = malloc(4096); if (!pidi->buf) return; pidi->cc = 0xff; } pid_info_build_section(pidi, tsp); } void proc_tsps(struct ts_info *tsi, uint8_t *tsp, uint32_t len) { time_t mt = mtime(NULL); struct sfilter *sf, *sfn; list_for_each_entry_safe(sf, sfn, &tsi->sfilters, tslink) { if (sf->done || mt > sf->timeout) { sf->done = 1; list_del(&sf->tslink); } } if (list_empty(&tsi->sfilters)) tsi->done = 1; #if 0 if (list_empty(&tsi->sfilters)) { if (mt > tsi->timeout) tsi->done = 1; } else tsi->timeout = mt + 1; #endif while (len >= 188) { proc_tsp(tsi, tsp); tsp += 188; len -= 188; } } /****************************************************************************/ /****************************************************************************/ // Valid till 28.2.2100 static void get_date_from_mjd(uint16_t mjd, uint16_t *y, uint8_t *m, uint8_t *d) { static int dm[] = {31,30,31,30,31,31,30,31,30,31,31,28}; int i,p,r; r = mjd - 51604; // 0 = 1.3.2000 if (r < 0) r += 65536; p = r / (365*4+1); r = r - p * (365*4+1); *y = p * 4 + 2000; p = r / 365; r = r - p * 365; //~ fprintf(stderr, " %d,%d\n",p,r); *y += p; if (p < 4) { for (i = 0; i < 12; i += 1) { *m = i < 10 ? i + 3 : i - 9; if (r < dm[i]) { *d = r + 1; if ( i >= 10 ) *y += 1; break; } r -= dm[i]; } } else { *m = 2; *d = 29; } } static void print_events(struct tp_info *tpi) { struct service *s; struct event *e; char t[768]; int i; uint16_t y; uint8_t m,d; list_for_each_entry(s, &tpi->services, link) { list_for_each_entry(e, &s->events, link) { printf("EVENT\n"); printf(" ID:%d:%d:%d:%d\n", e->onid, e->tsid, e->sid, e->eid); get_date_from_mjd(e->mjd,&y,&m,&d); printf(" TIME:%04d-%02d-%02dT%02d:%02d:%02dZ\n", y, m, d, e->sh, e->sm, e->ss); printf(" DUR:%02d:%02d:%02d\n", e->dh, e->dm, e->ds); for ( i = 0; i < 3; i += 1) { if( e->s_lang[i] < 0x20 || e->s_lang[i] >= 0x7F ) e->s_lang[i] = '?'; } printf(" LANG:%c%c%c\n", e->s_lang[0], e->s_lang[1], e->s_lang[2]); if( e->s_name ) { en300468_parse_string_to_utf8(t,sizeof(t),&e->s_name[1],e->s_name[0]); printf(" NAME:%s\n",t); } if( e->s_text ) { en300468_parse_string_to_utf8(t,sizeof(t),&e->s_text[1],e->s_text[0]); printf(" TEXT:%s\n",t); } printf("END\n"); } } } static void print_services(struct tp_info *tpi) { struct service *s; int i; list_for_each_entry(s, &tpi->services, link) { if (s->got_pmt && (s->vpid != 0 || s->anum>0)) { printf("SERVICE\n"); printf(" PNAME:%s\n",s->pname); printf(" SNAME:%s\n",s->name); printf(" ONID:%d\n",s->onid); printf(" TSID:%d\n",s->tsid); printf(" SID:%d\n",s->sid); printf(" PIDS:%d",s->pmt); uint16_t pcr = s->pcr; if (s->pmt == pcr) pcr = 0; if (s->vpid != 0 ) { printf(",%d",s->vpid); if (s->vpid == pcr) pcr = 0; } for (i= 0; i < s->anum; i+=1) { if (s->apid[i] != 0 ) { printf(",%d",s->apid[i]); if (s->apid[i] == pcr) pcr = 0; } } if (s->sub != 0 ) { printf(",%d",s->sub); if (s->sub == pcr) pcr = 0; } if (s->ttx != 0 ) { printf(",%d",s->ttx); if (s->ttx == pcr) pcr = 0; } if (pcr != 0) { printf(",%d",pcr); } printf("\n"); if (s->anum > 0 && s->apid[0] != 0) { printf(" APIDS:%d",s->apid[0]); for (i= 1; i < s->anum; i+=1) { if (s->apid[i] != 0 ) { printf(",%d",s->apid[i]); } } } printf("\n"); if ( s->vpid == 0 ) printf(" RADIO:1\n"); if ( s->ca_mode ) printf(" ENC:1\n"); printf(" EIT:%d%d\n",s->eit_pf,s->eit_sched); printf("END\n"); fflush(stdout); } //~ if (!s->got_pmt) //~ fprintf(stderr, "NO PMT: "); //~ fprintf(stderr, "%s:%s sid=%04x pmt=%04x pcr=%04x vpid=%04x apid=%04x\n", //~ s->pname, s->name, s->sid, s->pmt, s->pcr, s->vpid, s->apid[0]); } } static int scan_tp(struct scantp *stp) { struct scanip *sip= stp->sip; struct satipcon *scon = &stp->scon; fd_set fds; struct timeval timeout; int mfd, num, n; time_t t, u; char buf[2048]; struct sockaddr sadr; char *a; int rbuf = 1024 * 1024; scon->seq = 0; scon->usock = udpsock(&sadr, "0"); if (scon->usock < 0) { fprintf(stderr, "Could not get UDP socket\n"); return -1; } //setsockopt(usock, SOL_SOCKET, SO_RCVBUF, &rbuf, sizeof(rbuf)); scon->nsport = 0;//strtoul(sport, NULL, 10); if (scon->nsport == 0) { struct sockaddr_in sin; socklen_t len = sizeof(sin); getsockname(scon->usock, (struct sockaddr*) &sin, &len); scon->nsport = ntohs(sin.sin_port); } //fprintf(stderr, "Socket port = %u\n", scon->nsport); //fprintf(stderr, "host = %s, port = %s\n", scon->host, scon->port); scon->sock = streamsock(scon->host, scon->port, &sadr); if (scon->sock < 0) return scon->sock; send_setup(scon->sock, scon->host, scon->port, scon->tune, &scon->seq, scon->nsport, 0); if (check_ok(scon->sock, scon->sid, &scon->strid) < 0) return 0; update_pids(&stp->tsi); if (check_ok(scon->sock, scon->sid, &scon->strid) < 0) return 0; add_sfilter(&stp->tsi, 0x00, 0x00, 0, 0, 5); add_sfilter(&stp->tsi, 0x11, 0x42, 0, 1, 5); stp->timeout = mtime(NULL) + 10; while (!done && !stp->tsi.done && mtime(NULL) < stp->timeout) { mfd = 0; timeout.tv_sec = 1; timeout.tv_usec = 0; FD_ZERO(&fds); add_fd(scon->sock, &mfd, &fds); add_fd(scon->usock, &mfd, &fds); num = select(mfd + 1, &fds, NULL, NULL, &timeout); if (num < 0) break; if (FD_ISSET(scon->sock, &fds)) { n = recv(scon->sock, buf, sizeof(buf), 0); //dump(buf, n); } if (FD_ISSET(scon->usock, &fds)) { n = recvfrom(scon->usock, buf, sizeof(buf), 0, 0, 0); if (n > 12) { proc_tsps(&sip->stp.tsi, buf + 12, n - 12); // stp->timeout = mtime(NULL) + 10; stp->timeout += 60; } } } if( stp->tpi->scan_eit ) print_events(stp->tpi); else print_services(stp->tpi); a = 0; send_teardown(scon->sock, scon->host, scon->port, scon->strid, &scon->seq, scon->sid); close(scon->sock); } void tpstring(struct tp_info *tpi, char *s, int slen) { int len; switch (tpi->msys) { case 1: if( tpi->freq_frac ) len = snprintf(s, slen, "freq=%u.%04u&msys=dvbc&sr=%u&mtype=%s", tpi->freq, tpi->freq_frac, tpi->sr, mtype2str[tpi->mod]); else len = snprintf(s, slen, "freq=%u&msys=dvbc&sr=%u&mtype=%s", tpi->freq, tpi->sr, mtype2str[tpi->mod]); break; case 2: if( tpi->freq_frac ) len = snprintf(s, slen, "freq=%u.%04u&msys=dvbt&bw=%s", tpi->freq, tpi->freq_frac, bw2str[tpi->bw]); else len = snprintf(s, slen, "freq=%u&msys=dvbt&bw=%s", tpi->freq, bw2str[tpi->bw]); break; case 5: case 6: len = snprintf(s, slen, "src=%u&freq=%u&pol=%s&msys=%s&sr=%u", tpi->src,tpi->freq, pol2str[tpi->pol&3], msys2str[tpi->msys], tpi->sr); break; case 16: if( tpi->freq_frac ) len = snprintf(s, slen, "freq=%u.%04u&msys=dvbt2&bw=%s&plp=%u", tpi->freq, tpi->freq_frac, bw2str[tpi->bw], tpi->isi); else len = snprintf(s, slen, "freq=%u&msys=dvbt2&bw=%s&plp=%u", tpi->freq, bw2str[tpi->bw], tpi->isi); break; } } static int scanip(struct scanip *sip) { struct scantp *stp; struct ts_info *tsi; struct tp_info *tpi; while (!done && !list_empty(&sip->tps)) { stp = &sip->stp; memset(stp, 0, sizeof(struct scantp)); tsi = &stp->tsi; ts_info_init(tsi); stp->sip = sip; stp->scon.port = "554"; stp->scon.host = sip->host; tsi->stp = stp; tpi = list_first_entry(&sip->tps, struct tp_info, link); tpstring(tpi, &stp->scon.tune[0], sizeof(stp->scon.tune)); printf("\nTUNE:%s\n", stp->scon.tune); fflush(stdout); stp->tpi = tpi; scan_tp(stp); ts_info_release(tsi); list_del(&tpi->link); list_add(&tpi->link, &sip->tps_done); } } void term_action(int sig, siginfo_t *si, void *d) { done = 1; } void scanip_init(struct scanip *sip, char *host) { list_head_init(&sip->tps); list_head_init(&sip->tps_done); sip->done = 0; sip->host = host; } void scanip_release(struct scanip *sip) { struct tp_info *p, *n; list_for_each_entry_safe(p, n, &sip->tps, link) { list_del(&p->link); free_tp_info(p); } list_for_each_entry_safe(p, n, &sip->tps_done, link) { list_del(&p->link); free_tp_info(p); } } void scan_cable(struct scanip *sip) { struct tp_info tpi = { .freq = 130, .msys = 1, .mod = 5, }; uint32_t f, m; for (f = 114; f < 800; f += 8) for (m = 5; m < 6; m += 2) { tpi.freq = f; tpi.mod = m; add_tp(sip, &tpi); } } void usage() { printf("Octoscan" ", Copyright (C) 2016 Digital Devices GmbH\n\n"); printf("octoscan [options] \n"); printf(" address of SAT>IP server\n"); printf("\n"); printf(" options:\n"); printf(" --use_nit, -n\n"); printf(" Use network information table\n"); printf(" if not specified only a single transponder is scanned\n"); printf(" --freq=, -f \n"); printf(" frequency in MHz (required)\n"); printf(" --src=, -S \n"); printf(" satellite source 1,2,3,4 (required for DVB-S/S2)\n"); printf(" --sr=, -s \n"); printf(" symbolrate in kSymbols (required for DVB-S/S2 and DVB-C)\n"); printf(" DVB-S/S2 example: --sr=27500\n"); printf(" DVB-C example: --sr=6900\n"); printf(" --bw=, -b \n"); printf(" bandwidth 1.712,5,6,7,8,10 (required for DVB-T/T2)\n"); printf(" --pol=, -p \n"); printf(" polarisation = v,h,r,l (required for DVB-S/S2)\n"); printf(" example: --pol=v\n"); printf(" --msys=, -m \n"); printf(" system = dvbs,dvbs2,dvbc,dvbt,dvbt2 (required)\n"); printf(" example: --msys=dvbs\n"); printf(" --mtype=, -t \n"); printf(" modulation type = 16qam,32qam,64qam,128qam,256qam (required for DVB-C)\n"); printf(" --eit, -e\n"); printf(" Do an EIT scan\n"); printf(" --eit_sid=, -e \n"); printf(" sid list = comma separated list of sid numbers\n"); printf(" example: --eit_sid=1000,1002,3003\n"); printf(" --help, -?\n"); printf("\n"); printf(" Notes on NIT scanning:\n"); printf(" With some cable providers or inhouse retransmission systems\n"); printf(" it may be not usable, i.e. due to wrong frequencies in the NIT.\n"); printf("\n"); printf(" Notes on hardware depencies:\n"); printf(" Depending on hardware configuration the scan will succeed even if\n"); printf(" some required parameters are wrong. This will result in a channel list\n"); printf(" which is usable only on the same hardware configuration.\n"); printf("\n"); printf(" Example: NIT based scan which should work on Unitymedia in Germany\n"); printf(" octoscan --use_nit --freq=138 --msys=dvbc --sr=6900 --mtype=256qam 10.0.4.24\n"); } int main(int argc, char **argv) { struct sigaction term; struct scanip sip; struct tp_info tpi; int i; #if 0 struct tp_info tpi1 = { .freq = 11836, .pol = 1, .msys = 5, .sr = 27500, }; struct tp_info tpi2 = { .freq = 11914, .pol = 1, .msys = 6, .sr = 27500, }; struct tp_info tpi3 = { .freq = 138, .msys = 1, .mod = 5, .sr = 6900, }; struct tp_info tpi4 = { .freq = 410, .msys = 1, .mod = 5, .sr = 6900, }; #endif if(argc < 2) { usage(); exit(0); }; memset(&tpi, 0, sizeof(struct tp_info)); while (1) { int option_index = 0; int c; static struct option long_options[] = { {"use_nit", no_argument, 0, 'n'}, {"freq", required_argument, 0, 'f'}, {"sr", required_argument, 0, 's'}, {"src", required_argument, 0, 'S'}, {"pol", required_argument, 0, 'p'}, {"bw", required_argument, 0, 'b'}, {"plp", required_argument, 0, 'P'}, {"msys", required_argument, 0, 'm'}, {"mtype", required_argument, 0, 't'}, {"eit", no_argument, 0, 'e'}, {"eit_sid", required_argument, 0, 'E'}, {"help", no_argument , 0, '?'}, {0, 0, 0, 0} }; c = getopt_long(argc, argv, "nf:s:S:p:b:P:m:t:e:x:?", long_options, &option_index); if (c==-1) break; switch (c) { case 'x': { uint16_t mjd = strtoul(optarg, NULL, 10); uint16_t y; uint8_t m,d; get_date_from_mjd(mjd,&y,&m,&d); printf(" Date = %02d.%02d.%02d\n",d,m,y); return(0); } break; case 'n': tpi.use_nit = 1; break; case 'e': tpi.scan_eit = 1; break; case 'E': { char *p = optarg; char *pn = p; tpi.scan_eit = 1; for (i = 0; i < MAX_EIT_SID; i++) { if (tpi.eit_sid[i] == 0) { tpi.eit_sid[i] = strtoul(p, &pn, 10); if ( *pn != ',' ) break; p = pn + 1; } } if ( p == pn ) fprintf(stderr,"Invalid arg to --eit %s",optarg); } break; case 'f': tpi.freq = strtoul(optarg, NULL, 10); break; case 's': tpi.sr = strtoul(optarg, NULL, 10); break; case 'S': tpi.src = strtoul(optarg, NULL, 10); break; case 'p': i = 0; while( pol2str[i] ) { if( strcmp(optarg,pol2str[i]) == 0 ) { tpi.pol = i; break; } i += 1; } break; case 'b': i = 0; while( bw2str[i] ) { if( strcmp(optarg,bw2str[i]) == 0 ) { tpi.bw = i; break; } i += 1; } break; case 'P': tpi.isi = strtoul(optarg, NULL, 10); if( tpi.isi > 255 ) tpi.isi = 0; break; case 'm': i = 0; while( msys2str[i] ) { if( strcmp(optarg,msys2str[i]) == 0 ) { tpi.msys = i; break; } i += 1; } break; case 't': i = 0; while( mtype2str[i] ) { if( strcmp(optarg,mtype2str[i]) == 0 ) { tpi.mod = i; break; } i += 1; } break; case '?': usage(); exit(0); default: break; } } if( optind != argc - 1 ) { printf("wrong number of arguments\n\n"); usage(); exit(-1); } memset(&term, 0, sizeof(term)); term.sa_sigaction = term_action; sigemptyset(&term.sa_mask); term.sa_flags = 0; sigaction(SIGINT, &term, NULL); scanip_init(&sip, argv[optind]); add_tp(&sip, &tpi); //scan_cable(&sip); scanip(&sip); scanip_release(&sip); fprintf(stderr, "EIT Total size: %d Short size: %d\n",eit_size, eit_shortsize); fprintf(stderr, " Services: %d Sections: %d Events: %d (%d deleted)\n", eit_services, eit_sections, eit_events - eit_events_deleted, eit_events_deleted); }