FFmpeg源码分析:av_parser_parse2()解析数据包

FFmpeg源码分析:av_parser_parse2()解析数据包​在FFmpeg的libavcodec模块提供解析数据包和编解码功能。其中,av_parser_parse2()函数用来解析数据包,在使用av_read_frame()读取音视频帧时,会调用到该函数进行数据包解析。关于读取音视频帧的源码分析请查看:av_read_frame()文章。​

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺

在FFmpeg的libavcodec模块提供解析数据包和编解码功能。其中,av_parser_parse2()函数用来解析数据包,在使用av_read_frame()读取音视频帧时,会调用到该函数进行数据包解析。关于读取音视频帧的源码分析请查看:av_read_frame()文章

目录

一、av_parser_parse2源码分析

1、av_parser_parse2调用示例

2、av_parser_parse2函数源码

3、AVCodecParserContext解析器上下文

4、AVCodecParser解析器结构体

5、解析器列表

二、h264解析器分析

1、 h264解析器结构体

2、 h264_parse函数源码

3、ff_h264_decode_extradata函数

4、 h264_find_frame_end函数

5、ff_combine_frame函数

6、parse_nal_units


av_parser_parse2函数完整解析流程如下图所示:

FFmpeg源码分析:av_parser_parse2()解析数据包

 

一、av_parser_parse2源码分析

1、av_parser_parse2调用示例

av_parser_parse2()函数的声明位于libavcodec/avcodec.h,函数API调用示例如下:

while(in_len) {
   len = av_parser_parse2(myparser, AVCodecContext, &data, &size,
						  in_data, in_len, pts, dts, pos);
   in_data += len;
   in_len  -= len;

   if(size)
	  decode_frame(data, size);
}

2、av_parser_parse2函数源码

函数实现位于libavcodec/parser.c,具体代码如下:

int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx,
                     uint8_t **poutbuf, int *poutbuf_size,
                     const uint8_t *buf, int buf_size,
                     int64_t pts, int64_t dts, int64_t pos)
{
    int index, i;
    uint8_t dummy_buf[AV_INPUT_BUFFER_PADDING_SIZE];

    if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) {
        s->next_frame_offset =
        s->cur_offset        = pos;
        s->flags            |= PARSER_FLAG_FETCHED_OFFSET;
    }
    if (buf_size == 0) {
        /* padding is always necessary even if EOF, so we add it here */
        memset(dummy_buf, 0, sizeof(dummy_buf));
        buf = dummy_buf;
    } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) {
        /* add a new packet descriptor */
        i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
        s->cur_frame_start_index = i;
        s->cur_frame_offset[i]   = s->cur_offset;
        s->cur_frame_end[i]      = s->cur_offset + buf_size;
        s->cur_frame_pts[i]      = pts;
        s->cur_frame_dts[i]      = dts;
        s->cur_frame_pos[i]      = pos;
    }
    if (s->fetch_timestamp) {
        s->fetch_timestamp = 0;
        s->last_pts        = s->pts;
        s->last_dts        = s->dts;
        s->last_pos        = s->pos;
        ff_fetch_timestamp(s, 0, 0, 0);
    }
    // 解析数据包,返回值可能为负数
    index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf,
                                    poutbuf_size, buf, buf_size);
    // 更新文件指针
    if (*poutbuf_size) {
        s->frame_offset = s->next_frame_offset;
        // 偏移到下一帧的位置
        s->next_frame_offset = s->cur_offset + index;
        s->fetch_timestamp   = 1;
    } else {
        *poutbuf = NULL;
    }
    if (index < 0)
        index = 0;
    s->cur_offset += index;
    return index;
}

3、AVCodecParserContext解析器上下文

这里主要调用s->parser->parse()进行解析,s即为AVCodecParserContext 结构体,位于libavcodec/avcodec.h,具体如下:

