aboutsummaryrefslogtreecommitdiffstats
path: root/test/libucsi/testucsi.c
diff options
context:
space:
mode:
authoretobi <git@e-tobi.net>2013-09-03 09:48:41 +0200
committeretobi <git@e-tobi.net>2013-09-03 09:48:41 +0200
commitab959d7b4194715870128e616b8e29d4a101e488 (patch)
tree61a746231d30817be73416a7d67763fd677a1042 /test/libucsi/testucsi.c
parent6b350466c4902c5b137e0efaf1d189128a7f18f5 (diff)
downloadlinux-dvb-apps-ab959d7b4194715870128e616b8e29d4a101e488.tar.gz
Imported Upstream version 1.1.1+rev1207upstream/1.1.1+rev1207
Diffstat (limited to '')
-rw-r--r--test/libucsi/testucsi.c3528
1 files changed, 3528 insertions, 0 deletions
diff --git a/test/libucsi/testucsi.c b/test/libucsi/testucsi.c
new file mode 100644
index 0000000..e0a16c1
--- /dev/null
+++ b/test/libucsi/testucsi.c
@@ -0,0 +1,3528 @@
+/*
+ * section and descriptor parser test/sample application.
+ *
+ * Copyright (C) 2005 Andrew de Quincey (adq_dvb@lidskialf.net)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <libucsi/mpeg/descriptor.h>
+#include <libucsi/mpeg/section.h>
+#include <libucsi/dvb/descriptor.h>
+#include <libucsi/dvb/section.h>
+#include <libucsi/atsc/descriptor.h>
+#include <libucsi/atsc/section.h>
+#include <libucsi/transport_packet.h>
+#include <libucsi/section_buf.h>
+#include <libucsi/dvb/types.h>
+#include <libdvbapi/dvbdemux.h>
+#include <libdvbapi/dvbfe.h>
+#include <libdvbcfg/dvbcfg_zapchannel.h>
+#include <libdvbsec/dvbsec_api.h>
+#include <libdvbsec/dvbsec_cfg.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <fcntl.h>
+
+void receive_data(int dvrfd, int timeout, int data_type);
+void parse_section(uint8_t *buf, int len, int pid, int data_type);
+void parse_dvb_section(uint8_t *buf, int len, int pid, int data_type, struct section *section);
+void parse_atsc_section(uint8_t *buf, int len, int pid, int data_type, struct section *section);
+void parse_descriptor(struct descriptor *d, int indent, int data_type);
+void parse_dvb_descriptor(struct descriptor *d, int indent, int data_type);
+void parse_atsc_descriptor(struct descriptor *d, int indent, int data_type);
+void iprintf(int indent, char *fmt, ...);
+void hexdump(int indent, char *prefix, uint8_t *buf, int buflen);
+void atsctextdump(char *header, int indent, struct atsc_text *atext, int len);
+int channels_cb(struct dvbcfg_zapchannel *channel, void *private);
+void ts_from_file(char *filename, int data_type);
+
+#define TIME_CHECK_VAL 1131835761
+#define DURATION_CHECK_VAL 5643
+
+#define MAX_TUNE_TIME 3000
+#define MAX_DUMP_TIME 60
+
+#define DATA_TYPE_MPEG 0
+#define DATA_TYPE_DVB 1
+#define DATA_TYPE_ATSC 2
+
+
+struct dvbfe_handle *fe;
+struct dvbfe_info feinfo;
+int demuxfd;
+int dvrfd;
+
+int main(int argc, char *argv[])
+{
+ int adapter;
+ char *channelsfile;
+ int pidlimit = -1;
+ dvbdate_t dvbdate;
+ dvbduration_t dvbduration;
+
+ // process arguments
+ if ((argc < 3) || (argc > 4)) {
+ fprintf(stderr, "Syntax: testucsi <adapter id>|-atscfile <filename> <zapchannels file> [<pid to limit to>]\n");
+ exit(1);
+ }
+ if (!strcmp(argv[1], "-atscfile")) {
+ ts_from_file(argv[2], DATA_TYPE_ATSC);
+ exit(0);
+ }
+ adapter = atoi(argv[1]);
+ channelsfile = argv[2];
+ if (argc == 4)
+ sscanf(argv[3], "%i", &pidlimit);
+ printf("Using adapter %i\n", adapter);
+
+ // check the dvbdate conversion functions
+ unixtime_to_dvbdate(TIME_CHECK_VAL, dvbdate);
+ if (dvbdate_to_unixtime(dvbdate) != TIME_CHECK_VAL) {
+ fprintf(stderr, "XXXX dvbdate function check failed (%i!=%i)\n",
+ TIME_CHECK_VAL, (int) dvbdate_to_unixtime(dvbdate));
+ exit(1);
+ }
+ seconds_to_dvbduration(DURATION_CHECK_VAL, dvbduration);
+ if (dvbduration_to_seconds(dvbduration) != DURATION_CHECK_VAL) {
+ fprintf(stderr, "XXXX dvbduration function check failed (%i!=%i)\n",
+ DURATION_CHECK_VAL, (int) dvbduration_to_seconds(dvbduration));
+ exit(1);
+ }
+
+ // open the frontend
+ if ((fe = dvbfe_open(adapter, 0, 0)) == NULL) {
+ perror("open frontend");
+ exit(1);
+ }
+ dvbfe_get_info(fe, 0, &feinfo, DVBFE_INFO_QUERYTYPE_IMMEDIATE, 0);
+ int data_type = DATA_TYPE_MPEG;
+ switch(feinfo.type) {
+ case DVBFE_TYPE_DVBS:
+ case DVBFE_TYPE_DVBC:
+ case DVBFE_TYPE_DVBT:
+ data_type = DATA_TYPE_DVB;
+ break;
+
+ case DVBFE_TYPE_ATSC:
+ data_type = DATA_TYPE_ATSC;
+ break;
+ }
+
+ // open demux devices
+ if ((demuxfd = dvbdemux_open_demux(adapter, 0, 0)) < 0) {
+ perror("demux");
+ exit(1);
+ }
+ if ((dvrfd = dvbdemux_open_dvr(adapter, 0, 1, 1)) < 0) {
+ perror("dvr");
+ exit(1);
+ }
+
+ // make the demux buffer a bit larger
+ if (dvbdemux_set_buffer(demuxfd, 1024*1024)) {
+ perror("set buffer");
+ exit(1);
+ }
+
+ // setup filter to capture stuff
+ if (dvbdemux_set_pid_filter(demuxfd, pidlimit, DVBDEMUX_INPUT_FRONTEND, DVBDEMUX_OUTPUT_DVR, 1)) {
+ perror("set pid filter");
+ exit(1);
+ }
+
+ // process all the channels
+ FILE *channels = fopen(channelsfile, "r");
+ if (channels == NULL) {
+ fprintf(stderr, "Unable to open %s\n", channelsfile);
+ exit(1);
+ }
+ dvbcfg_zapchannel_parse(channels, channels_cb, (void*) (long) data_type);
+ return 0;
+}
+
+void ts_from_file(char *filename, int data_type) {
+ int fd = open(filename, O_RDONLY);
+ if (fd < 0) {
+ fprintf(stderr, "Unable to open file %s\n", filename);
+ exit(1);
+ }
+ receive_data(fd, 1000000000, data_type);
+}
+
+int channels_cb(struct dvbcfg_zapchannel *channel, void *private)
+{
+ long data_type = (long) private;
+ struct dvbsec_config sec;
+
+ if (dvbsec_cfg_find(NULL, "UNIVERSAL", &sec)) {
+ fprintf(stderr, "Unable to find SEC id\n");
+ exit(1);
+ }
+
+ if (dvbsec_set(fe,
+ &sec,
+ channel->polarization,
+ DISEQC_SWITCH_UNCHANGED,
+ DISEQC_SWITCH_UNCHANGED,
+ &channel->fe_params,
+ MAX_TUNE_TIME)) {
+ fprintf(stderr, "Failed to lock!\n");
+ } else {
+ printf("Tuned successfully!\n");
+ receive_data(dvrfd, MAX_DUMP_TIME, data_type);
+ }
+
+ return 0;
+}
+
+void receive_data(int _dvrfd, int timeout, int data_type)
+{
+ unsigned char databuf[TRANSPORT_PACKET_LENGTH*20];
+ int sz;
+ int pid;
+ int i;
+ int used;
+ int section_status;
+ time_t starttime;
+ unsigned char continuities[TRANSPORT_MAX_PIDS];
+ struct section_buf *section_bufs[TRANSPORT_MAX_PIDS];
+ struct transport_packet *tspkt;
+ struct transport_values tsvals;
+
+ // process the data
+ starttime = time(NULL);
+ memset(continuities, 0, sizeof(continuities));
+ memset(section_bufs, 0, sizeof(section_bufs));
+ while((time(NULL) - starttime) < timeout) {
+ // got some!
+ if ((sz = read(_dvrfd, databuf, sizeof(databuf))) < 0) {
+ if (errno == EOVERFLOW) {
+ fprintf(stderr, "data overflow!\n");
+ continue;
+ } else if (errno == EAGAIN) {
+ usleep(100);
+ continue;
+ } else {
+ perror("read error");
+ exit(1);
+ }
+ }
+ for(i=0; i < sz; i+=TRANSPORT_PACKET_LENGTH) {
+ // parse the transport packet
+ tspkt = transport_packet_init(databuf + i);
+ if (tspkt == NULL) {
+ fprintf(stderr, "XXXX Bad sync byte\n");
+ continue;
+ }
+ pid = transport_packet_pid(tspkt);
+
+ // extract all TS packet values even though we don't need them (to check for
+ // library segfaults etc)
+ if (transport_packet_values_extract(tspkt, &tsvals, 0xffff) < 0) {
+ fprintf(stderr, "XXXX Bad packet received (pid:%04x)\n", pid);
+ continue;
+ }
+
+ // check continuity
+ if (transport_packet_continuity_check(tspkt,
+ tsvals.flags & transport_adaptation_flag_discontinuity,
+ continuities + pid)) {
+ fprintf(stderr, "XXXX Continuity error (pid:%04x)\n", pid);
+ continuities[pid] = 0;
+ if (section_bufs[pid] != NULL) {
+ section_buf_reset(section_bufs[pid]);
+ }
+ continue;
+ }
+
+ // allocate section buf if we don't have one already
+ if (section_bufs[pid] == NULL) {
+ section_bufs[pid] = (struct section_buf*)
+ malloc(sizeof(struct section_buf) + DVB_MAX_SECTION_BYTES);
+ if (section_bufs[pid] == NULL) {
+ fprintf(stderr, "Failed to allocate section buf (pid:%04x)\n", pid);
+ exit(1);
+ }
+ section_buf_init(section_bufs[pid], DVB_MAX_SECTION_BYTES);
+ }
+
+ // process the payload data as a section
+ while(tsvals.payload_length) {
+ used = section_buf_add_transport_payload(section_bufs[pid],
+ tsvals.payload,
+ tsvals.payload_length,
+ tspkt->payload_unit_start_indicator,
+ &section_status);
+ tspkt->payload_unit_start_indicator = 0;
+ tsvals.payload_length -= used;
+ tsvals.payload += used;
+
+ if (section_status == 1) {
+ parse_section(section_buf_data(section_bufs[pid]),
+ section_bufs[pid]->len, pid, data_type);
+ section_buf_reset(section_bufs[pid]);
+ } else if (section_status < 0) {
+ // some kind of error - just discard
+ fprintf(stderr, "XXXX bad section %04x %i\n",pid, section_status);
+ section_buf_reset(section_bufs[pid]);
+ }
+ }
+ }
+ }
+}
+
+void parse_section(uint8_t *buf, int len, int pid, int data_type)
+{
+ struct section *section;
+ struct section_ext *section_ext = NULL;
+
+ if ((section = section_codec(buf, len)) == NULL) {
+ return;
+ }
+
+ switch(section->table_id) {
+ case stag_mpeg_program_association:
+ {
+ struct mpeg_pat_section *pat;
+ struct mpeg_pat_program *cur;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode PAT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((pat = mpeg_pat_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX PAT section decode error\n");
+ return;
+ }
+ printf("SCT transport_stream_id:0x%04x\n", mpeg_pat_section_transport_stream_id(pat));
+ mpeg_pat_section_programs_for_each(pat, cur) {
+ printf("\tSCT program_number:0x%04x pid:0x%04x\n", cur->program_number, cur->pid);
+ }
+ break;
+ }
+
+ case stag_mpeg_conditional_access:
+ {
+ struct mpeg_cat_section *cat;
+ struct descriptor *curd;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode CAT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((cat = mpeg_cat_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX CAT section decode error\n");
+ return;
+ }
+ mpeg_cat_section_descriptors_for_each(cat, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ break;
+ }
+
+ case stag_mpeg_program_map:
+ {
+ struct mpeg_pmt_section *pmt;
+ struct descriptor *curd;
+ struct mpeg_pmt_stream *cur_stream;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode PMT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((pmt = mpeg_pmt_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX PMT section decode error\n");
+ return;
+ }
+ printf("SCT program_number:0x%04x pcr_pid:0x%02x\n", mpeg_pmt_section_program_number(pmt), pmt->pcr_pid);
+ mpeg_pmt_section_descriptors_for_each(pmt, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ mpeg_pmt_section_streams_for_each(pmt, cur_stream) {
+ printf("\tSCT stream_type:0x%02x pid:0x%04x\n", cur_stream->stream_type, cur_stream->pid);
+ mpeg_pmt_stream_descriptors_for_each(cur_stream, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_mpeg_transport_stream_description:
+ {
+ struct mpeg_tsdt_section *tsdt;
+ struct descriptor *curd;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode TSDT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((tsdt = mpeg_tsdt_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX TSDT section decode error\n");
+ return;
+ }
+ mpeg_tsdt_section_descriptors_for_each(tsdt, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ case stag_mpeg_metadata:
+ {
+ struct mpeg_metadata_section *metadata;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode metadata (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((metadata = mpeg_metadata_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX metadata section decode error\n");
+ return;
+ }
+ printf("SCT random_access_indicator:%i decoder_config_flag:%i fragment_indicator:%i service_id:%02x\n",
+ mpeg_metadata_section_random_access_indicator(metadata),
+ mpeg_metadata_section_decoder_config_flag(metadata),
+ mpeg_metadata_section_fragment_indicator(metadata),
+ mpeg_metadata_section_service_id(metadata));
+ hexdump(0, "SCT ", mpeg_metadata_section_data(metadata), mpeg_metadata_section_data_length(metadata));
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ case stag_mpeg_iso14496_scene_description:
+ case stag_mpeg_iso14496_object_description:
+ {
+ struct mpeg_odsmt_section *odsmt;
+ struct mpeg_odsmt_stream *cur_stream;
+ struct descriptor *curd;
+ int _index;
+ uint8_t *objects;
+ size_t objects_length;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode ISO14496 (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((odsmt = mpeg_odsmt_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "XXXX ISO14496 section decode error\n");
+ return;
+ }
+ printf("SCT PID:0x%04x\n", mpeg_odsmt_section_pid(odsmt));
+ mpeg_odsmt_section_streams_for_each(osdmt, cur_stream, _index) {
+ if (odsmt->stream_count == 0) {
+ printf("\tSCT SINGLE 0x%04x\n", cur_stream->u.single.esid);
+ } else {
+ printf("\tSCT MULTI 0x%04x 0x%02x\n", cur_stream->u.multi.esid, cur_stream->u.multi.fmc);
+ }
+ mpeg_odsmt_stream_descriptors_for_each(osdmt, cur_stream, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ objects = mpeg_odsmt_section_object_descriptors(odsmt, &objects_length);
+ if (objects == NULL) {
+ printf("SCT XXXX OSDMT parse error\n");
+ break;
+ }
+ hexdump(1, "SCT ", objects, objects_length);
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ default:
+ switch(data_type) {
+ case DATA_TYPE_DVB:
+ parse_dvb_section(buf, len, pid, data_type, section);
+ break;
+
+ case DATA_TYPE_ATSC:
+ parse_atsc_section(buf, len, pid, data_type, section);
+ break;
+
+ default:
+ fprintf(stderr, "SCT XXXX Unknown table_id:0x%02x (pid:0x%04x)\n",
+ section->table_id, pid);
+// hexdump(0, "SCT ", buf, len);
+ return;
+ }
+ }
+
+ printf("\n");
+}
+
+void parse_dvb_section(uint8_t *buf, int len, int pid, int data_type, struct section *section)
+{
+ struct section_ext *section_ext = NULL;
+
+ switch(section->table_id) {
+ case stag_dvb_network_information_actual:
+ case stag_dvb_network_information_other:
+ {
+ struct dvb_nit_section *nit;
+ struct descriptor *curd;
+ struct dvb_nit_section_part2 *part2;
+ struct dvb_nit_transport *cur_transport;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode NIT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((nit = dvb_nit_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX NIT section decode error\n");
+ return;
+ }
+ printf("SCT network_id:0x%04x\n", dvb_nit_section_network_id(nit));
+ dvb_nit_section_descriptors_for_each(nit, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ part2 = dvb_nit_section_part2(nit);
+ dvb_nit_section_transports_for_each(nit, part2, cur_transport) {
+ printf("\tSCT transport_stream_id:0x%04x original_network_id:0x%04x\n", cur_transport->transport_stream_id, cur_transport->original_network_id);
+ dvb_nit_transport_descriptors_for_each(cur_transport, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_dvb_service_description_actual:
+ case stag_dvb_service_description_other:
+ {
+ struct dvb_sdt_section *sdt;
+ struct dvb_sdt_service *cur_service;
+ struct descriptor *curd;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode SDT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((sdt = dvb_sdt_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "XXXX SDT section decode error\n");
+ return;
+ }
+ printf("SCT transport_stream_id:0x%04x original_network_id:0x%04x\n", dvb_sdt_section_transport_stream_id(sdt), sdt->original_network_id);
+ dvb_sdt_section_services_for_each(sdt, cur_service) {
+ printf("\tSCT service_id:0x%04x eit_schedule_flag:%i eit_present_following_flag:%i running_status:%i free_ca_mode:%i\n",
+ cur_service->service_id,
+ cur_service->eit_schedule_flag,
+ cur_service->eit_present_following_flag,
+ cur_service->running_status,
+ cur_service->free_ca_mode);
+ dvb_sdt_service_descriptors_for_each(cur_service, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_dvb_bouquet_association:
+ {
+ struct dvb_bat_section *bat;
+ struct descriptor *curd;
+ struct dvb_bat_section_part2 *part2;
+ struct dvb_bat_transport *cur_transport;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode BAT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((bat = dvb_bat_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX BAT section decode error\n");
+ return;
+ }
+ printf("SCT bouquet_id:0x%04x\n", dvb_bat_section_bouquet_id(bat));
+ dvb_bat_section_descriptors_for_each(bat, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ part2 = dvb_bat_section_part2(bat);
+ dvb_bat_section_transports_for_each(part2, cur_transport) {
+ printf("\tSCT transport_stream_id:0x%04x original_network_id:0x%04x\n",
+ cur_transport->transport_stream_id,
+ cur_transport->original_network_id);
+ dvb_bat_transport_descriptors_for_each(cur_transport, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_dvb_update_notification:
+ case stag_dvb_ip_mac_notification:
+ {
+ struct dvb_int_section *_int;
+ struct descriptor *curd;
+ struct dvb_int_target *cur_target;
+ struct dvb_int_operational_loop *operational_loop;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode INT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((_int = dvb_int_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "XXXX INT section decode error\n");
+ return;
+ }
+ printf("SCT action_type:0x%02x platform_id_hash:0x%02x platform_id:0x%06x processing_order:0x%02x\n",
+ dvb_int_section_action_type(_int),
+ dvb_int_section_platform_id_hash(_int),
+ _int->platform_id,
+ _int->processing_order);
+ dvb_int_section_platform_descriptors_for_each(_int, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ dvb_int_section_target_loop_for_each(_int, cur_target) {
+ dvb_int_target_target_descriptors_for_each(cur_target, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ operational_loop = dvb_int_target_operational_loop(cur_target);
+ dvb_int_operational_loop_operational_descriptors_for_each(operational_loop, curd) {
+ parse_descriptor(curd, 3, data_type);
+ }
+ }
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ case stag_dvb_event_information_nownext_actual:
+ case stag_dvb_event_information_nownext_other:
+ case 0x50: case 0x51: case 0x52: case 0x53: case 0x54: case 0x55: case 0x56: case 0x57:
+ case 0x58: case 0x59: case 0x5a: case 0x5b: case 0x5c: case 0x5d: case 0x5e: case 0x5f:
+ case 0x60: case 0x61: case 0x62: case 0x63: case 0x64: case 0x65: case 0x66: case 0x67:
+ case 0x68: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: case 0x6e: case 0x6f:
+ {
+ struct dvb_eit_section *eit;
+ struct dvb_eit_event *cur_event;
+ struct descriptor *curd;
+ time_t start_time;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode EIT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((eit = dvb_eit_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "XXXX EIT section decode error\n");
+ return;
+ }
+ printf("SCT service_id:0x%04x transport_stream_id:0x%04x original_network_id:0x%04x segment_last_section_number:0x%02x last_table_id:0x%02x\n",
+ dvb_eit_section_service_id(eit),
+ eit->transport_stream_id,
+ eit->original_network_id,
+ eit->segment_last_section_number,
+ eit->last_table_id);
+ dvb_eit_section_events_for_each(eit, cur_event) {
+ start_time = dvbdate_to_unixtime(cur_event->start_time);
+ printf("\tSCT event_id:0x%04x duration:%i running_status:%i free_ca_mode:%i start_time:%i -- %s",
+ cur_event->event_id,
+ dvbduration_to_seconds(cur_event->duration),
+ cur_event->running_status,
+ cur_event->free_ca_mode,
+ (int) start_time,
+ ctime(&start_time));
+ dvb_eit_event_descriptors_for_each(cur_event, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_dvb_time_date:
+ {
+ struct dvb_tdt_section *tdt;
+ time_t dvbtime;
+
+ printf("SCT Decode TDT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((tdt = dvb_tdt_section_codec(section)) == NULL) {
+ fprintf(stderr, "XXXX TDT section decode error\n");
+ return;
+ }
+ dvbtime = dvbdate_to_unixtime(tdt->utc_time);
+ printf("SCT Time: %i -- %s", (int) dvbtime, ctime(&dvbtime));
+ break;
+ }
+
+ case stag_dvb_running_status:
+ {
+ struct dvb_rst_section *rst;
+ struct dvb_rst_status *cur_status;
+
+ printf("SCT Decode RST (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((rst = dvb_rst_section_codec(section)) == NULL) {
+ fprintf(stderr, "SCT XXXX RST section decode error\n");
+ return;
+ }
+ dvb_rst_section_statuses_for_each(rst, cur_status) {
+ printf("\tSCT transport_stream_id:0x%04x original_network_id:0x%04x service_id:0x%04x event_id:0x%04x running_status:%i\n",
+ cur_status->transport_stream_id,
+ cur_status->original_network_id,
+ cur_status->service_id,
+ cur_status->event_id,
+ cur_status->running_status);
+ }
+
+// hexdump(0, "SCT ", buf, len);
+// getchar();
+ break;
+ }
+
+ case stag_dvb_stuffing:
+ {
+ struct dvb_st_section *st;
+
+ printf("SCT Decode ST (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((st = dvb_st_section_codec(section)) == NULL) {
+ fprintf(stderr, "SCT XXXX ST section decode error\n");
+ return;
+ }
+ printf("SCT Length: %i\n", dvb_st_section_data_length(st));
+ break;
+ }
+
+ case stag_dvb_time_offset:
+ {
+ struct dvb_tot_section *tot;
+ struct descriptor *curd;
+ time_t dvbtime;
+
+ if (section_check_crc(section))
+ return;
+ printf("SCT Decode TOT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((tot = dvb_tot_section_codec(section)) == NULL) {
+ fprintf(stderr, "SCT XXXX TOT section decode error\n");
+ return;
+ }
+ dvbtime = dvbdate_to_unixtime(tot->utc_time);
+ printf("SCT utc_time: %i -- %s", (int) dvbtime, ctime(&dvbtime));
+ dvb_tot_section_descriptors_for_each(tot, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ break;
+ }
+
+ case stag_dvb_tva_container:
+ {
+ struct dvb_tva_container_section *tva;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode tva (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((tva = dvb_tva_container_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX tva section decode error\n");
+ return;
+ }
+ printf("SCT container_id:%04x\n",
+ dvb_tva_container_section_container_id(tva));
+ hexdump(0, "SCT ", dvb_tva_container_section_data(tva), dvb_tva_container_section_data_length(tva));
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ case stag_dvb_discontinuity_information:
+ {
+ struct dvb_dit_section *dit;
+
+ printf("SCT Decode DIT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((dit = dvb_dit_section_codec(section)) == NULL) {
+ fprintf(stderr, "SCT XXXX DIT section decode error\n");
+ return;
+ }
+ printf("SCT transition_flag:%i\n", dit->transition_flag);
+
+// hexdump(0, "SCT ", buf, len);
+// getchar();
+ break;
+ }
+
+ case stag_dvb_selection_information:
+ {
+ struct dvb_sit_section *sit;
+ struct descriptor *curd;
+ struct dvb_sit_service *cur_service;
+
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ printf("SCT Decode SIT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((sit = dvb_sit_section_codec(section_ext)) == NULL) {
+ fprintf(stderr, "SCT XXXX SIT section decode error\n");
+ return;
+ }
+ dvb_sit_section_descriptors_for_each(sit, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ dvb_sit_section_services_for_each(sit, cur_service) {
+ printf("\tSCT service_id:0x%04x running_status:%i\n", cur_service->service_id, cur_service->running_status);
+ dvb_sit_service_descriptors_for_each(cur_service, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ default:
+ fprintf(stderr, "SCT XXXX Unknown table_id:0x%02x (pid:0x%04x)\n", section->table_id, pid);
+// hexdump(0, "SCT ", buf, len);
+ return;
+ }
+}
+
+void parse_atsc_section(uint8_t *buf, int len, int pid, int data_type, struct section *section)
+{
+ struct section_ext *section_ext = NULL;
+ struct atsc_section_psip *section_psip = NULL;
+ if ((section_ext = section_ext_decode(section, 1)) == NULL) {
+ return;
+ }
+ if ((section_psip = atsc_section_psip_decode(section_ext)) == NULL) {
+ return;
+ }
+
+ printf("SCT protocol_version:%i\n", section_psip->protocol_version);
+
+ switch(section->table_id) {
+ case stag_atsc_master_guide:
+ {
+ struct atsc_mgt_section *mgt;
+ struct atsc_mgt_table *cur_table;
+ struct atsc_mgt_section_part2 *part2;
+ struct descriptor *curd;
+ int idx;
+
+ printf("SCT Decode MGT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((mgt = atsc_mgt_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX MGT section decode error\n");
+ return;
+ }
+ atsc_mgt_section_tables_for_each(mgt, cur_table, idx) {
+ printf("\tSCT table_type:0x%04x table_type_PID:%04x table_type_version_number:%i number_bytes:%i\n",
+ cur_table->table_type,
+ cur_table->table_type_PID,
+ cur_table->table_type_version_number,
+ cur_table->number_bytes);
+ atsc_mgt_table_descriptors_for_each(cur_table, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+
+ part2 = atsc_mgt_section_part2(mgt);
+ atsc_mgt_section_part2_descriptors_for_each(part2, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ break;
+ }
+
+ case stag_atsc_terrestrial_virtual_channel:
+ {
+ struct atsc_tvct_section *tvct;
+ struct atsc_tvct_channel *cur_channel;
+ struct atsc_tvct_section_part2 *part2;
+ struct descriptor *curd;
+ int idx;
+
+ printf("SCT Decode TVCT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((tvct = atsc_tvct_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX TVCT section decode error\n");
+ return;
+ }
+ printf("\tSCT tranport_stream_id:0x%04x\n",
+ atsc_tvct_section_transport_stream_id(tvct));
+
+ atsc_tvct_section_channels_for_each(tvct, cur_channel, idx) {
+ hexdump(0, "SCT short_name ", (uint8_t*) cur_channel->short_name, 7*2);
+
+ printf("\tSCT major_channel_number:%04x minor_channel_number:%04x modulation_mode:%02x carrier_frequency:%i channel_TSID:%04x program_number:%04x ETM_location:%i access_controlled:%i hidden:%i hide_guide:%i service_type:%02x source_id:%04x\n",
+ cur_channel->major_channel_number,
+ cur_channel->minor_channel_number,
+ cur_channel->modulation_mode,
+ cur_channel->carrier_frequency,
+ cur_channel->channel_TSID,
+ cur_channel->program_number,
+ cur_channel->ETM_location,
+ cur_channel->access_controlled,
+ cur_channel->hidden,
+ cur_channel->hide_guide,
+ cur_channel->service_type,
+ cur_channel->source_id);
+ atsc_tvct_channel_descriptors_for_each(cur_channel, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+
+ part2 = atsc_tvct_section_part2(tvct);
+ atsc_tvct_section_part2_descriptors_for_each(part2, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ break;
+ }
+
+ case stag_atsc_cable_virtual_channel:
+ {
+ struct atsc_cvct_section *cvct;
+ struct atsc_cvct_channel *cur_channel;
+ struct atsc_cvct_section_part2 *part2;
+ struct descriptor *curd;
+ int idx;
+
+ printf("SCT Decode CVCT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((cvct = atsc_cvct_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX CVCT section decode error\n");
+ return;
+ }
+ printf("\tSCT tranport_stream_id:0x%04x\n",
+ atsc_cvct_section_transport_stream_id(cvct));
+
+ atsc_cvct_section_channels_for_each(cvct, cur_channel, idx) {
+ hexdump(0, "SCT short_name ", (uint8_t*) cur_channel->short_name, 7*2);
+
+ printf("\tSCT major_channel_number:%04x minor_channel_number:%04x modulation_mode:%02x carrier_frequency:%i channel_TSID:%04x program_number:%04x ETM_location:%i access_controlled:%i hidden:%i path_select:%i out_of_band:%i hide_guide:%i service_type:%02x source_id:%04x\n",
+ cur_channel->major_channel_number,
+ cur_channel->minor_channel_number,
+ cur_channel->modulation_mode,
+ cur_channel->carrier_frequency,
+ cur_channel->channel_TSID,
+ cur_channel->program_number,
+ cur_channel->ETM_location,
+ cur_channel->access_controlled,
+ cur_channel->hidden,
+ cur_channel->path_select,
+ cur_channel->out_of_band,
+ cur_channel->hide_guide,
+ cur_channel->service_type,
+ cur_channel->source_id);
+ atsc_cvct_channel_descriptors_for_each(cur_channel, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+
+ part2 = atsc_cvct_section_part2(cvct);
+ atsc_cvct_section_part2_descriptors_for_each(part2, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+ break;
+ }
+
+ case stag_atsc_rating_region:
+ {
+ struct atsc_rrt_section *rrt;
+ struct atsc_rrt_section_part2 *part2;
+ struct atsc_rrt_dimension *cur_dimension;
+ struct atsc_rrt_dimension_part2 *dpart2;
+ struct atsc_rrt_dimension_value *cur_value;
+ struct atsc_rrt_dimension_value_part2 *vpart2;
+ struct atsc_rrt_section_part3 *part3;
+ struct descriptor *curd;
+ int didx;
+ int vidx;
+
+ printf("SCT Decode RRT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((rrt = atsc_rrt_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX RRT section decode error\n");
+ return;
+ }
+ printf("\tSCT rating_region:0x%02x\n",
+ atsc_rrt_section_rating_region(rrt));
+ atsctextdump("SCT region_name:", 1,
+ atsc_rrt_section_rating_region_name_text(rrt),
+ rrt->rating_region_name_length);
+
+ part2 = atsc_rrt_section_part2(rrt);
+ atsc_rrt_section_dimensions_for_each(part2, cur_dimension, didx) {
+ atsctextdump("SCT dimension_name:", 2,
+ atsc_rrt_dimension_name_text(cur_dimension),
+ cur_dimension->dimension_name_length);
+
+ dpart2 = atsc_rrt_dimension_part2(cur_dimension);
+ printf("\tSCT graduated_scale:%i\n",
+ dpart2->graduated_scale);
+
+ atsc_rrt_dimension_part2_values_for_each(dpart2, cur_value, vidx) {
+ atsctextdump("SCT value_abbrev_name:", 3,
+ atsc_rrt_dimension_value_abbrev_rating_value_text(cur_value),
+ cur_value->abbrev_rating_value_length);
+
+ vpart2 = atsc_rrt_dimension_value_part2(cur_value);
+ atsctextdump("SCT value_text:", 3,
+ atsc_rrt_dimension_value_part2_rating_value_text(vpart2),
+ vpart2->rating_value_length);
+ }
+ }
+
+ part3 = atsc_rrt_section_part3(part2);
+ atsc_rrt_section_part3_descriptors_for_each(part3, curd) {
+ parse_descriptor(curd, 1, data_type);
+ }
+
+ hexdump(0, "SCT ", buf, len);
+ getchar();
+ break;
+ }
+
+ case stag_atsc_event_information:
+ {
+ struct atsc_eit_section *eit;
+ struct atsc_eit_event *cur_event;
+ struct atsc_eit_event_part2 *part2;
+ struct descriptor *curd;
+ int idx;
+
+ printf("SCT Decode EIT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((eit = atsc_eit_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX EIT section decode error\n");
+ return;
+ }
+ printf("\tSCT source_id:0x%04x\n",
+ atsc_eit_section_source_id(eit));
+
+ atsc_eit_section_events_for_each(eit, cur_event, idx) {
+ printf("\t\tSCT event_id:%04x start_time:%i ETM_location:%i length_in_secs:%i\n",
+ cur_event->event_id,
+ cur_event->start_time,
+ cur_event->ETM_location,
+ cur_event->length_in_seconds);
+
+ atsctextdump("SCT title:", 2,
+ atsc_eit_event_name_title_text(cur_event),
+ cur_event->title_length);
+
+ part2 = atsc_eit_event_part2(cur_event);
+
+ atsc_eit_event_part2_descriptors_for_each(part2, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ }
+ break;
+ }
+
+ case stag_atsc_extended_text:
+ {
+ struct atsc_ett_section *ett;
+
+ printf("SCT Decode ETT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((ett = atsc_ett_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX ETT section decode error\n");
+ return;
+ }
+ printf("\tSCT ETM_source_id:0x%04x ETM_sub_id:%04x ETM_type:%02x\n",
+ ett->ETM_source_id,
+ ett->ETM_sub_id,
+ ett->ETM_type);
+ atsctextdump("SCT text:", 1,
+ atsc_ett_section_extended_text_message(ett),
+ atsc_ett_section_extended_text_message_length(ett));
+ break;
+ }
+
+ case stag_atsc_system_time:
+ {
+ struct atsc_stt_section *stt;
+ struct descriptor *curd;
+
+ printf("SCT Decode STT (pid:0x%04x) (table:0x%02x)\n", pid, section->table_id);
+ if ((stt = atsc_stt_section_codec(section_psip)) == NULL) {
+ fprintf(stderr, "SCT XXXX STT section decode error\n");
+ return;
+ }
+ printf("\tSCT system_time:%i gps_utc_offset:%i DS_status:%i DS_day_of_month:%i DS_hour:%i\n",
+ stt->system_time,
+ stt->gps_utc_offset,
+ stt->DS_status,
+ stt->DS_day_of_month,
+ stt->DS_hour);
+ atsc_stt_section_descriptors_for_each(stt, curd) {
+ parse_descriptor(curd, 2, data_type);
+ }
+ break;
+ }
+
+ default:
+ fprintf(stderr, "SCT XXXX Unknown table_id:0x%02x (pid:0x%04x)\n", section->table_id, pid);
+ hexdump(0, "SCT ", buf, len);
+ return;
+ }
+}
+
+void parse_descriptor(struct descriptor *d, int indent, int data_type)
+{
+ switch(d->tag) {
+ case dtag_mpeg_video_stream:
+ {
+ struct mpeg_video_stream_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_video_stream_descriptor\n");
+ dx = mpeg_video_stream_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_video_stream_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC multiple_frame_rate_flag:%i frame_rate_code:%i mpeg_1_only_flag:%i constrained_parameter_flag:%i still_picture_flag:%i\n",
+ dx->multiple_frame_rate_flag,
+ dx->frame_rate_code,
+ dx->mpeg_1_only_flag,
+ dx->constrained_parameter_flag,
+ dx->still_picture_flag);
+ if (!dx->mpeg_1_only_flag) {
+ struct mpeg_video_stream_extra *extra = mpeg_video_stream_descriptor_extra(dx);
+ iprintf(indent, "DSC profile_and_level_indication:0x%02x chroma_format:%i frame_rate_extension:%i\n",
+ extra->profile_and_level_indication,
+ extra->chroma_format,
+ extra->frame_rate_extension);
+ }
+ break;
+ }
+
+ case dtag_mpeg_audio_stream:
+ {
+ struct mpeg_audio_stream_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_audio_stream_descriptor\n");
+ dx = mpeg_audio_stream_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_audio_stream_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC free_format_flag:%i id:%i layer:%i variable_rate_audio_indicator:%i\n",
+ dx->free_format_flag,
+ dx->id,
+ dx->layer,
+ dx->variable_rate_audio_indicator);
+ break;
+ }
+
+ case dtag_mpeg_hierarchy:
+ {
+ struct mpeg_hierarchy_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_hierarchy_descriptor\n");
+ dx = mpeg_hierarchy_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_hierarchy_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC hierarchy_type:%i hierarchy_layer_index:%i hierarchy_embedded_layer_index:%i hierarchy_channel:%i\n",
+ dx->hierarchy_type,
+ dx->hierarchy_layer_index,
+ dx->hierarchy_embedded_layer_index,
+ dx->hierarchy_channel);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_registration:
+ {
+ struct mpeg_registration_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_registration_descriptor\n");
+ dx = mpeg_registration_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_registration_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC format_identifier:0x%x\n",
+ dx->format_identifier);
+ iprintf(indent, "DSC additional_id_info:\n");
+ hexdump(indent, "DSC ",
+ mpeg_registration_descriptor_additional_id_info(dx),
+ mpeg_registration_descriptor_additional_id_info_length(dx));
+ break;
+ }
+
+ case dtag_mpeg_data_stream_alignment:
+ {
+ struct mpeg_data_stream_alignment_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_data_stream_alignment_descriptor\n");
+ dx = mpeg_data_stream_alignment_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_data_stream_alignment_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC alignment_type:%i\n",
+ dx->alignment_type);
+ break;
+ }
+
+ case dtag_mpeg_target_background_grid:
+ {
+ struct mpeg_target_background_grid_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_target_background_grid_descriptor\n");
+ dx = mpeg_target_background_grid_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_target_background_grid_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC horizontal_size:%i vertical_size:%i aspect_ratio_information:%i\n",
+ dx->horizontal_size,
+ dx->vertical_size,
+ dx->aspect_ratio_information);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_video_window:
+ {
+ struct mpeg_video_window_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_video_window_descriptor\n");
+ dx = mpeg_video_window_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_video_window_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC horizontal_offset:%i vertical_offset:%i window_priority:%i\n",
+ dx->horizontal_offset,
+ dx->vertical_offset,
+ dx->window_priority);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_ca:
+ {
+ struct mpeg_ca_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_ca_descriptor\n");
+ dx = mpeg_ca_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_ca_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC ca_system_id:0x%04x ca_pid:0x%04x\n",
+ dx->ca_system_id,
+ dx->ca_pid);
+ iprintf(indent, "DSC data:\n");
+ hexdump(indent, "DSC ", mpeg_ca_descriptor_data(dx), mpeg_ca_descriptor_data_length(dx));
+ break;
+ }
+
+ case dtag_mpeg_iso_639_language:
+ {
+ struct mpeg_iso_639_language_descriptor *dx;
+ struct mpeg_iso_639_language_code *cur_lang;
+
+ iprintf(indent, "DSC Decode mpeg_iso_639_language_descriptor\n");
+ dx = mpeg_iso_639_language_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_iso_639_language_descriptor decode error\n");
+ return;
+ }
+ mpeg_iso_639_language_descriptor_languages_for_each(dx, cur_lang) {
+ iprintf(indent+1, "DSC language_code:%.3s audio_type:0x%02x\n",
+ cur_lang->language_code,
+ cur_lang->audio_type);
+ }
+ break;
+ }
+
+ case dtag_mpeg_system_clock:
+ {
+ struct mpeg_system_clock_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_system_clock_descriptor\n");
+ dx = mpeg_system_clock_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_system_clock_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC external_clock_reference_indicator:%i clock_accuracy_integer:%i clock_accuracy_exponent:%i\n",
+ dx->external_clock_reference_indicator,
+ dx->clock_accuracy_integer,
+ dx->clock_accuracy_exponent);
+ break;
+ }
+
+ case dtag_mpeg_multiplex_buffer_utilization:
+ {
+ struct mpeg_multiplex_buffer_utilization_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_multiplex_buffer_utilization_descriptor\n");
+ dx = mpeg_multiplex_buffer_utilization_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_multiplex_buffer_utilization_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC bound_valid_flag:%i ltw_offset_lower_bound:%i ltw_offset_upper_bound:%i\n",
+ dx->bound_valid_flag,
+ dx->ltw_offset_lower_bound,
+ dx->ltw_offset_upper_bound);
+ break;
+ }
+
+ case dtag_mpeg_copyright:
+ {
+ struct mpeg_copyright_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_copyright_descriptor\n");
+ dx = mpeg_copyright_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_copyright_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC copyright_identifier:0x%08x\n",
+ dx->copyright_identifier);
+ iprintf(indent, "DSC data:\n");
+ hexdump(indent, "DSC ", mpeg_copyright_descriptor_data(dx), mpeg_copyright_descriptor_data_length(dx));
+ break;
+ }
+
+ case dtag_mpeg_maximum_bitrate:
+ {
+ struct mpeg_maximum_bitrate_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_maximum_bitrate_descriptor\n");
+ dx = mpeg_maximum_bitrate_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_maximum_bitrate_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC maximum_bitrate:%i\n",
+ dx->maximum_bitrate);
+ break;
+ }
+
+ case dtag_mpeg_private_data_indicator:
+ {
+ struct mpeg_private_data_indicator_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_private_data_indicator_descriptor\n");
+ dx = mpeg_private_data_indicator_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_private_data_indicator_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC private_data_indicator:0x%x\n",
+ dx->private_data_indicator);
+ break;
+ }
+
+ case dtag_mpeg_smoothing_buffer:
+ {
+ struct mpeg_smoothing_buffer_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_smoothing_buffer_descriptor\n");
+ dx = mpeg_smoothing_buffer_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_smoothing_buffer_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC sb_leak_rate:%i sb_size:%i\n",
+ dx->sb_leak_rate,
+ dx->sb_size);
+ break;
+ }
+
+ case dtag_mpeg_std:
+ {
+ struct mpeg_std_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_std_descriptor\n");
+ dx = mpeg_std_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_std_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC leak_valid_flag:%i\n",
+ dx->leak_valid_flag);
+ break;
+ }
+
+ case dtag_mpeg_ibp:
+ {
+ struct mpeg_ibp_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_ibp_descriptor\n");
+ dx = mpeg_ibp_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_ibp_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC closed_gop_flag:%i identical_gop_flag:%i max_gop_length:%i\n",
+ dx->closed_gop_flag, dx->identical_gop_flag, dx->max_gop_length);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_4_video:
+ {
+ struct mpeg4_video_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg4_video_descriptor\n");
+ dx = mpeg4_video_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg4_video_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC mpeg4_visual_profile_and_level:0x%02x\n",
+ dx->mpeg4_visual_profile_and_level);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_4_audio:
+ {
+ struct mpeg4_audio_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg4_audio_descriptor\n");
+ dx = mpeg4_audio_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg4_audio_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC mpeg4_audio_profile_and_level:0x%02x\n",
+ dx->mpeg4_audio_profile_and_level);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_iod:
+ {
+ struct mpeg_iod_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_iod_descriptor\n");
+ dx = mpeg_iod_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_iod_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC scope_of_iod_label:0x%08x iod_label:0x%02x\n",
+ dx->scope_of_iod_label, dx->iod_label);
+ iprintf(indent, "DSC iod:\n");
+ hexdump(indent, "DSC ", mpeg_iod_descriptor_iod(dx), mpeg_iod_descriptor_iod_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_sl:
+ {
+ struct mpeg_sl_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_sl_descriptor\n");
+ dx = mpeg_sl_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_sl_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC es_id:0x%04x\n",
+ dx->es_id);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_fmc:
+ {
+ struct mpeg_fmc_descriptor *dx;
+ struct mpeg_flex_mux *cur_fm;
+
+ iprintf(indent, "DSC Decode mpeg_fmc_descriptor\n");
+ dx = mpeg_fmc_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_fmc_descriptor_descriptor decode error\n");
+ return;
+ }
+ mpeg_fmc_descriptor_muxes_for_each(dx, cur_fm) {
+ iprintf(indent+1, "DSC es_id:0x%04x flex_mux_channel:0x%02x\n",
+ cur_fm->es_id,
+ cur_fm->flex_mux_channel);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_external_es_id:
+ {
+ struct mpeg_external_es_id_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_external_es_id_descriptor\n");
+ dx = mpeg_external_es_id_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_external_es_id_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC external_es_id:0x%04x\n",
+ dx->external_es_id);
+ break;
+ }
+
+ case dtag_mpeg_muxcode:
+ {
+ struct mpeg_muxcode_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_muxcode_descriptor\n");
+ dx = mpeg_muxcode_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_muxcode_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC entries:\n");
+ hexdump(indent, "DSC ", mpeg_muxcode_descriptor_entries(dx), mpeg_muxcode_descriptor_entries_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_fmxbuffer_size:
+ {
+ struct mpeg_fmxbuffer_size_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_fmxbuffer_size_descriptor\n");
+ dx = mpeg_fmxbuffer_size_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_fmxbuffer_size_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC descriptors:\n");
+ hexdump(indent, "DSC ", mpeg_fmxbuffer_size_descriptor_descriptors(dx), mpeg_fmxbuffer_size_descriptor_descriptors_length(dx));
+ break;
+ }
+
+ case dtag_mpeg_multiplex_buffer:
+ {
+ struct mpeg_multiplex_buffer_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_multiplex_buffer_descriptor\n");
+ dx = mpeg_multiplex_buffer_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_multiplex_buffer_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC mb_buffer_size:%i tb_leak_rate:%i\n",
+ dx->mb_buffer_size, dx->tb_leak_rate);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_content_labelling:
+ {
+ struct mpeg_content_labelling_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_content_labelling_descriptor\n");
+ dx = mpeg_content_labelling_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_content_labelling_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC metadata_application_format:%04x\n",
+ dx->metadata_application_format);
+ struct mpeg_content_labelling_descriptor_application_format_identifier *id =
+ mpeg_content_labelling_descriptor_id(dx);
+ if (id != NULL) {
+ iprintf(indent, "DSC application_format_id:%04x\n",
+ id->id);
+ }
+ struct mpeg_content_labelling_descriptor_flags *flags =
+ mpeg_content_labelling_descriptor_flags(dx);
+ if (flags != NULL) {
+ iprintf(indent, "DSC content_reference_id_record_flag:%i content_time_base_indicator:%02x\n",
+ flags->content_reference_id_record_flag,
+ flags->content_time_base_indicator);
+
+ struct mpeg_content_labelling_descriptor_reference_id *reference_id =
+ mpeg_content_labelling_descriptor_reference_id(flags);
+ if (reference_id != NULL) {
+ hexdump(indent, "DSC reference_id " ,
+ mpeg_content_reference_id_data(reference_id),
+ reference_id->content_reference_id_record_length);
+ }
+
+ struct mpeg_content_labelling_descriptor_time_base *time_base =
+ mpeg_content_labelling_descriptor_time_base(flags);
+ if (time_base != NULL) {
+ iprintf(indent, "DSC time_base content_time_base_value:%lli metadata_time_base_value:%lli\n",
+ time_base->content_time_base_value,
+ time_base->metadata_time_base_value);
+ }
+
+ struct mpeg_content_labelling_descriptor_content_id *content_id =
+ mpeg_content_labelling_descriptor_content_id(flags);
+ if (content_id != NULL) {
+ iprintf(indent, "DSC content_id contentId:%i\n",
+ content_id->contentId);
+ }
+
+ struct mpeg_content_labelling_descriptor_time_base_association *time_base_assoc =
+ mpeg_content_labelling_descriptor_time_base_assoc(flags);
+ if (time_base_assoc != NULL) {
+ hexdump(indent, "DSC time_base_assoc" ,
+ mpeg_time_base_association_data(time_base_assoc),
+ time_base_assoc->time_base_association_data_length);
+ }
+
+ uint8_t *priv;
+ int priv_length;
+ priv = mpeg_content_labelling_descriptor_data(dx, flags, &priv_length);
+ hexdump(indent, "DSC private_data", priv, priv_length);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_metadata_pointer:
+ {
+ struct mpeg_metadata_pointer_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_metadata_pointer_descriptor\n");
+ dx = mpeg_metadata_pointer_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_metadata_pointer_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC metadata_application_format:%04x\n",
+ dx->metadata_application_format);
+
+ struct mpeg_metadata_pointer_descriptor_application_format_identifier *id =
+ mpeg_metadata_pointer_descriptor_appid(dx);
+ if (id != NULL) {
+ iprintf(indent, "DSC application_format_id:%04x\n",
+ id->id);
+ }
+
+ struct mpeg_metadata_pointer_descriptor_format_identifier *did =
+ mpeg_metadata_pointer_descriptor_formid(dx);
+ if (did != NULL) {
+ iprintf(indent, "DSC mpeg_metadata_pointer_descriptor_format_id:%04x\n",
+ did->id);
+ }
+
+ struct mpeg_metadata_pointer_descriptor_flags *flags =
+ mpeg_metadata_pointer_descriptor_flags(dx);
+ if (flags != NULL) {
+ iprintf(indent, "DSC metadata_service_id:%i metadata_locator_record_flag:%i mpeg_carriage_flags:%x\n",
+ flags->metadata_service_id,
+ flags->metadata_locator_record_flag,
+ flags->mpeg_carriage_flags);
+
+ struct mpeg_metadata_pointer_descriptor_locator *locator =
+ mpeg_metadata_pointer_descriptor_locator(flags);
+ if (locator != NULL) {
+ hexdump(indent, "DSC locator" ,
+ mpeg_metadata_pointer_descriptor_locator_data(locator),
+ locator->metadata_locator_record_length);
+ }
+
+ struct mpeg_metadata_pointer_descriptor_program_number *pnum=
+ mpeg_metadata_pointer_descriptor_program_number(flags);
+ if (pnum != NULL) {
+ iprintf(indent, "DSC program_number number:%04x\n",
+ pnum->number);
+ }
+
+ struct mpeg_metadata_pointer_descriptor_carriage *carriage =
+ mpeg_metadata_pointer_descriptor_carriage(flags);
+ if (carriage != NULL) {
+ iprintf(indent, "DSC carriage transport_stream_location:%04x transport_stream_id:%04x\n",
+ carriage->transport_stream_location,
+ carriage->transport_stream_id);
+ }
+
+ uint8_t *priv;
+ int priv_length;
+ priv = mpeg_metadata_pointer_descriptor_private_data(dx, flags, &priv_length);
+ hexdump(indent, "DSC private_data" , priv, priv_length);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_metadata:
+ {
+ struct mpeg_metadata_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_metadata_descriptor\n");
+ dx = mpeg_metadata_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_metadata_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC metadata_application_format:%04x\n",
+ dx->metadata_application_format);
+
+ struct mpeg_metadata_descriptor_application_format_identifier *id =
+ mpeg_metadata_descriptor_appid(dx);
+ if (id != NULL) {
+ iprintf(indent, "DSC application_format_id:%04x\n",
+ id->id);
+ }
+
+ struct mpeg_metadata_descriptor_format_identifier *did =
+ mpeg_metadata_descriptor_formid(dx);
+ if (did != NULL) {
+ iprintf(indent, "DSC mpeg_metadata_descriptor_format_id:%04x\n",
+ did->id);
+ }
+
+ struct mpeg_metadata_descriptor_flags *flags =
+ mpeg_metadata_descriptor_flags(dx);
+ if (flags != NULL) {
+ iprintf(indent, "DSC metadata_service_id:%i decoder_config_flags:%i dsm_cc_flag:%x\n",
+ flags->metadata_service_id,
+ flags->decoder_config_flags,
+ flags->dsm_cc_flag);
+
+ struct mpeg_metadata_descriptor_service_identifier *serviceid=
+ mpeg_metadata_descriptor_sevice_identifier(flags);
+ if (serviceid != NULL) {
+ hexdump(indent, "DSC service_id" ,
+ mpeg_metadata_descriptor_service_identifier_data(serviceid),
+ serviceid->service_identification_length);
+ }
+
+ struct mpeg_metadata_descriptor_decoder_config *dconfig=
+ mpeg_metadata_descriptor_decoder_config(flags);
+ if (dconfig != NULL) {
+ hexdump(indent, "DSC decoder_config" ,
+ mpeg_metadata_descriptor_decoder_config_data(dconfig),
+ dconfig->decoder_config_length);
+ }
+
+ struct mpeg_metadata_descriptor_decoder_config_id_record *dconfigid=
+ mpeg_metadata_descriptor_decoder_config_id_record(flags);
+ if (dconfigid != NULL) {
+ hexdump(indent, "DSC decoder_config" ,
+ mpeg_metadata_descriptor_decoder_config_id_record_data(dconfigid),
+ dconfigid->decoder_config_id_record_length);
+ }
+
+ struct mpeg_metadata_descriptor_decoder_config_service_id *dserviceid=
+ mpeg_metadata_descriptor_decoder_config_service_id(flags);
+ if (dserviceid != NULL) {
+ iprintf(indent, "DSC decoder config service_id:%04x\n",
+ dserviceid->decoder_config_metadata_service_id);
+ }
+
+ struct mpeg_metadata_descriptor_decoder_config_reserved *reserved=
+ mpeg_metadata_descriptor_decoder_config_reserved(flags);
+ if (reserved != NULL) {
+ hexdump(indent, "DSC reserved" ,
+ mpeg_metadata_descriptor_decoder_config_reserved_data(reserved),
+ reserved->reserved_data_length);
+ }
+
+ uint8_t *priv;
+ int priv_length;
+ priv = mpeg_metadata_descriptor_private_data(dx, flags, &priv_length);
+ hexdump(indent, "DSC private_data" , priv, priv_length);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_mpeg_metadata_std:
+ {
+ struct mpeg_metadata_std_descriptor *dx;
+
+ iprintf(indent, "DSC Decode mpeg_metadata_std_descriptor\n");
+ dx = mpeg_metadata_std_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX mpeg_metadata_std_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC metadata_input_leak_rate:%i metadata_buffer_size:%i metadata_output_leak_rate:%i\n",
+ dx->metadata_input_leak_rate,
+ dx->metadata_buffer_size,
+ dx->metadata_output_leak_rate);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ default:
+ switch(data_type) {
+ case DATA_TYPE_DVB:
+ parse_dvb_descriptor(d, indent, data_type);
+ return;
+
+ case DATA_TYPE_ATSC:
+ parse_atsc_descriptor(d, indent, data_type);
+ return;
+
+ default:
+ fprintf(stderr, "DSC XXXX Unknown descriptor_tag:0x%02x\n", d->tag);
+ hexdump(0, "DSC ", (uint8_t*) d, d->len+2);
+ return;
+ }
+ }
+}
+
+void parse_dvb_descriptor(struct descriptor *d, int indent, int data_type)
+{
+ (void) data_type;
+
+ switch(d->tag) {
+ case dtag_dvb_network_name:
+ {
+ struct dvb_network_name_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_network_name_descriptor\n");
+ dx = dvb_network_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_network_name_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC name:%.*s\n",
+ dvb_network_name_descriptor_name_length(dx),
+ dvb_network_name_descriptor_name(dx));
+ break;
+ }
+
+ case dtag_dvb_service_list:
+ {
+ struct dvb_service_list_descriptor *dx;
+ struct dvb_service_list_service *curs;
+
+ iprintf(indent, "DSC Decode dvb_service_list_descriptor\n");
+ dx = dvb_service_list_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_service_list_descriptor decode error\n");
+ return;
+ }
+ dvb_service_list_descriptor_services_for_each(dx, curs) {
+ iprintf(indent+1, "DSC service_id:0x%04x service_type:0x%02x\n",
+ curs->service_id, curs->service_type);
+ }
+ break;
+ }
+
+ case dtag_dvb_stuffing:
+ {
+ struct dvb_stuffing_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_stuffing_descriptor\n");
+ dx = dvb_stuffing_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_stuffing_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ dvb_stuffing_descriptor_data(dx),
+ dvb_stuffing_descriptor_data_length(dx));
+ break;
+ }
+
+ case dtag_dvb_satellite_delivery_system:
+ {
+ struct dvb_satellite_delivery_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_satellite_delivery_descriptor\n");
+ dx = dvb_satellite_delivery_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_satellite_delivery_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC frequency:%i orbital_position:%i west_east:%i polarization:%i roll_off:%i modulation_system:%i modulation_type: %i symbol_rate:%i fec_inner:%i\n",
+ dx->frequency,
+ dx->orbital_position,
+ dx->west_east_flag,
+ dx->polarization,
+ dx->roll_off,
+ dx->modulation_system,
+ dx->modulation_type,
+ dx->symbol_rate,
+ dx->fec_inner);
+ break;
+ }
+
+ case dtag_dvb_cable_delivery_system:
+ {
+ struct dvb_cable_delivery_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_cable_delivery_descriptor\n");
+ dx = dvb_cable_delivery_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_cable_delivery_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC frequency:%i fec_outer:%i modulation:%i symbol_rate:%i fec_inner:%i\n",
+ dx->frequency, dx->fec_outer, dx->modulation,
+ dx->symbol_rate, dx->fec_inner);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_vbi_data:
+ {
+ struct dvb_vbi_data_descriptor *dx;
+ struct dvb_vbi_data_entry *cur;
+ struct dvb_vbi_data_x *curx;
+
+ iprintf(indent, "DSC Decode dvb_vbi_data_descriptor\n");
+ dx = dvb_vbi_data_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_vbi_data_descriptor decode error\n");
+ return;
+ }
+ dvb_vbi_data_descriptor_entries_for_each(dx, cur) {
+ curx = dvb_vbi_data_entry_data_x(cur);
+ iprintf(indent+1, "DSC data_service_id:0x%04x\n", cur->data_service_id);
+ if (cur == NULL) {
+ hexdump(indent+1, "DSC", dvb_vbi_data_entry_data(cur), cur->data_length);
+ } else {
+ iprintf(indent+1, "DSC field_parity:%i line_offset:%i\n",
+ curx->field_parity, curx->line_offset);
+ }
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_vbi_teletext:
+ {
+ struct dvb_vbi_teletext_descriptor *dx;
+ struct dvb_vbi_teletext_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_vbi_teletext_descriptor\n");
+ dx = dvb_vbi_teletext_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_vbi_teletext_descriptor decode error\n");
+ return;
+ }
+ dvb_vbi_teletext_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1, "DSC language_code:%.3s type:%i magazine_number:%i page_number:%i\n",
+ cur->language_code,
+ cur->type, cur->magazine_number, cur->page_number);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_bouquet_name:
+ {
+ struct dvb_bouquet_name_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_bouquet_name_descriptor\n");
+ dx = dvb_bouquet_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_bouquet_name_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC name:%.*s\n",
+ dvb_bouquet_name_descriptor_name_length(dx),
+ dvb_bouquet_name_descriptor_name(dx));
+ break;
+ }
+
+ case dtag_dvb_service:
+ {
+ struct dvb_service_descriptor *dx;
+ struct dvb_service_descriptor_part2 *part2;
+
+ iprintf(indent, "DSC Decode dvb_service_descriptor\n");
+ dx = dvb_service_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_service_descriptor decode error\n");
+ return;
+ }
+ part2 = dvb_service_descriptor_part2(dx);
+ iprintf(indent, "DSC service_type:%02x provider_name:%.*s service_name:%.*s\n",
+ dx->service_type,
+ dx->service_provider_name_length,
+ dvb_service_descriptor_service_provider_name(dx),
+ part2->service_name_length,
+ dvb_service_descriptor_service_name(part2));
+ break;
+ }
+
+ case dtag_dvb_country_availability:
+ {
+ struct dvb_country_availability_descriptor *dx;
+ struct dvb_country_availability_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_country_availability_descriptor\n");
+ dx = dvb_country_availability_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_country_availability_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC country_availability_flag:%i\n", dx->country_availability_flag);
+ dvb_country_availability_descriptor_countries_for_each(dx, cur) {
+ iprintf(indent+1, "DSC country_code:%.3s\n", cur->country_code);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_linkage:
+ {
+ struct dvb_linkage_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_linkage_descriptor\n");
+ dx = dvb_linkage_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_linkage_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC transport_stream_id:0x%04x original_network_id:0x%04x service_id:0x%04x linkage_type:0x%02x\n",
+ dx->transport_stream_id, dx->original_network_id, dx->service_id, dx->linkage_type);
+ switch(dx->linkage_type) {
+ case 0x08:
+ {
+ struct dvb_linkage_data_08 *d08 = dvb_linkage_data_08(dx);
+ int network_id = dvb_linkage_data_08_network_id(dx, d08);
+ int initial_service_id = dvb_linkage_data_08_initial_service_id(dx, d08);
+ int length = 0;
+ uint8_t *data;
+
+ data = dvb_linkage_data_08_data(dx, d08, &length);
+ iprintf(indent, "DSC hand_over_type:%i origin_type:%i\n",
+ d08->hand_over_type, d08->origin_type);
+ if (network_id != -1) {
+ iprintf(indent, "DSC network_id:0x%04x\n", network_id);
+ }
+ if (initial_service_id != -1) {
+ iprintf(indent, "DSC initial_service_id:0x%04x\n", initial_service_id);
+ }
+ }
+
+ case 0x0b:
+ {
+ struct dvb_linkage_data_0b *data = dvb_linkage_data_0b(dx);
+ struct dvb_platform_id *platid;
+ struct dvb_platform_name *curplatname;
+
+ dvb_linkage_data_0b_platform_id_for_each(data, platid) {
+ iprintf(indent+1, "DSC platform_id:0x%06x\n", platid->platform_id);
+ dvb_platform_id_platform_name_for_each(platid, curplatname) {
+ iprintf(indent+2, "DSC language_code:%.3s platform_name:%.*s\n",
+ curplatname->language_code,
+ curplatname->platform_name_length, dvb_platform_name_text(curplatname));
+ }
+ }
+ break;
+ }
+
+ case 0x0c:
+ {
+ struct dvb_linkage_data_0c *data = dvb_linkage_data_0c(dx);
+
+ iprintf(indent, "DSC table_type:0x%02x\n", data->table_type);
+ if (dvb_linkage_data_0c_bouquet_id(data)) {
+ iprintf(indent, "DSC bouquet_id:0x%04x\n",
+ dvb_linkage_data_0c_bouquet_id(data));
+ }
+ break;
+ }
+
+ default:
+ hexdump(indent+1, "DSC", dvb_linkage_descriptor_data(dx), dvb_linkage_descriptor_data_length(dx));
+ break;
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_nvod_reference:
+ {
+ struct dvb_nvod_reference_descriptor *dx;
+ struct dvb_nvod_reference *cur;
+
+ iprintf(indent, "DSC Decode dvb_nvod_reference_descriptor\n");
+ dx = dvb_nvod_reference_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_nvod_reference_descriptor decode error\n");
+ return;
+ }
+ dvb_nvod_reference_descriptor_references_for_each(dx, cur) {
+ iprintf(indent+1, "DSC transport_stream_id:0x%04x original_network_id:0x%04x service_id:0x%04x\n",
+ cur->transport_stream_id, cur->original_network_id,
+ cur->service_id);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_time_shifted_service:
+ {
+ struct dvb_time_shifted_service_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_time_shifted_service_descriptor\n");
+ dx = dvb_time_shifted_service_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_time_shifted_service_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC reference_service_id:0x%04x\n", dx->reference_service_id);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_short_event:
+ {
+ struct dvb_short_event_descriptor *dx;
+ struct dvb_short_event_descriptor_part2 *part2;
+
+ iprintf(indent, "DSC Decode dvb_short_event_descriptor\n");
+ dx = dvb_short_event_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_short_event_descriptor decode error\n");
+ return;
+ }
+ part2 = dvb_short_event_descriptor_part2(dx);
+ iprintf(indent, "DSC language_code:%.3s event_name:%.*s text:%.*s\n",
+ dx->language_code,
+ dx->event_name_length, dvb_short_event_descriptor_event_name(dx),
+ part2->text_length, dvb_short_event_descriptor_text(part2));
+ break;
+ }
+
+ case dtag_dvb_extended_event:
+ {
+ struct dvb_extended_event_descriptor *dx;
+ struct dvb_extended_event_descriptor_part2 *part2;
+ struct dvb_extended_event_item *cur;
+
+ iprintf(indent, "DSC Decode dvb_extended_event_descriptor\n");
+ dx = dvb_extended_event_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_extended_event_descriptor decode error\n");
+ return;
+ }
+ part2 = dvb_extended_event_descriptor_part2(dx);
+ iprintf(indent, "DSC descriptor_number:%i last_descriptor_number:%i language_code:%.3s text:%.*s\n",
+ dx->descriptor_number, dx->last_descriptor_number,
+ dx->language_code,
+ part2->text_length, dvb_extended_event_descriptor_part2_text(part2));
+ dvb_extended_event_descriptor_items_for_each(dx, cur) {
+ struct dvb_extended_event_item_part2 *ipart2 =
+ dvb_extended_event_item_part2(cur);
+ iprintf(indent+1, "DSC description:%.*s item:%.*s\n",
+ cur->item_description_length, dvb_extended_event_item_description(cur),
+ ipart2->item_length, dvb_extended_event_item_part2_item(ipart2));
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_time_shifted_event:
+ {
+ struct dvb_time_shifted_event_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_time_shifted_event_descriptor\n");
+ dx = dvb_time_shifted_event_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_time_shifted_event_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC reference_service_id:0x%04x reference_event_id:0x%04x\n",
+ dx->reference_service_id, dx->reference_event_id);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_component:
+ {
+ struct dvb_component_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_component_descriptor\n");
+ dx = dvb_component_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_component_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC stream_content:%i component_type:%i component_tag: %i language_code:%.3s, text:%.*s\n",
+ dx->stream_content,
+ dx->component_type,
+ dx->component_tag,
+ dx->language_code,
+ dvb_component_descriptor_text_length(dx),
+ dvb_component_descriptor_text(dx));
+ break;
+ }
+
+ case dtag_dvb_mosaic:
+ {
+ struct dvb_mosaic_descriptor *dx;
+ struct dvb_mosaic_info *curinfo;
+
+ iprintf(indent, "DSC Decode dvb_mosaic_descriptor\n");
+ dx = dvb_mosaic_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_mosaic_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC mosaic_entry_point:%i number_of_horiz_elementary_cells:%i number_of_vert_elementary_cells:%i\n",
+ dx->mosaic_entry_point, dx->number_of_horiz_elementary_cells,
+ dx->number_of_vert_elementary_cells);
+ dvb_mosaic_descriptor_infos_for_each(dx, curinfo) {
+ struct dvb_mosaic_info_part2 *part2;
+ struct dvb_mosaic_linkage *linkage;
+ struct dvb_mosaic_elementary_cell_field *curfield;
+
+ part2 = dvb_mosaic_info_part2(curinfo);
+ linkage = dvb_mosaic_linkage(part2);
+ iprintf(indent+1, "DSC logical_cell_id:%i logical_cell_presentation_info:%i cell_linkage_info:0x%02x\n",
+ curinfo->logical_cell_id, curinfo->logical_cell_presentation_info,
+ part2->cell_linkage_info);
+ if (linkage) {
+ switch(part2->cell_linkage_info) {
+ case 0x01:
+ iprintf(indent+1, "DSC bouquet_id:0x%04x\n",
+ linkage->u.linkage_01.bouquet_id);
+ break;
+
+ case 0x02:
+ iprintf(indent+1, "DSC original_network_id:0x%04x transport_stream_id:0x%04x service_id:0x%04x\n",
+ linkage->u.linkage_02.original_network_id,
+ linkage->u.linkage_02.transport_stream_id,
+ linkage->u.linkage_02.service_id);
+ break;
+
+ case 0x03:
+ iprintf(indent+1, "DSC original_network_id:0x%04x transport_stream_id:0x%04x service_id:0x%04x\n",
+ linkage->u.linkage_03.original_network_id,
+ linkage->u.linkage_03.transport_stream_id,
+ linkage->u.linkage_03.service_id);
+ break;
+
+ case 0x04:
+ iprintf(indent+1, "DSC original_network_id:0x%04x transport_stream_id:0x%04x service_id:0x%04x event_id:0x%04x\n",
+ linkage->u.linkage_04.original_network_id,
+ linkage->u.linkage_04.transport_stream_id,
+ linkage->u.linkage_04.service_id,
+ linkage->u.linkage_04.event_id);
+ break;
+ }
+ }
+
+ dvb_mosaic_info_fields_for_each(curinfo, curfield) {
+ iprintf(indent+2, "DSC elementary_cell_id:0x%02x\n",
+ curfield->elementary_cell_id);
+ }
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_stream_identifier:
+ {
+ struct dvb_stream_identifier_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_stream_identifier_descriptor\n");
+ dx = dvb_stream_identifier_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_stream_identifier_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC component_tag:%i\n",
+ dx->component_tag);
+ break;
+ }
+
+ case dtag_dvb_ca_identifier:
+ {
+ struct dvb_ca_identifier_descriptor *dx;
+ int i;
+ uint16_t *ids;
+
+ iprintf(indent, "DSC Decode dvb_ca_identifier_descriptor\n");
+ dx = dvb_ca_identifier_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_ca_identifier_descriptor decode error\n");
+ return;
+ }
+ ids = dvb_ca_identifier_descriptor_ca_system_ids(dx);
+ for(i=0; i< dvb_ca_identifier_descriptor_ca_system_ids_count(dx); i++) {
+ iprintf(indent+i, "DSC system_id:0x%04x\n", ids[i]);
+ }
+ break;
+ }
+
+ case dtag_dvb_content:
+ {
+ struct dvb_content_descriptor *dx;
+ struct dvb_content_nibble *cur;
+
+ iprintf(indent, "DSC Decode dvb_content_descriptor\n");
+ dx = dvb_content_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_content_descriptor decode error\n");
+ return;
+ }
+ dvb_content_descriptor_nibbles_for_each(dx, cur) {
+ iprintf(indent+1, "DSC content_nibble_level_1:%i content_nibble_level_2:%i user_nibble_1:%i user_nibble_2:%i\n",
+ cur->content_nibble_level_1, cur->content_nibble_level_2,
+ cur->user_nibble_1, cur->user_nibble_2);
+ }
+ break;
+ }
+
+ case dtag_dvb_parental_rating:
+ {
+ struct dvb_parental_rating_descriptor *dx;
+ struct dvb_parental_rating *cur;
+
+ iprintf(indent, "DSC Decode dvb_parental_rating_descriptor\n");
+ dx = dvb_parental_rating_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_parental_rating_descriptor decode error\n");
+ return;
+ }
+ dvb_parental_rating_descriptor_ratings_for_each(dx, cur) {
+ iprintf(indent+1, "DSC country_code:%.3s rating:%i\n",
+ cur->country_code, cur->rating);
+ }
+ break;
+ }
+
+ case dtag_dvb_teletext:
+ {
+ struct dvb_teletext_descriptor *dx;
+ struct dvb_teletext_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_teletext_descriptor\n");
+ dx = dvb_teletext_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_teletext_descriptor decode error\n");
+ return;
+ }
+ dvb_teletext_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1, "DSC language_code:%.3s type:%i magazine_number:%i page_number:%i\n",
+ cur->language_code,
+ cur->type, cur->magazine_number, cur->page_number);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_telephone:
+ {
+ struct dvb_telephone_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_telephone_descriptor\n");
+ dx = dvb_telephone_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_telephone_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent,
+ "DSC foreign_availability:%i connection_type:%i country_prefix:%.*s "
+ "international_area_code:%.*s operator_code:%.*s national_area_code:%.*s core_number:%.*s\n",
+ dx->foreign_availability, dx->connection_type,
+ dx->country_prefix_length, dvb_telephone_descriptor_country_prefix(dx),
+ dx->international_area_code_length, dvb_telephone_descriptor_international_area_code(dx),
+ dx->operator_code_length, dvb_telephone_descriptor_operator_code(dx),
+ dx->national_area_code_length, dvb_telephone_descriptor_national_area_code(dx),
+ dx->core_number_length, dvb_telephone_descriptor_core_number(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_local_time_offset:
+ {
+ struct dvb_local_time_offset_descriptor *dx;
+ struct dvb_local_time_offset *cur;
+
+ iprintf(indent, "DSC Decode dvb_local_time_offset_descriptor\n");
+ dx = dvb_local_time_offset_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_local_time_offset_descriptor decode error\n");
+ return;
+ }
+ dvb_local_time_offset_descriptor_offsets_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC country_code:%.3s country_region_id:%i "
+ "local_time_offset_polarity:%i local_time_offset:%i "
+ "time_of_change:%i next_time_offset:%i\n",
+ cur->country_code, cur->country_region_id,
+ cur->local_time_offset_polarity,
+ dvbhhmm_to_seconds(cur->local_time_offset),
+ dvbdate_to_unixtime(cur->time_of_change),
+ dvbhhmm_to_seconds(cur->next_time_offset));
+ }
+ break;
+ }
+
+ case dtag_dvb_subtitling:
+ {
+ struct dvb_subtitling_descriptor *dx;
+ struct dvb_subtitling_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_subtitling_descriptor\n");
+ dx = dvb_subtitling_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_subtitling_descriptor decode error\n");
+ return;
+ }
+ dvb_subtitling_descriptor_subtitles_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC language_code:%.3s subtitling_type:0x%02x composition_page_id:0x%04x ancillary_page_id:0x%04x\n",
+ cur->language_code, cur->subtitling_type,
+ cur->composition_page_id, cur->ancillary_page_id);
+ }
+ break;
+ }
+
+ case dtag_dvb_terrestial_delivery_system:
+ {
+ struct dvb_terrestrial_delivery_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_terrestrial_delivery_descriptor\n");
+ dx = dvb_terrestrial_delivery_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_terrestrial_delivery_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC centre_frequency:%i bandwidth:%i priority:%i "
+ "time_slicing_indicator:%i mpe_fec_indicator:%i constellation:%i "
+ "hierarchy_information:%i code_rate_hp_stream:%i "
+ "code_rate_lp_stream:%i guard_interval:%i transmission_mode:%i "
+ "other_frequency_flag:%i\n",
+ dx->centre_frequency, dx->bandwidth, dx->priority,
+ dx->time_slicing_indicator, dx->mpe_fec_indicator,
+ dx->constellation,
+ dx->hierarchy_information, dx->code_rate_hp_stream,
+ dx->code_rate_lp_stream, dx->guard_interval,
+ dx->transmission_mode, dx->other_frequency_flag);
+ break;
+ }
+
+ case dtag_dvb_multilingual_network_name:
+ {
+ struct dvb_multilingual_network_name_descriptor *dx;
+ struct dvb_multilingual_network_name *cur;
+
+ iprintf(indent, "DSC Decode dvb_multilingual_network_name_descriptor\n");
+ dx = dvb_multilingual_network_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_multilingual_network_name_descriptor decode error\n");
+ return;
+ }
+ dvb_multilingual_network_name_descriptor_names_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC language_code:%.3s network_name:%.*s\n",
+ cur->language_code,
+ cur->network_name_length,
+ dvb_multilingual_network_name_name(cur));
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_multilingual_bouquet_name:
+ {
+ struct dvb_multilingual_bouquet_name_descriptor *dx;
+ struct dvb_multilingual_bouquet_name *cur;
+
+ iprintf(indent, "DSC Decode dvb_multilingual_bouquet_name_descriptor\n");
+ dx = dvb_multilingual_bouquet_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_multilingual_bouquet_name_descriptor decode error\n");
+ return;
+ }
+ dvb_multilingual_bouquet_name_descriptor_names_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC language_code:%.3s bouquet_name:%.*s\n",
+ cur->language_code,
+ cur->bouquet_name_length,
+ dvb_multilingual_bouquet_name_name(cur));
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_multilingual_service_name:
+ {
+ struct dvb_multilingual_service_name_descriptor *dx;
+ struct dvb_multilingual_service_name *cur;
+
+ iprintf(indent, "DSC Decode dvb_multilingual_service_name_descriptor\n");
+ dx = dvb_multilingual_service_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_multilingual_service_name_descriptor decode error\n");
+ return;
+ }
+ dvb_multilingual_service_name_descriptor_names_for_each(dx, cur) {
+ struct dvb_multilingual_service_name_part2 *part2;
+ part2 = dvb_multilingual_service_name_part2(cur);
+
+ iprintf(indent+1,
+ "DSC language_code:%.3s provider_name:%.*s service_name:%.*s\n",
+ cur->language_code,
+ cur->service_provider_name_length,
+ dvb_multilingual_service_name_service_provider_name(cur),
+ part2->service_name_length,
+ dvb_multilingual_service_name_service_name(part2));
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_multilingual_component:
+ {
+ struct dvb_multilingual_component_descriptor *dx;
+ struct dvb_multilingual_component *cur;
+
+ iprintf(indent, "DSC Decode dvb_multilingual_component_descriptor\n");
+ dx = dvb_multilingual_component_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_multilingual_component_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC component_tag:%02x\n", dx->component_tag);
+ dvb_multilingual_component_descriptor_components_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC language_code:%.3s description:%.*s\n",
+ cur->language_code,
+ cur->text_description_length,
+ dvb_multilingual_component_text_char(cur));
+ }
+ break;
+ }
+
+ case dtag_dvb_private_data_specifier:
+ {
+ struct dvb_private_data_specifier_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_private_data_specifier_descriptor\n");
+ dx = dvb_private_data_specifier_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_private_data_specifier_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC private_data_specifier:0x%08x\n",
+ dx->private_data_specifier);
+ break;
+ }
+
+ case dtag_dvb_service_move:
+ {
+ struct dvb_service_move_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_service_move_descriptor\n");
+ dx = dvb_service_move_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_service_move_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC new_original_network_id:0x%04x new_transport_stream_id:0x%04x new_service_id:0x%04x\n",
+ dx->new_original_network_id, dx->new_transport_stream_id, dx->new_service_id);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_short_smoothing_buffer:
+ {
+ struct dvb_short_smoothing_buffer_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_short_smoothing_buffer_descriptor\n");
+ dx = dvb_short_smoothing_buffer_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_short_smoothing_buffer_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC sb_size:%i sb_leak_rate:%i\n",
+ dx->sb_size, dx->sb_leak_rate);
+ hexdump(indent, "DSC",
+ dvb_short_smoothing_buffer_descriptor_reserved(dx),
+ dvb_short_smoothing_buffer_descriptor_reserved_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_frequency_list:
+ {
+ struct dvb_frequency_list_descriptor *dx;
+ uint32_t *freqs;
+ int count;
+ int i;
+
+ iprintf(indent, "DSC Decode dvb_frequency_list_descriptor\n");
+ dx = dvb_frequency_list_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_frequency_list_descriptor decode error\n");
+ return;
+ }
+ iprintf(0, "DSC coding_type=%i\n", dx->coding_type);
+
+ freqs = dvb_frequency_list_descriptor_centre_frequencies(dx);
+ count = dvb_frequency_list_descriptor_centre_frequencies_count(dx);
+ for(i=0; i< count; i++) {
+ iprintf(indent+1, "DSC %i\n", freqs[i]);
+ }
+ break;
+ }
+
+ case dtag_dvb_partial_transport_stream:
+ {
+ struct dvb_partial_transport_stream_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_partial_transport_stream_descriptor\n");
+ dx = dvb_partial_transport_stream_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_partial_transport_stream_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC peak_rate:%i minimum_overall_smoothing_rate:%i maximum_overall_smoothing_rate:%i\n",
+ dx->peak_rate, dx->minimum_overall_smoothing_rate, dx->maximum_overall_smoothing_rate);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_data_broadcast:
+ {
+ struct dvb_data_broadcast_descriptor *dx;
+ struct dvb_data_broadcast_descriptor_part2 *part2;
+
+ iprintf(indent, "DSC Decode dvb_data_broadcast_descriptor\n");
+ dx = dvb_data_broadcast_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_data_broadcast_descriptor decode error\n");
+ return;
+ }
+ part2 = dvb_data_broadcast_descriptor_part2(dx);
+
+ iprintf(indent, "DSC data_broadcast_id:0x%04x component_tag:0x%02x selector:%.*s language_code:%.3s text:%.*s\n",
+ dx->data_broadcast_id, dx->component_tag,
+ dx->selector_length, dvb_data_broadcast_descriptor_selector(dx),
+ part2->language_code,
+ part2->text_length, dvb_data_broadcast_descriptor_part2_text(part2));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_scrambling:
+ {
+ struct dvb_scrambling_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_scrambling_descriptor\n");
+ dx = dvb_scrambling_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_scrambling_descriptor decode error\n");
+ return;
+ }
+
+ iprintf(indent, "DSC scrambling_mode:0x%02x\n",
+ dx->scrambling_mode);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_data_broadcast_id:
+ {
+ struct dvb_data_broadcast_id_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_data_broadcast_id_descriptor\n");
+ dx = dvb_data_broadcast_id_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_data_broadcast_id_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC data_broadcast_id:0x%04x\n",
+ dx->data_broadcast_id);
+ hexdump(indent+1, "DSC",
+ dvb_data_broadcast_id_descriptor_id_selector_byte(dx),
+ dvb_data_broadcast_id_descriptor_id_selector_byte_length(dx));
+ break;
+ }
+
+ case dtag_dvb_transport_stream:
+ {
+ struct dvb_transport_stream_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_transport_stream_descriptor\n");
+ dx = dvb_transport_stream_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_transport_stream_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ dvb_transport_stream_descriptor_data(dx),
+ dvb_transport_stream_descriptor_data_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_dsng:
+ {
+ struct dvb_dsng_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_dsng_descriptor\n");
+ dx = dvb_dsng_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_dsng_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ dvb_dsng_descriptor_data(dx),
+ dvb_dsng_descriptor_data_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_pdc:
+ {
+ struct dvb_pdc_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_pdc_descriptor\n");
+ dx = dvb_pdc_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_pdc_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC programme_id_label:0x%06x\n",
+ dx->programme_id_label);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_ac3:
+ {
+ struct dvb_ac3_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_ac3_descriptor\n");
+ dx = dvb_ac3_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_ac3_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC ac3_type_flag:%i bsid_flag:%i mainid_flag:%i asvc_flag:%i\n",
+ dx->ac3_type_flag, dx->bsid_flag, dx->mainid_flag, dx->asvc_flag);
+ hexdump(indent+1, "DSC",
+ dvb_ac3_descriptor_additional_info(dx),
+ dvb_ac3_descriptor_additional_info_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_ancillary_data:
+ {
+ struct dvb_ancillary_data_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_ancillary_data_descriptor\n");
+ dx = dvb_ancillary_data_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_ancillary_data_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent, "DSC scale_factor_error_check:%i dab_ancillary_data:%i announcement_switching_data:%i extended_ancillary_data:%i dvd_video_ancillary_data:%i\n",
+ dx->scale_factor_error_check,
+ dx->dab_ancillary_data,
+ dx->announcement_switching_data,
+ dx->extended_ancillary_data,
+ dx->dvd_video_ancillary_data);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_cell_list:
+ {
+ struct dvb_cell_list_descriptor *dx;
+ struct dvb_cell_list_entry *cur;
+ struct dvb_subcell_list_entry *cur_subcell;
+
+ iprintf(indent, "DSC Decode dvb_cell_list_descriptor\n");
+ dx = dvb_cell_list_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_cell_list_descriptor decode error\n");
+ return;
+ }
+ dvb_cell_list_descriptor_cells_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC cell_id:%04x cell_latitude:%i cell_longitude:%i cell_extend_of_latitude:%i cell_extend_of_longitude:%i\n",
+ cur->cell_id,
+ cur->cell_latitude,
+ cur->cell_longitude,
+ cur->cell_extend_of_latitude,
+ cur->cell_extend_of_longitude);
+
+ dvb_cell_list_entry_subcells_for_each(cur, cur_subcell) {
+ iprintf(indent+2,
+ "DSC cell_id_extension:%04x subcell_latitude:%i subcell_longitude:%i subcell_extend_of_latitude:%i subcell_extend_of_longitude:%i\n",
+ cur_subcell->cell_id_extension,
+ cur_subcell->subcell_latitude,
+ cur_subcell->subcell_longitude,
+ cur_subcell->subcell_extend_of_latitude,
+ cur_subcell->subcell_extend_of_longitude);
+ }
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_cell_frequency_link:
+ {
+ struct dvb_cell_frequency_link_descriptor *dx;
+ struct dvb_cell_frequency_link_cell *cur;
+ struct dvb_cell_frequency_link_cell_subcell *cur_subcell;
+
+ iprintf(indent, "DSC Decode dvb_cell_frequency_link_descriptor\n");
+ dx = dvb_cell_frequency_link_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_cell_frequency_link_descriptor decode error\n");
+ return;
+ }
+ dvb_cell_frequency_link_descriptor_cells_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC cell_id:%04x frequency:%i\n",
+ cur->cell_id,
+ cur->frequency);
+
+ dvb_cell_frequency_link_cell_subcells_for_each(cur, cur_subcell) {
+ iprintf(indent+2,
+ "DSC cell_id_extension:%04x transposer_frequency:%i\n",
+ cur_subcell->cell_id_extension,
+ cur_subcell->transposer_frequency);
+ }
+ }
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_announcement_support:
+ {
+ struct dvb_announcement_support_descriptor *dx;
+ struct dvb_announcement_support_entry *cur;
+ struct dvb_announcement_support_reference *ref;
+
+ iprintf(indent, "DSC Decode dvb_announcement_support_descriptor\n");
+ dx = dvb_announcement_support_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_announcement_support_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent,
+ "DSC announcement_support_indicator:%04x\n",
+ dx->announcement_support_indicator);
+
+ dvb_announcement_support_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC announcement_type:%i reference_type:%i\n",
+ cur->announcement_type,
+ cur->reference_type);
+
+ ref = dvb_announcement_support_entry_reference(cur);
+ if (ref) {
+ iprintf(indent+1,
+ "DSC original_network_id:%04x transport_stream_id:%04x service_id:%04x component_tag:%02x\n",
+ ref->original_network_id,
+ ref->transport_stream_id,
+ ref->service_id,
+ ref->component_tag);
+ }
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_application_signalling:
+ {
+ struct dvb_application_signalling_descriptor *dx;
+ struct dvb_application_signalling_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_application_signalling_descriptor\n");
+ dx = dvb_application_signalling_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_application_signalling_descriptor decode error\n");
+ return;
+ }
+
+ dvb_application_signalling_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC application_type:%i AIT_version_number:%i\n",
+ cur->application_type,
+ cur->AIT_version_number);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_adaptation_field_data:
+ {
+ struct dvb_adaptation_field_data_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_adaptation_field_data_descriptor\n");
+ dx = dvb_adaptation_field_data_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_adaptation_field_data_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent,
+ "DSC announcement_switching_data:%i\n",
+ dx->announcement_switching_data);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_service_identifier:
+ {
+ struct dvb_service_identifier_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_service_identifier_descriptor\n");
+ dx = dvb_service_identifier_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_service_identifier_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ dvb_service_identifier_descriptor_identifier(dx),
+ dvb_service_identifier_descriptor_identifier_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_service_availability:
+ {
+ struct dvb_service_availability_descriptor *dx;
+ uint16_t *cellids;
+ int count;
+ int i;
+
+ iprintf(indent, "DSC Decode dvb_service_availability_descriptor\n");
+ dx = dvb_service_availability_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_service_availability_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent,
+ "DSC availability_flag:%i\n",
+ dx->availability_flag);
+
+ cellids = dvb_service_availability_descriptor_cell_ids(dx);
+ count = dvb_service_availability_descriptor_cell_ids_count(dx);
+ for(i=0; i< count; i++) {
+ iprintf(indent+1, "DSC", "%04x\n", cellids[i]);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_default_authority:
+ {
+ struct dvb_default_authority_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_default_authority_descriptor\n");
+ dx = dvb_default_authority_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_default_authority_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ dvb_default_authority_descriptor_name(dx),
+ dvb_default_authority_descriptor_name_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_related_content:
+ {
+ struct dvb_related_content_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_related_content_descriptor\n");
+ dx = dvb_related_content_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_related_content_descriptor decode error\n");
+ return;
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_tva_id:
+ {
+ struct dvb_tva_id_descriptor *dx;
+ struct dvb_tva_id_entry *cur;
+
+ iprintf(indent, "DSC Decode dvb_tva_id_descriptor\n");
+ dx = dvb_tva_id_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_tva_id_descriptor decode error\n");
+ return;
+ }
+
+ dvb_tva_id_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC tva_id:%04x running_status:%i\n",
+ cur->tva_id,
+ cur->running_status);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_content_identifier:
+ {
+ struct dvb_content_identifier_descriptor *dx;
+ struct dvb_content_identifier_entry *cur;
+ struct dvb_content_identifier_entry_data_0 *data0;
+ struct dvb_content_identifier_entry_data_1 *data1;
+
+ iprintf(indent, "DSC Decode dvb_tva_id_descriptor\n");
+ dx = dvb_content_identifier_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_content_identifier_descriptor decode error\n");
+ return;
+ }
+
+ dvb_content_identifier_descriptor_entries_for_each(dx, cur) {
+ iprintf(indent+1,
+ "DSC crid_type:%i crid_location:%i\n",
+ cur->crid_type,
+ cur->crid_location);
+
+ data0 = dvb_content_identifier_entry_data_0(cur);
+ if (data0) {
+ hexdump(indent, "DSC data0",
+ dvb_content_identifier_entry_data_0_data(data0),
+ data0->crid_length);
+ }
+
+ data1 = dvb_content_identifier_entry_data_1(cur);
+ if (data1) {
+ iprintf(indent+1,
+ "DSC crid_ref:%04x\n",
+ data1->crid_ref);
+ }
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_dvb_s2_satellite_delivery_descriptor:
+ {
+ struct dvb_s2_satellite_delivery_descriptor *dx;
+
+ iprintf(indent, "DSC Decode dvb_s2_satellite_delivery_descriptor\n");
+ dx = dvb_s2_satellite_delivery_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX dvb_s2_satellite_delivery_descriptor decode error\n");
+ return;
+ }
+
+ iprintf(indent,
+ "DSC scrambling_sequence_selector:%i multiple_input_stream:%i backwards_compatability:%i\n",
+ dx->scrambling_sequence_selector,
+ dx->multiple_input_stream,
+ dx->backwards_compatability);
+ if (dx->scrambling_sequence_selector) {
+ iprintf(indent,
+ "DSC scrambling_sequence_index:%i\n",
+ dvb_s2_satellite_delivery_descriptor_scrambling_sequence_index(dx));
+ }
+ if (dx->multiple_input_stream) {
+ iprintf(indent,
+ "DSC input_stream_id:%i\n",
+ dvb_s2_satellite_delivery_descriptor_input_stream_id(dx));
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ default:
+ fprintf(stderr, "DSC XXXX Unknown descriptor_tag:0x%02x\n", d->tag);
+ hexdump(0, "DSC ", (uint8_t*) d, d->len+2);
+ return;
+ }
+}
+
+void parse_atsc_descriptor(struct descriptor *d, int indent, int data_type)
+{
+ (void) data_type;
+
+ switch(d->tag) {
+ case dtag_atsc_stuffing:
+ {
+ struct atsc_stuffing_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_stuffing_descriptor\n");
+ dx = atsc_stuffing_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_stuffing_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ atsc_stuffing_descriptor_data(dx),
+ atsc_stuffing_descriptor_data_length(dx));
+ break;
+ }
+
+ case dtag_atsc_ac3_audio:
+ {
+ struct atsc_ac3_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_ac3_descriptor\n");
+ dx = atsc_ac3_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_ac3_descriptor decode error\n");
+ return;
+ }
+
+ iprintf(indent,
+ "DSC sample_rate_code:%i bsid:%i bit_rate_code:%i surround_mode:%i bsmod:%i num_channels:%i full_svc:%i\n",
+ dx->sample_rate_code,
+ dx->bsid,
+ dx->bit_rate_code,
+ dx->surround_mode,
+ dx->bsmod,
+ dx->num_channels,
+ dx->full_svc);
+
+ hexdump(indent+1, "DSC additional_info",
+ atsc_ac3_descriptor_additional_info(dx),
+ atsc_ac3_descriptor_additional_info_length(dx));
+ break;
+ }
+
+ case dtag_atsc_caption_service:
+ {
+ struct atsc_caption_service_descriptor *dx;
+ struct atsc_caption_service_entry *cur;
+ int idx;
+
+ iprintf(indent, "DSC Decode atsc_caption_service_descriptor\n");
+ dx = atsc_caption_service_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_caption_service_descriptor decode error\n");
+ return;
+ }
+
+ atsc_caption_service_descriptor_entries_for_each(dx, cur, idx) {
+ iprintf(indent+1,
+ "DSC language_code:%.3s digital_cc:%i value:%i easy_reader:%i wide_aspect_ratio:%i\n",
+ cur->language_code,
+ cur->digital_cc,
+ cur->value,
+ cur->easy_reader,
+ cur->wide_aspect_ratio);
+ }
+ break;
+ }
+
+ case dtag_atsc_content_advisory:
+ {
+ struct atsc_content_advisory_descriptor *dx;
+ struct atsc_content_advisory_entry *cure;
+ struct atsc_content_advisory_entry_dimension *curd;
+ struct atsc_content_advisory_entry_part2 *part2;
+ int eidx;
+ int didx;
+
+ iprintf(indent, "DSC Decode atsc_content_advisory_descriptor\n");
+ dx = atsc_content_advisory_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_content_advisory_descriptor decode error\n");
+ return;
+ }
+
+ atsc_content_advisory_descriptor_entries_for_each(dx, cure, eidx) {
+ iprintf(indent+1,
+ "DSC rating_region:%i\n",
+ cure->rating_region);
+
+ atsc_content_advisory_entry_dimensions_for_each(cure, curd, didx) {
+ iprintf(indent+2,
+ "DSC rating_dimension_j:%i rating_value:%i\n",
+ curd->rating_dimension_j,
+ curd->rating_value);
+ }
+
+ part2 = atsc_content_advisory_entry_part2(cure);
+
+ atsctextdump("DSC description:",
+ indent,
+ atsc_content_advisory_entry_part2_description(part2),
+ part2->rating_description_length);
+ }
+
+ break;
+ }
+
+ case dtag_atsc_extended_channel_name:
+ {
+ struct atsc_extended_channel_name_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_extended_channel_name_descriptor\n");
+ dx = atsc_extended_channel_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_extended_channel_name_descriptor decode error\n");
+ return;
+ }
+
+ atsctextdump("SCT text:", 1,
+ atsc_extended_channel_name_descriptor_text(dx),
+ atsc_extended_channel_name_descriptor_text_length(dx));
+ break;
+ }
+
+ case dtag_atsc_service_location:
+ {
+ struct atsc_service_location_descriptor *dx;
+ struct atsc_caption_service_location_element *cur;
+ int idx;
+
+ iprintf(indent, "DSC Decode atsc_service_location_descriptor\n");
+ dx = atsc_service_location_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_service_location_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent+1, "DSC PCR_PID:%04x\n", dx->PCR_PID);
+
+ atsc_service_location_descriptor_elements_for_each(dx, cur, idx) {
+ iprintf(indent+1, "DSC stream_type:%02x elementary_PID:%04x language_code:%.3s\n",
+ cur->stream_type,
+ cur->elementary_PID,
+ cur->language_code);
+ }
+ break;
+ }
+
+ case dtag_atsc_time_shifted_service:
+ {
+ struct atsc_time_shifted_service_descriptor *dx;
+ struct atsc_time_shifted_service *cur;
+ int idx;
+
+ iprintf(indent, "DSC Decode atsc_time_shifted_service_descriptor\n");
+ dx = atsc_time_shifted_service_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_time_shifted_service_descriptor decode error\n");
+ return;
+ }
+
+ atsc_time_shifted_service_descriptor_services_for_each(dx, cur, idx) {
+ iprintf(indent+1, "DSC time_shift:%i major_channel_number:%04x minor_channel_number:%04x\n",
+ cur->time_shift,
+ cur->major_channel_number,
+ cur->minor_channel_number);
+ }
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_component_name:
+ {
+ struct atsc_component_name_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_component_name_descriptor\n");
+ dx = atsc_component_name_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_component_name_descriptor decode error\n");
+ return;
+ }
+
+ atsctextdump("SCT name:", 1,
+ atsc_component_name_descriptor_text(dx),
+ atsc_component_name_descriptor_text_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_dcc_departing_request:
+ {
+ struct atsc_dcc_departing_request_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_dcc_departing_request_descriptor\n");
+ dx = atsc_dcc_departing_request_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_dcc_departing_request_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent+1, "DSC dcc_departing_request_type:%02x\n",
+ dx->dcc_departing_request_type);
+
+ atsctextdump("SCT text:", 1,
+ atsc_dcc_departing_request_descriptor_text(dx),
+ atsc_dcc_departing_request_descriptor_text_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_dcc_arriving_request:
+ {
+ struct atsc_dcc_arriving_request_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_dcc_arriving_request_descriptor\n");
+ dx = atsc_dcc_arriving_request_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_dcc_arriving_request_descriptor decode error\n");
+ return;
+ }
+ iprintf(indent+1, "DSC dcc_arriving_request_type:%02x\n",
+ dx->dcc_arriving_request_type);
+
+ atsctextdump("SCT text:", 1,
+ atsc_dcc_arriving_request_descriptor_text(dx),
+ atsc_dcc_arriving_request_descriptor_text_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_redistribution_control:
+ {
+ struct atsc_rc_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_rc_descriptor\n");
+ dx = atsc_rc_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_rc_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ atsc_rc_descriptor_info(dx),
+ atsc_rc_descriptor_info_length(dx));
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_genre:
+ {
+ struct atsc_genre_descriptor *dx;
+
+ iprintf(indent, "DSC Decode atsc_genre_descriptor\n");
+ dx = atsc_genre_descriptor_codec(d);
+ if (dx == NULL) {
+ fprintf(stderr, "DSC XXXX atsc_genre_descriptor decode error\n");
+ return;
+ }
+ hexdump(indent, "DSC",
+ atsc_genre_descriptor_attributes(dx),
+ dx->attribute_count);
+
+ hexdump(0, "XXX", (uint8_t*) d, d->len + 2);
+ getchar();
+ break;
+ }
+
+ case dtag_atsc_private_information:
+ // FIXME: whats the format?
+
+ case dtag_atsc_content_identifier:
+ // FIXME: whats the format?
+
+ default:
+ fprintf(stderr, "DSC XXXX Unknown descriptor_tag:0x%02x\n", d->tag);
+ hexdump(0, "DSC ", (uint8_t*) d, d->len+2);
+ return;
+ }
+}
+
+void iprintf(int indent, char *fmt, ...)
+{
+ va_list ap;
+
+ while(indent--) {
+ printf("\t");
+ }
+
+ va_start(ap, fmt);
+ vprintf(fmt, ap);
+ va_end(ap);
+}
+
+void hexdump(int indent, char *prefix, uint8_t *buf, int buflen)
+{
+ int i;
+ int j;
+ int max;
+ char line[512];
+
+ for(i=0; i< buflen; i+=16) {
+ max = 16;
+ if ((i + max) > buflen)
+ max = buflen - i;
+
+ memset(line, 0, sizeof(line));
+ memset(line + 4 + 48 + 1, ' ', 16);
+ sprintf(line, "%02x: ", i);
+ for(j=0; j<max; j++) {
+ sprintf(line + 4 + (j*3), "%02x", buf[i+j]);
+ if ((buf[i+j] > 31) && (buf[i+j] < 127))
+ line[4 + 48 + 1 + j] = buf[i+j];
+ else
+ line[4 + 48 + 1 + j] = '.';
+ }
+
+ for(j=0; j< 4 + 48; j++) {
+ if (!line[j])
+ line[j] = ' ';
+ }
+ line[4+48] = '|';
+
+ for(j=0; j < indent; j++) {
+ printf("\t");
+ }
+ printf("%s%s|\n", prefix, line);
+ }
+}
+
+void atsctextdump(char *header, int indent, struct atsc_text *atext, int len)
+{
+ struct atsc_text_string *cur_string;
+ struct atsc_text_string_segment *cur_segment;
+ int str_idx;
+ int seg_idx;
+
+ if (len == 0)
+ return;
+
+ atsc_text_strings_for_each(atext, cur_string, str_idx) {
+ iprintf(indent+1, "%s String %i language:%.3s\n", header, str_idx, cur_string->language_code);
+
+ atsc_text_string_segments_for_each(cur_string, cur_segment, seg_idx) {
+ iprintf(indent+2, "Segment %i compression_type:%i mode:%i\n",
+ seg_idx,
+ cur_segment->compression_type,
+ cur_segment->mode);
+
+ hexdump(indent+2, "rawbytes ",
+ atsc_text_string_segment_bytes(cur_segment),
+ cur_segment->number_bytes);
+
+ if (cur_segment->compression_type < 0x3e) {
+ uint8_t *decoded = NULL;
+ size_t decodedlen = 0;
+ size_t decodedpos = 0;
+
+ if (atsc_text_segment_decode(cur_segment,
+ &decoded,
+ &decodedlen,
+ &decodedpos) < 0) {
+ iprintf(indent+2, "Decode error\n");
+ } else {
+ hexdump(indent+2, "decoded ", decoded, decodedpos);
+ }
+ if (decoded)
+ free(decoded);
+ }
+ }
+ }
+}