FFmpeg解析TS私有文本流

 TS包的结构如下：

本文在FFmpeg 4.3.2的基础上修改avformat/mpegts.c中的handle_packet函数，添加了从188个字节的TS包中解析出，pid为0x12的私有流信息。代码做的事情主要是：跳过TS头部4个字节，跳过adaptation填充字节，然后跳过PES的头部，最后找到ES的Payload。

其中PES的结构如下：

 

 

在我的另外一篇博文里也有详细介绍：PES包结构解析_iChenwin的博客-CSDN博客 

最后上代码： 

/* handle one TS packet */
static int handle_packet(MpegTSContext *ts, AVFormatContext *fmt, const uint8_t *packet, int64_t pos)
{
    MpegTSFilter *tss;
    int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
        has_adaptation, has_payload;
    const uint8_t *p, *p_end;

    pid = AV_RB16(packet + 1) & 0x1fff;

    is_start = packet[1] & 0x40;

    // 私有流解析
    if (fmt != NULL && pid == 0x12 && is_start)
    {
        // The packet contains the desired data.
        int payload_offset = 4;                        //跳过TS头部4个字节
        if ((packet[3] >> 5) & 0x01) {                 //解析Adaptation Field字段，并跳过
            int adaptation_field_length = packet[payload_offset] + 1;
            payload_offset += adaptation_field_length;
        }
        //pes解析：https://blog.csdn.net/ichenwin/article/details/84946333
        payload_offset += 4; 							//跳过PES的起始码00 00 01 BD
        int pes_len = (packet[payload_offset]<<8) | (packet[payload_offset+1]);
        payload_offset += 2; 							//跳过PES的长度表示位

        int pes_header_left_len = packet[payload_offset+2];
        int es_len = pes_len - 3 - pes_header_left_len;		
        payload_offset += 3; 							    //跳过pes头前面3字节
        payload_offset += pes_header_left_len; 				//跳过pes头剩余字节，到达es数据

        const uint8_t *es_payload = packet + payload_offset;

        // Parse the es data as UTF-8.
        char es_data[188];
        memcpy(es_data, es_payload, es_len);
        es_data[es_len] = '\0';

        // parse_private_json(fmt, es_data);           //到这里已经完全解出自己的私有流，我的是json，所以调用自己写的json解析。

        //av_log(ts->stream, AV_LOG_ERROR, "pid %04x, payload:%02x %02x %02x %02x %02x %02x, len:%d,%d, ts:%s\n", pid,
        //	packet[0], packet[1], packet[2], packet[3], packet[4], packet[5], pes_len, es_len, text_data);
    }


    tss = ts->pids[pid];
    if (ts->auto_guess && !tss && is_start) {
        add_pes_stream(ts, pid, -1);
        tss = ts->pids[pid];
    }
    if (!tss)
        return 0;
    if (is_start)
        tss->discard = discard_pid(ts, pid);
    if (tss->discard)
        return 0;
    ts->current_pid = pid;

    afc = (packet[3] >> 4) & 3;
    if (afc == 0) /* reserved value */
        return 0;
    has_adaptation   = afc & 2;
    has_payload      = afc & 1;
    is_discontinuity = has_adaptation &&
                        packet[4] != 0 && /* with length > 0 */
                        (packet[5] & 0x80); /* and discontinuity indicated */

    /* continuity check (currently not used) */
    cc = (packet[3] & 0xf);
    expected_cc = has_payload ? (tss->last_cc + 1) & 0x0f : tss->last_cc;
    cc_ok = pid == 0x1FFF || // null packet PID
            is_discontinuity ||
            tss->last_cc < 0 ||
            expected_cc == cc;

    tss->last_cc = cc;
    if (!cc_ok) {
        av_log(ts->stream, AV_LOG_DEBUG,
                "Continuity check failed for pid %d expected %d got %d\n",
                pid, expected_cc, cc);
        if (tss->type == MPEGTS_PES) {
            PESContext *pc = tss->u.pes_filter.opaque;
            pc->flags |= AV_PKT_FLAG_CORRUPT;
        }
    }

    if (packet[1] & 0x80) {
        av_log(ts->stream, AV_LOG_DEBUG, "Packet had TEI flag set; marking as corrupt\n");
        if (tss->type == MPEGTS_PES) {
            PESContext *pc = tss->u.pes_filter.opaque;
            pc->flags |= AV_PKT_FLAG_CORRUPT;
        }
    }

    p = packet + 4;
    if (has_adaptation) {
        int64_t pcr_h;
        int pcr_l;
        if (parse_pcr(&pcr_h, &pcr_l, packet) == 0)
            tss->last_pcr = pcr_h * 300 + pcr_l;
        /* skip adaptation field */
        p += p[0] + 1;
    }
    /* if past the end of packet, ignore */
    p_end = packet + TS_PACKET_SIZE;
    if (p >= p_end || !has_payload)
        return 0;

    if (pos >= 0) {
        av_assert0(pos >= TS_PACKET_SIZE);
        ts->pos47_full = pos - TS_PACKET_SIZE;
    }

    if (tss->type == MPEGTS_SECTION) {
        if (is_start) {
            /* pointer field present */
            len = *p++;
            if (len > p_end - p)
                return 0;
            if (len && cc_ok) {
                /* write remaining section bytes */
                write_section_data(ts, tss,
                                    p, len, 0);
                /* check whether filter has been closed */
                if (!ts->pids[pid])
                    return 0;
            }
            p += len;
            if (p < p_end) {
                write_section_data(ts, tss,
                                    p, p_end - p, 1);
            }
        } else {
            if (cc_ok) {
                write_section_data(ts, tss,
                                    p, p_end - p, 0);
            }
        }

        // stop find_stream_info from waiting for more streams
        // when all programs have received a PMT
        if (ts->stream->ctx_flags & AVFMTCTX_NOHEADER && ts->scan_all_pmts <= 0) {
            int i;
            for (i = 0; i < ts->nb_prg; i++) {
                if (!ts->prg[i].pmt_found)
                    break;
            }
            if (i == ts->nb_prg && ts->nb_prg > 0) {
                int types = 0;
                for (i = 0; i < ts->stream->nb_streams; i++) {
                    AVStream *st = ts->stream->streams[i];
                    if (st->codecpar->codec_type >= 0)
                        types |= 1<<st->codecpar->codec_type;
                }
                if ((types & (1<<AVMEDIA_TYPE_AUDIO) && types & (1<<AVMEDIA_TYPE_VIDEO)) || pos > 100000) {
                    av_log(ts->stream, AV_LOG_DEBUG, "All programs have pmt, headers found\n");
                    ts->stream->ctx_flags &= ~AVFMTCTX_NOHEADER;
                }
            }
        }

    } else {
        int ret;
        // Note: The position here points actually behind the current packet.
        if (tss->type == MPEGTS_PES) {
            if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start,
                                                pos - ts->raw_packet_size)) < 0)
                return ret;
        }
    }

    return 0;
}