typedef struct AVCodecParserContext {
    void *priv_data;
    struct AVCodecParser *parser;
    int64_t frame_offset;
    int64_t cur_offset;
    int64_t next_frame_offset;
    int pict_type;
    int repeat_pict;
    int64_t pts;      // 当前帧pts
    int64_t dts;      // 当前帧dts
    int64_t last_pts; // 上一帧pts
    int64_t last_dts; // 上一帧dts
    int fetch_timestamp;

    int cur_frame_start_index;
    int64_t cur_frame_offset[AV_PARSER_PTS_NB];
    int64_t cur_frame_pts[AV_PARSER_PTS_NB];
    int64_t cur_frame_dts[AV_PARSER_PTS_NB];
    int flags;
    int64_t offset;
    int64_t cur_frame_end[AV_PARSER_PTS_NB];

    // 关键帧标志,1代表关键帧,0代表非关键帧
    int key_frame;
    int dts_sync_point;
    int dts_ref_dts_delta;
    int pts_dts_delta;
    int64_t cur_frame_pos[AV_PARSER_PTS_NB];

    // 当前帧position位置
    int64_t pos;
    // 上一帧position位置
    int64_t last_pos;
    // 帧时长
    int duration;

    enum AVFieldOrder field_order;
    enum AVPictureStructure picture_structure;
    int output_picture_number;
    int width;
    int height;
    int coded_width;
    int coded_height;

    // 视频为AVPixelFormat枚举类型,音频为AVSampleFormat枚举类型
    int format;
} AVCodecParserContext;

4、AVCodecParser解析器结构体

AVCodecParserContext有个参数是parser,为AVCodecParser结构体,具体如下:

typedef struct AVCodecParser {
    int codec_ids[5];
    int priv_data_size;
    int (*parser_init)(AVCodecParserContext *s);
    int (*parser_parse)(AVCodecParserContext *s,
                        AVCodecContext *avctx,
                        const uint8_t **poutbuf, int *poutbuf_size,
                        const uint8_t *buf, int buf_size);
    void (*parser_close)(AVCodecParserContext *s);
    int (*split)(AVCodecContext *avctx, const uint8_t *buf, int buf_size);
#if FF_API_NEXT
    struct AVCodecParser *next;
#endif
} AVCodecParser;

5、解析器列表

所有解析器声明在libavcodec/parsers.c中,编译时会自动生成parser_list.c,解析器以链表结构存储,解析器列表如下:

extern AVCodecParser ff_aac_parser;
extern AVCodecParser ff_aac_latm_parser;
extern AVCodecParser ff_ac3_parser;
extern AVCodecParser ff_adx_parser;
extern AVCodecParser ff_av1_parser;
extern AVCodecParser ff_avs2_parser;
extern AVCodecParser ff_avs3_parser;
extern AVCodecParser ff_bmp_parser;
extern AVCodecParser ff_cavsvideo_parser;
extern AVCodecParser ff_cook_parser;
extern AVCodecParser ff_cri_parser;
extern AVCodecParser ff_dca_parser;
extern AVCodecParser ff_dirac_parser;
extern AVCodecParser ff_dnxhd_parser;
extern AVCodecParser ff_dolby_e_parser;
extern AVCodecParser ff_dpx_parser;
extern AVCodecParser ff_dvaudio_parser;
extern AVCodecParser ff_dvbsub_parser;
extern AVCodecParser ff_dvdsub_parser;
extern AVCodecParser ff_dvd_nav_parser;
extern AVCodecParser ff_flac_parser;
extern AVCodecParser ff_g723_1_parser;
extern AVCodecParser ff_g729_parser;
extern AVCodecParser ff_gif_parser;
extern AVCodecParser ff_gsm_parser;
extern AVCodecParser ff_h261_parser;
extern AVCodecParser ff_h263_parser;
extern AVCodecParser ff_h264_parser;
extern AVCodecParser ff_hevc_parser;
extern AVCodecParser ff_ipu_parser;
extern AVCodecParser ff_jpeg2000_parser;
extern AVCodecParser ff_mjpeg_parser;
extern AVCodecParser ff_mlp_parser;
extern AVCodecParser ff_mpeg4video_parser;
extern AVCodecParser ff_mpegaudio_parser;
extern AVCodecParser ff_mpegvideo_parser;
extern AVCodecParser ff_opus_parser;
extern AVCodecParser ff_png_parser;
extern AVCodecParser ff_pnm_parser;
extern AVCodecParser ff_rv30_parser;
extern AVCodecParser ff_rv40_parser;
extern AVCodecParser ff_sbc_parser;
extern AVCodecParser ff_sipr_parser;
extern AVCodecParser ff_tak_parser;
extern AVCodecParser ff_vc1_parser;
extern AVCodecParser ff_vorbis_parser;
extern AVCodecParser ff_vp3_parser;
extern AVCodecParser ff_vp8_parser;
extern AVCodecParser ff_vp9_parser;
extern AVCodecParser ff_webp_parser;
extern AVCodecParser ff_xbm_parser;
extern AVCodecParser ff_xma_parser;

