diff options
Diffstat (limited to 'test/libucsi/testucsi.c')
| -rw-r--r-- | test/libucsi/testucsi.c | 3528 |
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, + §ion_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); + } + } + } +} |