ini_t *ini_parse(const gchar *buf, gsize len) { ini_parser_t *parser; if (buf == NULL || len == 0) { return NULL; } parser = g_new0(ini_parser_t, 1); parser->tokenizer = ini_tokenizer_new(buf, len); parser->ini = ini_new(); while (next_token(parser)->type != INI_TOKEN_EOF) { skip_whitespace(parser); switch (parser->curr_token->type) { case INI_TOKEN_EOL: case INI_TOKEN_EOF: continue; case INI_TOKEN_BRACKET_LEFT: parse_section_header(parser); break; case INI_TOKEN_TEXT: parse_key_value_pair(parser); break; case INI_TOKEN_SEMICOLON: skip_comment(parser); break; default: // XXX: Error. Log error and continue or shut down? break; } } return parser->ini; };
/* add all services found in the PAT */ static void pat_scan_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end; int sid, pmt_pid; char *provider_name, *name; char buf[256]; #ifdef DEBUG_SI printf("PAT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != PAT_TID) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; pmt_pid = get16(&p, p_end) & 0x1fff; if (pmt_pid < 0) break; #ifdef DEBUG_SI printf("sid=0x%x pid=0x%x\n", sid, pmt_pid); #endif if (sid == 0x0000) { /* NIT info */ } else { /* add the service with a dummy name */ snprintf(buf, sizeof(buf), "Service %x\n", sid); name = av_strdup(buf); provider_name = av_strdup(""); if (name && provider_name) { new_service(ts, sid, provider_name, name); } else { av_freep(&name); av_freep(&provider_name); } } } ts->stop_parse = 1; /* remove filter */ mpegts_close_filter(ts, ts->pat_filter); ts->pat_filter = NULL; }
static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end; int sid, pmt_pid; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "PAT:\n"); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != PAT_TID) return; clear_programs(ts); for(;;) { sid = get16(&p, p_end); if (sid < 0) break; pmt_pid = get16(&p, p_end) & 0x1fff; if (pmt_pid < 0) break; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x pid=0x%x\n", sid, pmt_pid); #endif if (sid == 0x0000) { /* NIT info */ } else { av_new_program(ts->stream, sid); ts->stop_parse--; mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1); add_pat_entry(ts, sid); add_pid_to_pmt(ts, sid, 0); //add pat pid to program add_pid_to_pmt(ts, sid, pmt_pid); } } /* not found */ ts->stop_parse++; mpegts_close_filter(ts, filter); }
static void pat_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end; int sid, pmt_pid; #ifdef DEBUG_SI printf("PAT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != PAT_TID) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; pmt_pid = get16(&p, p_end) & 0x1fff; if (pmt_pid < 0) break; #ifdef DEBUG_SI printf("sid=0x%x pid=0x%x\n", sid, pmt_pid); #endif if (sid == 0x0000) { /* NIT info */ } else { if (ts->req_sid == sid) { ts->pmt_filter = mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1); goto found; } } } /* not found */ ts->set_service_cb(ts->set_service_opaque, -1); found: mpegts_close_filter(ts, ts->pat_filter); ts->pat_filter = NULL; }
static int hap_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { HapContext *ctx = avctx->priv_data; ThreadFrame tframe; int ret, length; int blocks = avctx->coded_width * avctx->coded_height / (TEXTURE_BLOCK_W * TEXTURE_BLOCK_H); bytestream2_init(&ctx->gbc, avpkt->data, avpkt->size); /* Check for section header */ length = parse_section_header(avctx); if (length < 0) { av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n"); return length; } /* Prepare the texture buffer and decompress function */ ret = setup_texture(avctx, length); if (ret < 0) return ret; /* Get the output frame ready to receive data */ tframe.f = data; ret = ff_thread_get_buffer(avctx, &tframe, 0); if (ret < 0) return ret; if (avctx->codec->update_thread_context) ff_thread_finish_setup(avctx); /* Use the decompress function on the texture, one block per thread */ avctx->execute2(avctx, decompress_texture_thread, tframe.f, NULL, blocks); /* Frame is ready to be output */ tframe.f->pict_type = AV_PICTURE_TYPE_I; tframe.f->key_frame = 1; *got_frame = 1; return avpkt->size; }
static int hap_parse_decode_instructions(HapContext *ctx, int size) { GetByteContext *gbc = &ctx->gbc; int section_size; enum HapSectionType section_type; int is_first_table = 1, had_offsets = 0, had_compressors = 0, had_sizes = 0; int i, ret; while (size > 0) { int stream_remaining = bytestream2_get_bytes_left(gbc); ret = parse_section_header(gbc, §ion_size, §ion_type); if (ret != 0) return ret; size -= stream_remaining - bytestream2_get_bytes_left(gbc); switch (section_type) { case HAP_ST_COMPRESSOR_TABLE: ret = ff_hap_set_chunk_count(ctx, section_size, is_first_table); if (ret != 0) return ret; for (i = 0; i < section_size; i++) { ctx->chunks[i].compressor = bytestream2_get_byte(gbc) << 4; } had_compressors = 1; is_first_table = 0; break; case HAP_ST_SIZE_TABLE: ret = ff_hap_set_chunk_count(ctx, section_size / 4, is_first_table); if (ret != 0) return ret; for (i = 0; i < section_size / 4; i++) { ctx->chunks[i].compressed_size = bytestream2_get_le32(gbc); } had_sizes = 1; is_first_table = 0; break; case HAP_ST_OFFSET_TABLE: ret = ff_hap_set_chunk_count(ctx, section_size / 4, is_first_table); if (ret != 0) return ret; for (i = 0; i < section_size / 4; i++) { ctx->chunks[i].compressed_offset = bytestream2_get_le32(gbc); } had_offsets = 1; is_first_table = 0; break; default: break; } size -= section_size; } if (!had_sizes || !had_compressors) return AVERROR_INVALIDDATA; /* The offsets table is optional. If not present than calculate offsets by * summing the sizes of preceding chunks. */ if (!had_offsets) { size_t running_size = 0; for (i = 0; i < ctx->chunk_count; i++) { ctx->chunks[i].compressed_offset = running_size; running_size += ctx->chunks[i].compressed_size; } } return 0; }
static int hap_parse_frame_header(AVCodecContext *avctx) { HapContext *ctx = avctx->priv_data; GetByteContext *gbc = &ctx->gbc; int section_size; enum HapSectionType section_type; const char *compressorstr; int i, ret; ret = parse_section_header(gbc, §ion_size, §ion_type); if (ret != 0) return ret; if ((avctx->codec_tag == MKTAG('H','a','p','1') && (section_type & 0x0F) != HAP_FMT_RGBDXT1) || (avctx->codec_tag == MKTAG('H','a','p','5') && (section_type & 0x0F) != HAP_FMT_RGBADXT5) || (avctx->codec_tag == MKTAG('H','a','p','Y') && (section_type & 0x0F) != HAP_FMT_YCOCGDXT5)) { av_log(avctx, AV_LOG_ERROR, "Invalid texture format %#04x.\n", section_type & 0x0F); return AVERROR_INVALIDDATA; } switch (section_type & 0xF0) { case HAP_COMP_NONE: case HAP_COMP_SNAPPY: ret = ff_hap_set_chunk_count(ctx, 1, 1); if (ret == 0) { ctx->chunks[0].compressor = section_type & 0xF0; ctx->chunks[0].compressed_offset = 0; ctx->chunks[0].compressed_size = section_size; } if (ctx->chunks[0].compressor == HAP_COMP_NONE) { compressorstr = "none"; } else { compressorstr = "snappy"; } break; case HAP_COMP_COMPLEX: ret = parse_section_header(gbc, §ion_size, §ion_type); if (ret == 0 && section_type != HAP_ST_DECODE_INSTRUCTIONS) ret = AVERROR_INVALIDDATA; if (ret == 0) ret = hap_parse_decode_instructions(ctx, section_size); compressorstr = "complex"; break; default: ret = AVERROR_INVALIDDATA; break; } if (ret != 0) return ret; /* Check the frame is valid and read the uncompressed chunk sizes */ ctx->tex_size = 0; for (i = 0; i < ctx->chunk_count; i++) { HapChunk *chunk = &ctx->chunks[i]; /* Check the compressed buffer is valid */ if (chunk->compressed_offset + chunk->compressed_size > bytestream2_get_bytes_left(gbc)) return AVERROR_INVALIDDATA; /* Chunks are unpacked sequentially, ctx->tex_size is the uncompressed * size thus far */ chunk->uncompressed_offset = ctx->tex_size; /* Fill out uncompressed size */ if (chunk->compressor == HAP_COMP_SNAPPY) { GetByteContext gbc_tmp; int64_t uncompressed_size; bytestream2_init(&gbc_tmp, gbc->buffer + chunk->compressed_offset, chunk->compressed_size); uncompressed_size = ff_snappy_peek_uncompressed_length(&gbc_tmp); if (uncompressed_size < 0) { return uncompressed_size; } chunk->uncompressed_size = uncompressed_size; } else if (chunk->compressor == HAP_COMP_NONE) { chunk->uncompressed_size = chunk->compressed_size; } else { return AVERROR_INVALIDDATA; } ctx->tex_size += chunk->uncompressed_size; } av_log(avctx, AV_LOG_DEBUG, "%s compressor\n", compressorstr); return ret; }
static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type; char *name, *provider_name; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "SDT:\n"); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != SDT_TID) return; onid = get16(&p, p_end); if (onid < 0) return; val = get8(&p, p_end); if (val < 0) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; val = get8(&p, p_end); if (val < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case 0x48: service_type = get8(&p, p_end); if (service_type < 0) break; provider_name = getstr8(&p, p_end); if (!provider_name) break; name = getstr8(&p, p_end); if (name) { AVProgram *program = av_new_program(ts->stream, sid); if(program) av_set_program_name(program, provider_name, name); } av_free(name); av_free(provider_name); break; default: break; } p = desc_end; } p = desc_list_end; } }
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int program_info_length, pcr_pid, pid, stream_type; int desc_list_len, desc_len, desc_tag; int comp_page = 0, anc_page = 0; /* initialize to kill warnings */ char language[4] = {0}; /* initialize to kill warnings */ int has_hdmv_descr = 0; int has_dirac_descr = 0; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "PMT: len %i\n", section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num); #endif if (h->tid != PMT_TID) return; clear_program(ts, h->id); pcr_pid = get16(&p, p_end) & 0x1fff; if (pcr_pid < 0) return; add_pid_to_pmt(ts, h->id, pcr_pid); #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "pcr_pid=0x%x\n", pcr_pid); #endif program_info_length = get16(&p, p_end) & 0xfff; if (program_info_length < 0) return; while(program_info_length >= 2) { uint8_t tag, len; tag = get8(&p, p_end); len = get8(&p, p_end); if(len > program_info_length - 2) //something else is broken, exit the program_descriptors_loop break; program_info_length -= len + 2; if(tag == REGISTRATION_DESCRIPTOR && len >= 4) { uint8_t bytes[4]; bytes[0] = get8(&p, p_end); bytes[1] = get8(&p, p_end); bytes[2] = get8(&p, p_end); bytes[3] = get8(&p, p_end); len -= 4; if(bytes[0] == 'H' && bytes[1] == 'D' && bytes[2] == 'M' && bytes[3] == 'V') has_hdmv_descr = 1; } p += len; } p += program_info_length; if (p >= p_end) return; for(;;) { language[0] = 0; st = 0; stream_type = get8(&p, p_end); if (stream_type < 0) break; pid = get16(&p, p_end) & 0x1fff; if (pid < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; if (stream_type == STREAM_TYPE_PRIVATE_DATA) { if((desc_tag == 0x6A) || (desc_tag == 0x7A)) { /*assume DVB AC-3 Audio*/ stream_type = STREAM_TYPE_AUDIO_AC3; } else if(desc_tag == 0x7B) { /* DVB DTS audio */ stream_type = STREAM_TYPE_AUDIO_DTS; } } desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case DVB_SUBT_DESCID: if (stream_type == STREAM_TYPE_PRIVATE_DATA) stream_type = STREAM_TYPE_SUBTITLE_DVB; language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; get8(&p, desc_end); comp_page = get16(&p, desc_end); anc_page = get16(&p, desc_end); break; case 0x0a: /* ISO 639 language descriptor */ language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; break; case REGISTRATION_DESCRIPTOR: /*MPEG-2 Registration descriptor */ { uint8_t bytes[4]; bytes[0] = get8(&p, desc_end); bytes[1] = get8(&p, desc_end); bytes[2] = get8(&p, desc_end); bytes[3] = get8(&p, desc_end); if(bytes[0] == 'd' && bytes[1] == 'r' && bytes[2] == 'a' && bytes[3] == 'c') has_dirac_descr = 1; break; } default: break; } p = desc_end; } p = desc_list_end; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "stream_type=%d pid=0x%x\n", stream_type, pid); #endif /* now create ffmpeg stream */ switch(stream_type) { case STREAM_TYPE_AUDIO_MPEG1: case STREAM_TYPE_AUDIO_MPEG2: case STREAM_TYPE_VIDEO_MPEG1: case STREAM_TYPE_VIDEO_MPEG2: case STREAM_TYPE_VIDEO_MPEG4: case STREAM_TYPE_VIDEO_H264: case STREAM_TYPE_VIDEO_VC1: case STREAM_TYPE_VIDEO_DIRAC: case STREAM_TYPE_AUDIO_AAC: case STREAM_TYPE_AUDIO_AC3: case STREAM_TYPE_AUDIO_DTS: case STREAM_TYPE_AUDIO_HDMV_DTS: case STREAM_TYPE_SUBTITLE_DVB: if((stream_type == STREAM_TYPE_AUDIO_HDMV_DTS && !has_hdmv_descr) || (stream_type == STREAM_TYPE_VIDEO_DIRAC && !has_dirac_descr)) break; if(ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES){ pes= ts->pids[pid]->u.pes_filter.opaque; st= pes->st; }else{ if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably pes = add_pes_stream(ts, pid, pcr_pid, stream_type); if (pes) st = new_pes_av_stream(pes, 0); } add_pid_to_pmt(ts, h->id, pid); if(st) av_program_add_stream_index(ts->stream, h->id, st->index); break; default: /* we ignore the other streams */ break; } if (st) { if (language[0] != 0) { memcpy(st->language, language, 4); } if (stream_type == STREAM_TYPE_SUBTITLE_DVB) { st->codec->sub_id = (anc_page << 16) | comp_page; } } } /* all parameters are there */ ts->stop_parse++; mpegts_close_filter(ts, filter); }
static void sdt_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type; char *name, *provider_name; #ifdef DEBUG_SI printf("SDT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != SDT_TID) return; onid = get16(&p, p_end); if (onid < 0) return; val = get8(&p, p_end); if (val < 0) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; val = get8(&p, p_end); if (val < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI printf("tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case 0x48: service_type = get8(&p, p_end); if (service_type < 0) break; provider_name = getstr8(&p, p_end); if (!provider_name) break; name = getstr8(&p, p_end); if (!name) break; new_service(ts, sid, provider_name, name); break; default: break; } p = desc_end; } p = desc_list_end; } ts->stop_parse = 1; /* remove filter */ mpegts_close_filter(ts, ts->sdt_filter); ts->sdt_filter = NULL; }
static void pmt_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end; int program_info_length, pcr_pid, pid, stream_type, desc_length; #ifdef DEBUG_SI printf("PMT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; #ifdef DEBUG_SI printf("sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num); #endif if (h->tid != PMT_TID || (ts->req_sid >= 0 && h->id != ts->req_sid) ) return; pcr_pid = get16(&p, p_end) & 0x1fff; if (pcr_pid < 0) return; ts->pcr_pid = pcr_pid; #ifdef DEBUG_SI printf("pcr_pid=0x%x\n", pcr_pid); #endif program_info_length = get16(&p, p_end) & 0xfff; if (program_info_length < 0) return; p += program_info_length; if (p >= p_end) return; for(;;) { stream_type = get8(&p, p_end); if (stream_type < 0) break; pid = get16(&p, p_end) & 0x1fff; if (pid < 0) break; desc_length = get16(&p, p_end) & 0xfff; if (desc_length < 0) break; p += desc_length; if (p > p_end) return; #ifdef DEBUG_SI printf("stream_type=%d pid=0x%x\n", stream_type, pid); #endif /* now create ffmpeg stream */ switch(stream_type) { case STREAM_TYPE_AUDIO_MPEG1: case STREAM_TYPE_AUDIO_MPEG2: case STREAM_TYPE_VIDEO_MPEG1: case STREAM_TYPE_VIDEO_MPEG2: case STREAM_TYPE_VIDEO_MPEG4: case STREAM_TYPE_VIDEO_H264: case STREAM_TYPE_AUDIO_AAC: case STREAM_TYPE_AUDIO_AC3: add_pes_stream(ts, pid, stream_type); break; default: /* we ignore the other streams */ break; } } /* all parameters are there */ ts->set_service_cb(ts->set_service_opaque, 0); mpegts_close_filter(ts, ts->pmt_filter); ts->pmt_filter = NULL; }
int parse_opal_event_log(char *buf, int buflen, struct opal_event_log_scn **r_log) { struct header_id elog_hdr_id[] = { HEADER_ORDER }; int rc; struct opal_v6_hdr hdr; struct opal_priv_hdr_scn *ph; int header_pos; struct header_id *hdr_data; char *start = buf; int nrsections = 0; int is_error = 0; int i; opal_event_log *log = NULL; int log_pos = 0; *r_log = NULL; while (buflen) { rc = parse_section_header(&hdr, buf, buflen); if (rc < 0) { break; } header_pos = header_id_lookup(elog_hdr_id, HEADER_ORDER_MAX, hdr.id); if (header_pos == -1) { printf("Unknown section header: %c%c at %lu:\n", hdr.id[0], hdr.id[1], buf-start); printf("Length: %u (incl 8 byte header)\n", hdr.length); printf("Hex:\n"); for (i = 8; i < hdr.length; i++) { printf("0x%02x ", *(buf+i)); if (i % 16) printf("\n"); } printf("Text (. = unprintable):\n"); for (i = 8; i < hdr.length; i++) { printf("%c", (isgraph(*(buf+i)) | isspace(*(buf+i))) ? *(buf+i) : '.'); } } hdr_data = &elog_hdr_id[header_pos]; nrsections++; if (hdr_data->pos != 0 && hdr_data->pos != nrsections && ((hdr_data->req & HEADER_REQ) || ((hdr_data->req & HEADER_REQ_W_ERROR) && is_error))) { fprintf(stderr, "ERROR %s: Section number %d should be " "%s, instead is 0x%02x%02x (%c%c)\n", __func__, nrsections, hdr_data->id, hdr.id[0], hdr.id[1], hdr.id[0], hdr.id[1]); rc = -1; break; } if (hdr_data->max == 0) { fprintf(stderr, "ERROR %s: Section %s has already appeared the " "required times and should not be seen again\n", __func__, hdr_data->id); } else if (hdr_data->max > 0) { hdr_data->max--; } if (strncmp(hdr.id, "PH", 2) == 0) { if (parse_priv_hdr_scn(&ph, &hdr, buf, buflen) == 0) { log = create_opal_event_log(ph->scn_count); if (!log) { free(ph); fprintf(stderr, "ERROR %s: Could not allocate internal log buffer\n", __func__); return -ENOMEM; } add_opal_event_log_scn(log, "PH", ph, log_pos++); } else { /* We didn't parse the private header and therefore couldn't malloc * the log array, must stop */ fprintf(stderr, "ERROR %s: Unable to parse private header section" " cannot continue\n", __func__); return -EINVAL; } } else if (strncmp(hdr.id, "UH", 2) == 0) { struct opal_usr_hdr_scn *usr; if (parse_usr_hdr_scn(&usr, &hdr, buf, buflen, &is_error) == 0) { add_opal_event_log_scn(log, "UH", usr, log_pos++); } } else if (strncmp(hdr.id, "PS", 2) == 0) { struct opal_src_scn *src; if (parse_src_scn(&src, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "PS", src, log_pos++); } } else if (strncmp(hdr.id, "EH", 2) == 0) { struct opal_eh_scn *eh; if (parse_eh_scn(&eh, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "EH", eh, log_pos++); } } else if (strncmp(hdr.id, "MT", 2) == 0) { struct opal_mtms_scn *mtms; if (parse_mtms_scn(&mtms, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "MT", mtms, log_pos++); } } else if (strncmp(hdr.id, "SS", 2) == 0) { struct opal_src_scn *src; if (parse_src_scn(&src, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "SS", src, log_pos++); } } else if (strncmp(hdr.id, "DH", 2) == 0) { struct opal_dh_scn *dh; if (parse_dh_scn(&dh, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "DH", dh, log_pos++); } } else if (strncmp(hdr.id, "SW", 2) == 0) { struct opal_sw_scn *sw; if (parse_sw_scn(&sw, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "SW", sw, log_pos++); } } else if (strncmp(hdr.id, "LP", 2) == 0) { struct opal_lp_scn *lp; if (parse_lp_scn(&lp, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "LP", lp, log_pos++); } } else if (strncmp(hdr.id, "LR", 2) == 0) { struct opal_lr_scn *lr; if (parse_lr_scn(&lr, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "LR", lr, log_pos++); } } else if (strncmp(hdr.id, "HM", 2) == 0) { struct opal_hm_scn *hm; if (parse_hm_scn(&hm, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "HM", hm, log_pos++); } } else if (strncmp(hdr.id, "EP", 2) == 0) { struct opal_ep_scn *ep; if (parse_ep_scn(&ep, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "EP", ep, log_pos++); } } else if (strncmp(hdr.id, "IE", 2) == 0) { struct opal_ie_scn *ie; if (parse_ie_scn(&ie, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "IE", ie, log_pos++); } } else if (strncmp(hdr.id, "MI", 2) == 0) { struct opal_mi_scn *mi; if (parse_mi_scn(&mi, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "MI", mi, log_pos++); } } else if (strncmp(hdr.id, "CH", 2) == 0) { struct opal_ch_scn *ch; if (parse_ch_scn(&ch, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "CH", ch, log_pos++); } } else if (strncmp(hdr.id, "UD", 2) == 0) { struct opal_ud_scn *ud; if (parse_ud_scn(&ud, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "UD", ud, log_pos++); } } else if (strncmp(hdr.id, "EI", 2) == 0) { struct opal_ei_scn *ei; if (parse_ei_scn(&ei, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "EI", ei, log_pos++); } } else if (strncmp(hdr.id, "ED", 2) == 0) { struct opal_ed_scn *ed; if (parse_ed_scn(&ed, &hdr, buf, buflen) == 0) { add_opal_event_log_scn(log, "ED", ed, log_pos++); } } buf += hdr.length; if (nrsections == ph->scn_count) break; } if(log) { /* we could get here but have failed to parse sections of have an * unexpectady truncated buffer pad log with NULLS */ char nulStr2[2] = {'\0','\0'}; for(i = log_pos; i < ph->scn_count; i++) { add_opal_event_log_scn(log, nulStr2, NULL, i); } *r_log = log; } for (i = 0; i < HEADER_ORDER_MAX; i++) { if (((elog_hdr_id[i].req & HEADER_REQ) || ((elog_hdr_id[i].req & HEADER_REQ_W_ERROR) && is_error)) && elog_hdr_id[i].max != 0) { fprintf(stderr,"ERROR %s: Truncated error log, expected section %s" " not found\n", __func__, elog_hdr_id[i].id); rc = -EINVAL; } } return rc; }
static void pmt_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int program_info_length, pcr_pid, pid, stream_type; int desc_list_len, desc_len, desc_tag; int comp_page = 0, anc_page = 0; /* initialize to kill warnings */ char language[4]; #ifdef DEBUG_SI printf("PMT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; #ifdef DEBUG_SI printf("sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num); #endif if (h->tid != PMT_TID || (ts->req_sid >= 0 && h->id != ts->req_sid) ) return; pcr_pid = get16(&p, p_end) & 0x1fff; if (pcr_pid < 0) return; ts->pcr_pid = pcr_pid; #ifdef DEBUG_SI printf("pcr_pid=0x%x\n", pcr_pid); #endif program_info_length = get16(&p, p_end) & 0xfff; if (program_info_length < 0) return; p += program_info_length; if (p >= p_end) return; for(;;) { language[0] = 0; st = 0; stream_type = get8(&p, p_end); if (stream_type < 0) break; pid = get16(&p, p_end) & 0x1fff; if (pid < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; if (stream_type == STREAM_TYPE_PRIVATE_DATA) { if((desc_tag == 0x6A) || (desc_tag == 0x7A)) { /*assume DVB AC-3 Audio*/ stream_type = STREAM_TYPE_AUDIO_AC3; } else if(desc_tag == 0x7B) { /* DVB DTS audio */ stream_type = STREAM_TYPE_AUDIO_DTS; } } desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI printf("tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case DVB_SUBT_DESCID: if (stream_type == STREAM_TYPE_PRIVATE_DATA) stream_type = STREAM_TYPE_SUBTITLE_DVB; language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; get8(&p, desc_end); comp_page = get16(&p, desc_end); anc_page = get16(&p, desc_end); break; case 0x0a: /* ISO 639 language descriptor */ language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; break; default: break; } p = desc_end; } p = desc_list_end; #ifdef DEBUG_SI printf("stream_type=%d pid=0x%x\n", stream_type, pid); #endif /* now create ffmpeg stream */ switch(stream_type) { case STREAM_TYPE_AUDIO_MPEG1: case STREAM_TYPE_AUDIO_MPEG2: case STREAM_TYPE_VIDEO_MPEG1: case STREAM_TYPE_VIDEO_MPEG2: case STREAM_TYPE_VIDEO_MPEG4: case STREAM_TYPE_VIDEO_H264: case STREAM_TYPE_AUDIO_AAC: case STREAM_TYPE_AUDIO_AC3: case STREAM_TYPE_AUDIO_DTS: case STREAM_TYPE_SUBTITLE_DVB: pes = add_pes_stream(ts, pid, stream_type); if (pes) st = new_pes_av_stream(pes, 0); break; default: /* we ignore the other streams */ break; } if (st) { if (language[0] != 0) { st->language[0] = language[0]; st->language[1] = language[1]; st->language[2] = language[2]; st->language[3] = language[3]; } if (stream_type == STREAM_TYPE_SUBTITLE_DVB) { st->codec->sub_id = (anc_page << 16) | comp_page; } } } /* all parameters are there */ ts->set_service_cb(ts->set_service_opaque, 0); mpegts_close_filter(ts, ts->pmt_filter); ts->pmt_filter = NULL; }
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int program_info_length, pcr_pid, pid, stream_type; int desc_list_len, desc_len, desc_tag; int comp_page = 0, anc_page = 0; /* initialize to kill warnings */ char language[4] = {0}; /* initialize to kill warnings */ #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "PMT: len %i\n", section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num); #endif if (h->tid != PMT_TID) return; clear_program(ts, h->id); pcr_pid = get16(&p, p_end) & 0x1fff; if (pcr_pid < 0) return; add_pid_to_pmt(ts, h->id, pcr_pid); #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "pcr_pid=0x%x\n", pcr_pid); #endif program_info_length = get16(&p, p_end) & 0xfff; if (program_info_length < 0) return; p += program_info_length; if (p >= p_end) return; for(;;) { language[0] = 0; st = 0; stream_type = get8(&p, p_end); if (stream_type < 0) break; pid = get16(&p, p_end) & 0x1fff; if (pid < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; if (stream_type == STREAM_TYPE_PRIVATE_DATA) { if((desc_tag == 0x6A) || (desc_tag == 0x7A)) { /*assume DVB AC-3 Audio*/ stream_type = STREAM_TYPE_AUDIO_AC3; } else if(desc_tag == 0x7B) { /* DVB DTS audio */ stream_type = STREAM_TYPE_AUDIO_DTS; } } desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case DVB_SUBT_DESCID: if (stream_type == STREAM_TYPE_PRIVATE_DATA) stream_type = STREAM_TYPE_SUBTITLE_DVB; language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; get8(&p, desc_end); comp_page = get16(&p, desc_end); anc_page = get16(&p, desc_end); break; case 0x0a: /* ISO 639 language descriptor */ language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; break; default: break; } p = desc_end; } p = desc_list_end; #ifdef DEBUG_SI av_log(ts->stream, AV_LOG_DEBUG, "stream_type=%d pid=0x%x\n", stream_type, pid); #endif /* now create ffmpeg stream */ switch(stream_type) { case STREAM_TYPE_AUDIO_MPEG1: case STREAM_TYPE_AUDIO_MPEG2: case STREAM_TYPE_VIDEO_MPEG1: case STREAM_TYPE_VIDEO_MPEG2: case STREAM_TYPE_VIDEO_MPEG4: case STREAM_TYPE_VIDEO_H264: case STREAM_TYPE_VIDEO_VC1: case STREAM_TYPE_AUDIO_AAC: case STREAM_TYPE_AUDIO_AC3: case STREAM_TYPE_AUDIO_DTS: case STREAM_TYPE_SUBTITLE_DVB: if(ts->pids[pid]){ assert(ts->pids[pid]->type == MPEGTS_PES); pes= ts->pids[pid]->u.pes_filter.opaque; st= pes->st; }else{ pes = add_pes_stream(ts, pid, pcr_pid, stream_type); if (pes) st = new_pes_av_stream(pes, 0); } add_pid_to_pmt(ts, h->id, pid); break; default: /* we ignore the other streams */ break; } if (st) { if (language[0] != 0) { memcpy(st->language, language, 4); } if (stream_type == STREAM_TYPE_SUBTITLE_DVB) { st->codec->sub_id = (anc_page << 16) | comp_page; } } } /* all parameters are there */ ts->stop_parse++; mpegts_close_filter(ts, filter); }
int git_config_parse( git_config_parser *parser, git_config_parser_section_cb on_section, git_config_parser_variable_cb on_variable, git_config_parser_comment_cb on_comment, git_config_parser_eof_cb on_eof, void *data) { git_parse_ctx *ctx; char *current_section = NULL, *var_name, *var_value; int result = 0; ctx = &parser->ctx; skip_bom(ctx); for (; ctx->remain_len > 0; git_parse_advance_line(ctx)) { const char *line_start = parser->ctx.line; size_t line_len = parser->ctx.line_len; char c; if (git_parse_peek(&c, ctx, GIT_PARSE_PEEK_SKIP_WHITESPACE) < 0 && git_parse_peek(&c, ctx, 0) < 0) continue; switch (c) { case '[': /* section header, new section begins */ git__free(current_section); current_section = NULL; if ((result = parse_section_header(parser, ¤t_section)) == 0 && on_section) { result = on_section(parser, current_section, line_start, line_len, data); } break; case '\n': /* comment or whitespace-only */ case ' ': case '\t': case ';': case '#': if (on_comment) { result = on_comment(parser, line_start, line_len, data); } break; default: /* assume variable declaration */ if ((result = parse_variable(parser, &var_name, &var_value)) == 0 && on_variable) { result = on_variable(parser, current_section, var_name, var_value, line_start, line_len, data); } break; } if (result < 0) goto out; } if (on_eof) result = on_eof(parser, current_section, data); out: git__free(current_section); return result; }
static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) { MpegTSContext *ts = filter->u.section_filter.opaque; SectionHeader h1, *h = &h1; PESContext *pes; AVStream *st; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int program_info_length, pcr_pid, pid, stream_type; int desc_list_len, desc_len, desc_tag; int comp_page, anc_page; char language[4]; uint32_t prog_reg_desc = 0; /* registration descriptor */ #ifdef DEBUG dprintf(ts->stream, "PMT: len %i\n", section_len); av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n", h->id, h->sec_num, h->last_sec_num); if (h->tid != PMT_TID) return; clear_program(ts, h->id); pcr_pid = get16(&p, p_end) & 0x1fff; if (pcr_pid < 0) return; add_pid_to_pmt(ts, h->id, pcr_pid); dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid); program_info_length = get16(&p, p_end) & 0xfff; if (program_info_length < 0) return; while(program_info_length >= 2) { uint8_t tag, len; tag = get8(&p, p_end); len = get8(&p, p_end); if(len > program_info_length - 2) //something else is broken, exit the program_descriptors_loop break; program_info_length -= len + 2; if(tag == 0x05 && len >= 4) { // registration descriptor prog_reg_desc = bytestream_get_le32(&p); len -= 4; } p += len; } p += program_info_length; if (p >= p_end) return; for(;;) { st = 0; stream_type = get8(&p, p_end); if (stream_type < 0) break; pid = get16(&p, p_end) & 0x1fff; if (pid < 0) break; /* now create ffmpeg stream */ if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) { pes = ts->pids[pid]->u.pes_filter.opaque; st = pes->st; } else { if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably pes = add_pes_stream(ts, pid, pcr_pid, stream_type); if (pes) st = new_pes_av_stream(pes, prog_reg_desc, 0); } if (!st) return; add_pid_to_pmt(ts, h->id, pid); av_program_add_stream_index(ts->stream, h->id, st->index); desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; desc_len = get8(&p, desc_list_end); if (desc_len < 0) break; desc_end = p + desc_len; if (desc_end > desc_list_end) break; dprintf(ts->stream, "tag: 0x%02x len=%d\n", desc_tag, desc_len); if (st->codec->codec_id == CODEC_ID_PROBE && stream_type == STREAM_TYPE_PRIVATE_DATA) mpegts_find_stream_type(st, desc_tag, DESC_types); switch(desc_tag) { case 0x59: /* subtitling descriptor */ language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; get8(&p, desc_end); comp_page = get16(&p, desc_end); anc_page = get16(&p, desc_end); st->codec->sub_id = (anc_page << 16) | comp_page; av_metadata_set(&st->metadata, "language", language); break; case 0x0a: /* ISO 639 language descriptor */ language[0] = get8(&p, desc_end); language[1] = get8(&p, desc_end); language[2] = get8(&p, desc_end); language[3] = 0; av_metadata_set(&st->metadata, "language", language); break; case 0x05: /* registration descriptor */ st->codec->codec_tag = bytestream_get_le32(&p); dprintf(ts->stream, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag); if (st->codec->codec_id == CODEC_ID_PROBE && stream_type == STREAM_TYPE_PRIVATE_DATA) mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types); break; default: break; } p = desc_end; } p = desc_list_end; } /* all parameters are there */ ts->stop_parse++; mpegts_close_filter(ts, filter); }