二、h264解析器分析

1、 h264解析器结构体

以h264解析器为例,对应的解析器结构体为ff_h264_parser,位于libavcodec/h264_parser.c,结构体如下:

AVCodecParser ff_h264_parser = {
    .codec_ids      = { AV_CODEC_ID_H264 },
    .priv_data_size = sizeof(H264ParseContext),
    .parser_init    = init,
    .parser_parse   = h264_parse,
    .parser_close   = h264_close,
    .split          = h264_split,
};

2、 h264_parse函数源码

这里的parser_parse函数指针指向h264_parse,我们来看下h264_parse()的源码(位于libavcodec/h264_parser.c):

static int h264_parse(AVCodecParserContext *s,
                      AVCodecContext *avctx,
                      const uint8_t **poutbuf, int *poutbuf_size,
                      const uint8_t *buf, int buf_size)
{
    H264ParseContext *p = s->priv_data;
    ParseContext *pc = &p->pc;
    int next;

    if (!p->got_first) {
        p->got_first = 1;
        if (avctx->extradata_size) {
			// 解析额外数据:avcC,包含sps和pps等信息
            ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
                                     &p->ps, &p->is_avc, &p->nal_length_size,
                                     avctx->err_recognition, avctx);
        }
    }
    if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
        next = buf_size;
    } else {
		// 找到帧结束符:FFmpeg使用下一帧的start_code作为当前帧结束符
        next = h264_find_frame_end(p, buf, buf_size, avctx);
        // 开始组帧
        if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
            *poutbuf      = NULL;
            *poutbuf_size = 0;
            return buf_size;
        }
        if (next < 0 && next != END_NOT_FOUND) {
            av_assert1(pc->last_index + next >= 0);
            h264_find_frame_end(p, &pc->buffer[pc->last_index + next], -next, avctx);
        }
    }
    // 解析NAL单元
    parse_nal_units(s, avctx, buf, buf_size);

    if (avctx->framerate.num)
        avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
    if (p->sei.picture_timing.cpb_removal_delay >= 0) {
        s->dts_sync_point    = p->sei.buffering_period.present;
        s->dts_ref_dts_delta = p->sei.picture_timing.cpb_removal_delay;
        s->pts_dts_delta     = p->sei.picture_timing.dpb_output_delay;
    } else {
        s->dts_sync_point    = INT_MIN;
        s->dts_ref_dts_delta = INT_MIN;
        s->pts_dts_delta     = INT_MIN;
    }
    if (s->flags & PARSER_FLAG_ONCE) {
        s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
    }
    if (s->dts_sync_point >= 0) {
        int64_t den = avctx->time_base.den * (int64_t)avctx->pkt_timebase.num;
        if (den > 0) {
            int64_t num = avctx->time_base.num * (int64_t)avctx->pkt_timebase.den;
            if (s->dts != AV_NOPTS_VALUE) {
                // 从stream中获取到dts,更新引用时间戳
                p->reference_dts = s->dts - av_rescale(s->dts_ref_dts_delta, num, den);
            } else if (p->reference_dts != AV_NOPTS_VALUE) {
                // 基于引用时间戳计算dts
                s->dts = p->reference_dts + av_rescale(s->dts_ref_dts_delta, num, den);
            }
            if (p->reference_dts != AV_NOPTS_VALUE && s->pts == AV_NOPTS_VALUE)
                s->pts = s->dts + av_rescale(s->pts_dts_delta, num, den);
            if (s->dts_sync_point > 0)
                p->reference_dts = s->dts;
        }
    }
    *poutbuf      = buf;
    *poutbuf_size = buf_size;
    return next;
}

