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;            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_AUDIO_HDMV_DTS:        case STREAM_TYPE_SUBTITLE_DVB:            if(stream_type == STREAM_TYPE_AUDIO_HDMV_DTS && !has_hdmv_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 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 mpegts_set_service(MpegTSContext *ts){    mpegts_open_section_filter(ts, PAT_PID,                                                pat_cb, ts, 1);}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;    }}/* scan services in a transport stream by looking at the SDT */static void mpegts_scan_sdt(MpegTSContext *ts){    mpegts_open_section_filter(ts, SDT_PID,                                                sdt_cb, ts, 1);}static int64_t get_pts(const uint8_t *p){    int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30;    pts |= (AV_RB16(p + 1) >> 1) << 15;    pts |=  AV_RB16(p + 3) >> 1;    return pts;}/* return non zero if a packet could be constructed */static void mpegts_push_data(MpegTSFilter *filter,                             const uint8_t *buf, int buf_size, int is_start){    PESContext *pes = filter->u.pes_filter.opaque;    MpegTSContext *ts = pes->ts;    const uint8_t *p;    int len, code;    if(!ts->pkt)        return;    if (is_start) {        pes->state = MPEGTS_HEADER;        pes->data_index = 0;    }    p = buf;    while (buf_size > 0) {        switch(pes->state) {        case MPEGTS_HEADER:            len = PES_START_SIZE - pes->data_index;            if (len > buf_size)                len = buf_size;            memcpy(pes->header + pes->data_index, p, len);            pes->data_index += len;            p += len;            buf_size -= len;            if (pes->data_index == PES_START_SIZE) {                /* we got all the PES or section header. We can now                   decide */#if 0                av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index);#endif                if (pes->header[0] == 0x00 && pes->header[1] == 0x00 &&                    pes->header[2] == 0x01) {                    /* it must be an mpeg2 PES stream */                    code = pes->header[3] | 0x100;                    if (!((code >= 0x1c0 && code <= 0x1df) ||                          (code >= 0x1e0 && code <= 0x1ef) ||                          (code == 0x1bd) || (code == 0x1fd)))                        goto skip;                    if (!pes->st) {                        /* allocate stream */                        new_pes_av_stream(pes, code);                    }                    pes->state = MPEGTS_PESHEADER_FILL;                    pes->total_size = AV_RB16(pes->header + 4);                    /* NOTE: a zero total size means the PES size is                       unbounded */                    if (pes->total_size)                        pes->total_size += 6;                    pes->pes_header_size = pes->header[8] + 9;                } else {                    /* otherwise, it should be a table */                    /* skip packet */                skip:                    pes->state = MPEGTS_SKIP;                    continue;                }            }            break;            /**********************************************/            /* PES packing parsing */        case MPEGTS_PESHEADER_FILL:            len = pes->pes_header_size - pes->data_index;            if (len > buf_size)                len = buf_size;            memcpy(pes->header + pes->data_index, p, len);            pes->data_index += len;            p += len;            buf_size -= len;            if (pes->data_index == pes->pes_header_size) {                const uint8_t *r;                unsigned int flags;                flags = pes->header[7];                r = pes->header + 9;                pes->pts = AV_NOPTS_VALUE;                pes->dts = AV_NOPTS_VALUE;                if ((flags & 0xc0) == 0x80) {                    pes->pts = get_pts(r);                    r += 5;                } else if ((flags & 0xc0) == 0xc0) {                    pes->pts = get_pts(r);                    r += 5;                    pes->dts = get_pts(r);                    r += 5;                }                /* we got the full header. We parse it and get the payload */                pes->state = MPEGTS_PAYLOAD;            }            break;        case MPEGTS_PAYLOAD:            if (pes->total_size) {                len = pes->total_size - pes->data_index;                if (len > buf_size)                    len = buf_size;            } else {                len = buf_size;            }            if (len > 0) {                AVPacket *pkt = ts->pkt;                if (pes->st && av_new_packet(pkt, len) == 0) {                    memcpy(pkt->data, p, len);                    pkt->stream_index = pes->st->index;                    pkt->pts = pes->pts;                    pkt->dts = pes->dts;                    /* reset pts values */                    pes->pts = AV_NOPTS_VALUE;                    pes->dts = AV_NOPTS_VALUE;                    ts->stop_parse = 1;                    return;                }            }            buf_size = 0;            break;        case MPEGTS_SKIP:            buf_size = 0;            break;        }    }}static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code){    AVStream *st;    int codec_type, codec_id;    switch(pes->stream_type){    case STREAM_TYPE_AUDIO_MPEG1:    case STREAM_TYPE_AUDIO_MPEG2:        codec_type = CODEC_TYPE_AUDIO;        codec_id = CODEC_ID_MP3;        break;    case STREAM_TYPE_VIDEO_MPEG1:    case STREAM_TYPE_VIDEO_MPEG2:        codec_type = CODEC_TYPE_VIDEO;        codec_id = CODEC_ID_MPEG2VIDEO;        break;    case STREAM_TYPE_VIDEO_MPEG4:        codec_type = CODEC_TYPE_VIDEO;        codec_id = CODEC_ID_MPEG4;        break;    case STREAM_TYPE_VIDEO_H264:        codec_type = CODEC_TYPE_VIDEO;        codec_id = CODEC_ID_H264;        break;    case STREAM_TYPE_VIDEO_VC1:        codec_type = CODEC_TYPE_VIDEO;        codec_id = CODEC_ID_VC1;        break;    case STREAM_TYPE_AUDIO_AAC:        codec_type = CODEC_TYPE_AUDIO;        codec_id = CODEC_ID_AAC;        break;    case STREAM_TYPE_AUDIO_AC3:        codec_type = CODEC_TYPE_AUDIO;        codec_id = CODEC_ID_AC3;        break;    case STREAM_TYPE_AUDIO_DTS:    case STREAM_TYPE_AUDIO_HDMV_DTS:        codec_type = CODEC_TYPE_AUDIO;        codec_id = CODEC_ID_DTS;        break;    case STREAM_TYPE_SUBTITLE_DVB:        codec_type = CODEC_TYPE_SUBTITLE;        codec_id = CODEC_ID_DVB_SUBTITLE;        break;    default:        if (code >= 0x1c0 && code <= 0x1df) {            codec_type = CODEC_TYPE_AUDIO;            codec_id = CODEC_ID_MP2;        } else if (code == 0x1bd) {            codec_type = CODEC_TYPE_AUDIO;            codec_id = CODEC_ID_AC3;        } else {            codec_type = CODEC_TYPE_VIDEO;            codec_id = CODEC_ID_MPEG1VIDEO;        }        break;    }    st = av_new_stream(pes->stream, pes->pid);    if (st) {        av_set_pts_info(st, 33, 1, 90000);        st->priv_data = pes;        st->codec->codec_type = codec_type;        st->codec->codec_id = codec_id;        st->need_parsing = AVSTREAM_PARSE_FULL;        pes->st = st;    }    return st;}static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type){    MpegTSFilter *tss;    PESContext *pes;    /* if no pid found, then add a pid context */    pes = av_mallocz(sizeof(PESContext));    if (!pes)        return 0;    pes->ts = ts;    pes->stream = ts->stream;    pes->pid = pid;    pes->pcr_pid = pcr_pid;    pes->stream_type = stream_type;    tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes);    if (!tss) {        av_free(pes);        return 0;    }    return pes;}/* handle one TS packet */static void handle_packet(MpegTSContext *ts, const uint8_t *packet){    AVFormatContext *s = ts->stream;    MpegTSFilter *tss;    int len, pid, cc, cc_ok, afc, is_start;    const uint8_t *p, *p_end;