由此可见,h264解析过程分为4个步骤:

  • 调用ff_h264_decode_extradata()解析额外数据;
  • 调用h264_find_frame_end()寻找帧结束符;
  • 调用ff_combine_frame()执行组帧;
  • 调用parse_nal_units()解析NAL单元;

3、ff_h264_decode_extradata函数

如果是第一帧,先解析extradata,对于h264编码,就是解析avcC,包含sps和pps参数。然后找到帧结束符,默认为下一帧的起始码start_code作为当前帧的结束符。接着解析NAL单元,更新dts时间戳。我们来看下解析extradata的代码(位于libavcodec/h264_parse.c):

int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
                             int *is_avc, int *nal_length_size,
                             int err_recognition, void *logctx)
{
    int ret;
    if (!data || size <= 0)
        return -1;
    if (data[0] == 1) {
        int i, cnt, nalsize;
        const uint8_t *p = data;
        *is_avc = 1;
        if (size < 7) {
            return AVERROR_INVALIDDATA;
        }
        // 从avcC解析sps
        cnt = *(p + 5) & 0x1f; // sps数量
        p  += 6;
        for (i = 0; i < cnt; i++) {
            nalsize = AV_RB16(p) + 2;
            if (nalsize > size - (p - data))
                return AVERROR_INVALIDDATA;
            ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
            if (ret < 0) {
                return ret;
            }
            p += nalsize;
        }
        // 从avcC解析pps
        cnt = *(p++); // pps数量
        for (i = 0; i < cnt; i++) {
            nalsize = AV_RB16(p) + 2;
            if (nalsize > size - (p - data))
                return AVERROR_INVALIDDATA;
            ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
            if (ret < 0) {
                return ret;
            }
            p += nalsize;
        }
        // 存储正确的NAL长度
        *nal_length_size = (data[4] & 0x03) + 1;
    } else {
        *is_avc = 0;
        ret = decode_extradata_ps(data, size, ps, 0, logctx);
        if (ret < 0)
            return ret;
    }
    return size;
}

4、 h264_find_frame_end函数

接着调用h264_find_frame_end()找到帧结束符,代码位于libavcodec/h264_parser.c,具体如下:

static int h264_find_frame_end(H264ParseContext *p, const uint8_t *buf,
                               int buf_size, void *logctx)
{
    int i, j;
    uint32_t state;
    ParseContext *pc = &p->pc;
    int next_avc = p->is_avc ? 0 : buf_size;
    state = pc->state;
    if (state > 13)
        state = 7;

    for (i = 0; i < buf_size; i++) {
        if (i >= next_avc) {
            int nalsize = 0;
            i = next_avc;
            for (j = 0; j < p->nal_length_size; j++)
                nalsize = (nalsize << 8) | buf[i++];
            if (nalsize <= 0 || nalsize > buf_size - i) {
                return buf_size;
            }
            next_avc = i + nalsize;
            state    = 5;
        }

        if (state == 7) {
            i += p->h264dsp.startcode_find_candidate(buf + i, next_avc - i);
            if (i < next_avc)
                state = 2;
        } else if (state <= 2) {
            if (buf[i] == 1)
                state ^= 5;
            else if (buf[i])
                state = 7;
            else
                state >>= 1;
        } else if (state <= 5) {
            int nalu_type = buf[i] & 0x1F;
            if (nalu_type == H264_NAL_SEI || nalu_type == H264_NAL_SPS ||
                nalu_type == H264_NAL_PPS || nalu_type == H264_NAL_AUD) {
                if (pc->frame_start_found) {
                    i++;
                    goto found;
                }
            } else if (nalu_type == H264_NAL_SLICE || nalu_type == H264_NAL_DPA ||
                       nalu_type == H264_NAL_IDR_SLICE) {
                state += 8;
                continue;
            }
            state = 7;
        } else {
            unsigned int mb, last_mb = p->parse_last_mb;
            GetBitContext gb;
            p->parse_history[p->parse_history_count++] = buf[i];

            init_get_bits(&gb, p->parse_history, 8*p->parse_history_count);
            mb= get_ue_golomb_long(&gb);
            if (get_bits_left(&gb) > 0 || p->parse_history_count > 5) {
                p->parse_last_mb = mb;
                if (pc->frame_start_found) {
                    if (mb <= last_mb) {
                        i -= p->parse_history_count - 1;
                        p->parse_history_count = 0;
                        goto found;
                    }
                } else
                    pc->frame_start_found = 1;
                p->parse_history_count = 0;
                state = 7;
            }
        }
    }
    pc->state = state;
    if (p->is_avc)
        return next_avc;
    return END_NOT_FOUND;

found:
    pc->state             = 7;
    pc->frame_start_found = 0;
    if (p->is_avc)
        return next_avc;
    return i - (state & 5);
}

5、ff_combine_frame函数

找到帧结束符后,调用ff_combine_frame()进行组帧,拼接成一个完整的音视频帧。代码位于libavcodec/parser.c,具体如下:

int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
{
    /* Copy overread bytes from last frame into buffer. */
    for (; pc->overread > 0; pc->overread--)
        pc->buffer[pc->index++] = pc->buffer[pc->overread_index++];

    if (next > *buf_size)
        return AVERROR(EINVAL);

    /* flush remaining if EOF */
    if (!*buf_size && next == END_NOT_FOUND)
        next = 0;

    pc->last_index = pc->index;
    /* copy into buffer end return */
    if (next == END_NOT_FOUND) {
        void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
                                           *buf_size + pc->index +
                                           AV_INPUT_BUFFER_PADDING_SIZE);
        if (!new_buffer) {
            pc->index = 0;
            return AVERROR(ENOMEM);
        }
        pc->buffer = new_buffer;
        memcpy(&pc->buffer[pc->index], *buf, *buf_size);
        pc->index += *buf_size;
        return -1;
    }

    *buf_size          =
    pc->overread_index = pc->index + next;
    if (pc->index) {
        void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size,
                                           next + pc->index +
                                           AV_INPUT_BUFFER_PADDING_SIZE);
        if (!new_buffer) {
            pc->overread_index =
            pc->index = 0;
            return AVERROR(ENOMEM);
        }
        pc->buffer = new_buffer;
        if (next > -AV_INPUT_BUFFER_PADDING_SIZE)
            memcpy(&pc->buffer[pc->index], *buf,
                   next + AV_INPUT_BUFFER_PADDING_SIZE);
        pc->index = 0;
        *buf      = pc->buffer;
    }

    if (next < -8) {
        pc->overread += -8 - next;
        next = -8;
    }
    /* store overread bytes */
    for (; next < 0; next++) {
        pc->state   = pc->state   << 8 | pc->buffer[pc->last_index + next];
        pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next];
        pc->overread++;
    }

    return 0;
}

6、parse_nal_units

最后是调用parse_nal_units()来解析NAL单元,位于libavcodec/h264_parser.c,具体代码如下:

static inline int parse_nal_units(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t * const buf, int buf_size)
{
H264ParseContext *p = s->priv_data;
H2645RBSP rbsp = { NULL };
H2645NAL nal = { NULL };
int buf_index, next_avc;
unsigned int pps_id;
unsigned int slice_type;
int state = -1, got_reset = 0;
int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
int field_poc[2];
int ret;
s->pict_type         = AV_PICTURE_TYPE_I;
s->key_frame         = 0;
s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
ff_h264_sei_uninit(&p->sei);
p->sei.frame_packing.arrangement_cancel_flag = -1;
if (!buf_size)
return 0;
av_fast_padded_malloc(&rbsp.rbsp_buffer, &rbsp.rbsp_buffer_alloc_size, buf_size);
if (!rbsp.rbsp_buffer)
return AVERROR(ENOMEM);
buf_index     = 0;
next_avc      = p->is_avc ? 0 : buf_size;
for (;;) {
const SPS *sps;
int src_length, consumed, nalsize = 0;
if (buf_index >= next_avc) {
// 获取NAL长度
nalsize = get_nalsize(p->nal_length_size, buf, buf_size, &buf_index, avctx);
if (nalsize < 0)
break;
next_avc = buf_index + nalsize;
} else {
// 找到起始码
buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
if (buf_index >= buf_size)
break;
if (buf_index >= next_avc)
continue;
}
src_length = next_avc - buf_index;
state = buf[buf_index];
switch (state & 0x1f) {
case H264_NAL_SLICE:
case H264_NAL_IDR_SLICE:
// 只解析slice条带的头部
if ((state & 0x1f) == H264_NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
if (src_length > 60)
src_length = 60;
} else {
if (src_length > 1000)
src_length = 1000;
}
break;
}
// 抽取rbsp序列
consumed = ff_h2645_extract_rbsp(buf + buf_index, src_length, &rbsp, &nal, 1);
if (consumed < 0)
break;
buf_index += consumed;
ret = init_get_bits8(&nal.gb, nal.data, nal.size);
if (ret < 0)
goto fail;
get_bits1(&nal.gb);
nal.ref_idc = get_bits(&nal.gb, 2);
nal.type    = get_bits(&nal.gb, 5);
switch (nal.type) {
case H264_NAL_SPS: // SPS序列参数集
ff_h264_decode_seq_parameter_set(&nal.gb, avctx, &p->ps, 0);
break;
case H264_NAL_PPS: // PPS图像参数集
ff_h264_decode_picture_parameter_set(&nal.gb, avctx, &p->ps,
nal.size_bits);
break;
case H264_NAL_SEI: // 补充增强信息
ff_h264_sei_decode(&p->sei, &nal.gb, &p->ps, avctx);
break;
case H264_NAL_IDR_SLICE: //IDR立即刷新
s->key_frame = 1;
p->poc.prev_frame_num        = 0;
p->poc.prev_frame_num_offset = 0;
p->poc.prev_poc_msb          =
p->poc.prev_poc_lsb          = 0;
case H264_NAL_SLICE: // slice条带
get_ue_golomb_long(&nal.gb);
slice_type   = get_ue_golomb_31(&nal.gb);
s->pict_type = ff_h264_golomb_to_pict_type[slice_type % 5];
if (p->sei.recovery_point.recovery_frame_cnt >= 0) {
s->key_frame = 1;
}
pps_id = get_ue_golomb(&nal.gb);
if (pps_id >= MAX_PPS_COUNT) {
goto fail;
}
if (!p->ps.pps_list[pps_id]) {
goto fail;
}
av_buffer_unref(&p->ps.pps_ref);
p->ps.pps = NULL;
p->ps.sps = NULL;
p->ps.pps_ref = av_buffer_ref(p->ps.pps_list[pps_id]);
if (!p->ps.pps_ref)
goto fail;
p->ps.pps = (const PPS*)p->ps.pps_ref->data;
p->ps.sps = p->ps.pps->sps;
sps       = p->ps.sps;
// 检测未标记的关键帧
if (p->ps.sps->ref_frame_count <= 1 && p->ps.pps->ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
s->key_frame = 1;
p->poc.frame_num = get_bits(&nal.gb, sps->log2_max_frame_num);
s->coded_width  = 16 * sps->mb_width;
s->coded_height = 16 * sps->mb_height;
s->width        = s->coded_width  - (sps->crop_right + sps->crop_left);
s->height       = s->coded_height - (sps->crop_top   + sps->crop_bottom);
if (s->width <= 0 || s->height <= 0) {
s->width  = s->coded_width;
s->height = s->coded_height;
}
// 根据色度的idc来推测像素格式
switch (sps->bit_depth_luma) {
case 9:
if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P9;
else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P9;
else                                  s->format = AV_PIX_FMT_YUV420P9;
break;
case 10:
if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P10;
else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P10;
else                                  s->format = AV_PIX_FMT_YUV420P10;
break;
case 8:
if (sps->chroma_format_idc == 3)      s->format = AV_PIX_FMT_YUV444P;
else if (sps->chroma_format_idc == 2) s->format = AV_PIX_FMT_YUV422P;
else                                  s->format = AV_PIX_FMT_YUV420P;
break;
default:
s->format = AV_PIX_FMT_NONE;
}
avctx->profile = ff_h264_get_profile(sps);
avctx->level   = sps->level_idc;
if (sps->frame_mbs_only_flag) {
p->picture_structure = PICT_FRAME;
} else {
if (get_bits1(&nal.gb)) {
p->picture_structure = PICT_TOP_FIELD + get_bits1(&nal.gb);
} else {
p->picture_structure = PICT_FRAME;
}
}
if (nal.type == H264_NAL_IDR_SLICE)
get_ue_golomb_long(&nal.gb); /* idr_pic_id */
if (sps->poc_type == 0) {
p->poc.poc_lsb = get_bits(&nal.gb, sps->log2_max_poc_lsb);
if (p->ps.pps->pic_order_present == 1 &&
p->picture_structure == PICT_FRAME)
p->poc.delta_poc_bottom = get_se_golomb(&nal.gb);
}
if (sps->poc_type == 1 &&
!sps->delta_pic_order_always_zero_flag) {
p->poc.delta_poc[0] = get_se_golomb(&nal.gb);
if (p->ps.pps->pic_order_present == 1 &&
p->picture_structure == PICT_FRAME)
p->poc.delta_poc[1] = get_se_golomb(&nal.gb);
}
field_poc[0] = field_poc[1] = INT_MAX;
ret = ff_h264_init_poc(field_poc, &s->output_picture_number, sps,
&p->poc, p->picture_structure, nal.ref_idc);
if (ret < 0)
goto fail;
if (nal.ref_idc && nal.type != H264_NAL_IDR_SLICE) {
got_reset = scan_mmco_reset(s, &nal.gb, avctx);
if (got_reset < 0)
goto fail;
}
p->poc.prev_frame_num        = got_reset ? 0 : p->poc.frame_num;
p->poc.prev_frame_num_offset = got_reset ? 0 : p->poc.frame_num_offset;
if (nal.ref_idc != 0) {
if (!got_reset) {
p->poc.prev_poc_msb = p->poc.poc_msb;
p->poc.prev_poc_lsb = p->poc.poc_lsb;
} else {
p->poc.prev_poc_msb = 0;
p->poc.prev_poc_lsb =
p->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
}
}
if (p->sei.picture_timing.present) {
// 处理补充增强信息
ret = ff_h264_sei_process_picture_timing(&p->sei.picture_timing,
sps, avctx);
if (ret < 0) {
p->sei.picture_timing.present = 0;
}
}
if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
switch (p->sei.picture_timing.pic_struct) {
case H264_SEI_PIC_STRUCT_TOP_FIELD:
case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
s->repeat_pict = 0;
break;
case H264_SEI_PIC_STRUCT_FRAME:
case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
s->repeat_pict = 1;
break;
case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
s->repeat_pict = 2;
break;
case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
s->repeat_pict = 3;
break;
case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
s->repeat_pict = 5;
break;
default:
s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
break;
}
} else {
s->repeat_pict = p->picture_structure == PICT_FRAME ? 1 : 0;
}
if (p->picture_structure == PICT_FRAME) {
s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
if (sps->pic_struct_present_flag && p->sei.picture_timing.present) {
switch (p->sei.picture_timing.pic_struct) {
case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
s->field_order = AV_FIELD_TT;
break;
case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
s->field_order = AV_FIELD_BB;
break;
default:
s->field_order = AV_FIELD_PROGRESSIVE;
break;
}
} else {
if (field_poc[0] < field_poc[1])
s->field_order = AV_FIELD_TT;
else if (field_poc[0] > field_poc[1])
s->field_order = AV_FIELD_BB;
else
s->field_order = AV_FIELD_PROGRESSIVE;
}
} else {
if (p->picture_structure == PICT_TOP_FIELD)
s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
else
s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
if (p->poc.frame_num == p->last_frame_num &&
p->last_picture_structure != AV_PICTURE_STRUCTURE_UNKNOWN &&
p->last_picture_structure != AV_PICTURE_STRUCTURE_FRAME &&
p->last_picture_structure != s->picture_structure) {
if (p->last_picture_structure == AV_PICTURE_STRUCTURE_TOP_FIELD)
s->field_order = AV_FIELD_TT;
else
s->field_order = AV_FIELD_BB;
} else {
s->field_order = AV_FIELD_UNKNOWN;
}
p->last_picture_structure = s->picture_structure;
p->last_frame_num = p->poc.frame_num;
}
av_freep(&rbsp.rbsp_buffer);
return 0;
}
}
if (q264) {
av_freep(&rbsp.rbsp_buffer);
return 0;
}
av_log(avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
fail:
av_freep(&rbsp.rbsp_buffer);
return -1;
}

解析NAL单元流程主要是根据NAL类型来解析:SPS、PPS、IDR、SLICE、SEI。如果是slice类型,会检测未标记的关键帧、根据色度的idc来推测像素格式、处理补充增强信息。

至此,FFmpeg的解析数据包流程分析完毕。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/193259.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • 免费提供一个完整股票分析软件源码(包含开发文档)

    免费提供一个完整股票分析软件源码(包含开发文档)很多人想开发股票分析软件。这里提供一套完整的股票分析软件源码,包含开发文档。程序可以完全编译成功,并运行。价格200元,有需要的可以邮件联系。30796007@qq.com …

  • 区块链|CAP原理[通俗易懂]

    区块链|CAP原理[通俗易懂]分布式系统(distributedsystem)正变得越来越重要,大型网站几乎都是分布式的。分布式系统的最大难点,就是各个节点的状态如何同步。CAP定理是这方面的基本定理,也是理解分布式系统的起点。一、分布式系统的三个指标ConsistencyAvailabilityPartitiontolerance它们的第一个字母分别是C、A、P。EricBrewer说,这三个指标不可能同时做到。这个结论就叫做CAP定理。二、Partitiontolerance先看Parti

  • 计算机考研数据库题库及答案_数据结构历年考研真题

    计算机考研数据库题库及答案_数据结构历年考研真题在数据库的三级模式结构中,描述数据库中全体数据的全局逻辑结构和特征的是()。A.充分必要条件B.必要条件C.充分条件D.既不充分也不必要条件。A.需求分析阶段B.概念设计阶段C.逻辑设计阶段D.物理设计阶段。在关系模式R(U,F)中,Y∈XF+是X→Y是否成立的()。A.数据库系统B.文件系统C.人工管理D.数据项管理。A.网络系统B.数据库系统C.操作系统D.数据库。A.外模式B.内模式C.存储模式D.模式。…

    2022年10月26日
  • asp.net中英文转换

    asp.net中英文转换一、中英文切换主要是依靠资源文件(Resources):资源文件名称格式:"页面名称加后缀.resx"      资源文件分为本地[App_LocalResources]和全球化[App_GlobalResources]二、实现过程:  本地资源:1.添加文件夹[App_LocalResources]                    2.创建以.resx结尾的资源文件   …

    2022年10月24日
  • dumpbin的使用方法_dumpbin 的基础使用

    dumpbin的使用方法_dumpbin 的基础使用oneNeko于2020-10-17发布要查看exe依赖哪些动态库或某个DLL包含哪些接口函数依赖哪些动态库,可以使用depends工具或者vs自带的dumpbin工具,这里使用vs自带的dumpbin启动dumpbin是使用vs命令行的,有两种方法打开:1、打开vs,工具-命令行-开发者命令提示2、开始菜单-visualstdioxxxx-命令提示符使用使用很简单,语法如下:DUMPB…

  • 详解RPN网络[通俗易懂]

    详解RPN网络[通俗易懂]引言RPN(RegionProposalNetwork)是Faster-RCNN网络用于提取预选框(也就是RCNN中使用selectivesearch算法进行RegionProposal的部分),我们知道RCNN及Fast-RCNN中一个性能瓶颈就是提取预选框的部分,而RPN很好地对这个部分进行了优化,原因在于它将卷积神经网络引入了进来,使用特征提取的形式生成出预选框的位置从而降低了selectivesearch算法带来的计算时间上的开销。RPN(RegionProposalNetwor

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号