FFMPEG函数read_frame_internal()

最新推荐文章于 2023-03-14 17:49:08 发布
最新推荐文章于 2023-03-14 17:49:08 发布
阅读量460 收藏
点赞数
文章标签： ffmpeg python
原文链接：https://my.oschina.net/u/2326611/blog/809099
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

FFMPEG版本3.2release，文件位于libavformat/utils.c

函数read_frame_internal()主要功能分为三部分

static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
    int ret = 0, i, got_packet = 0;
    AVDictionary *metadata = NULL;

    av_init_packet(pkt);

    while (!got_packet && !s->internal->parse_queue) {
        AVStream *st;
        AVPacket cur_pkt;

        /* read next packet */
        ret = ff_read_packet(s, &cur_pkt);
        if (ret < 0) {
            if (ret == AVERROR(EAGAIN))
                return ret;
            /* flush the parsers */
            for (i = 0; i < s->nb_streams; i++) {
                st = s->streams[i];
                if (st->parser && st->need_parsing)
                    parse_packet(s, NULL, st->index);
            }
            /* all remaining packets are now in parse_queue =>
             * really terminate parsing */
            break;
        }
        ret = 0;
        st  = s->streams[cur_pkt.stream_index];

        /* update context if required */
        if (st->internal->need_context_update) {
            if (avcodec_is_open(st->internal->avctx)) {
                av_log(s, AV_LOG_DEBUG, "Demuxer context update while decoder is open, closing and trying to re-open\n");
                avcodec_close(st->internal->avctx);
                st->info->found_decoder = 0;
            }

            ret = avcodec_parameters_to_context(st->internal->avctx, st->codecpar);
            if (ret < 0)
                return ret;

#if FF_API_LAVF_AVCTX
FF_DISABLE_DEPRECATION_WARNINGS
            /* update deprecated public codec context */
            ret = avcodec_parameters_to_context(st->codec, st->codecpar);
            if (ret < 0)
                return ret;
FF_ENABLE_DEPRECATION_WARNINGS
#endif

            st->internal->need_context_update = 0;
        }

        if (cur_pkt.pts != AV_NOPTS_VALUE &&
            cur_pkt.dts != AV_NOPTS_VALUE &&
            cur_pkt.pts < cur_pkt.dts) {
            av_log(s, AV_LOG_WARNING,
                   "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
                   cur_pkt.stream_index,
                   av_ts2str(cur_pkt.pts),
                   av_ts2str(cur_pkt.dts),
                   cur_pkt.size);
        }
        if (s->debug & FF_FDEBUG_TS)
            av_log(s, AV_LOG_DEBUG,
                   "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%"PRId64", flags=%d\n",
                   cur_pkt.stream_index,
                   av_ts2str(cur_pkt.pts),
                   av_ts2str(cur_pkt.dts),
                   cur_pkt.size, cur_pkt.duration, cur_pkt.flags);

        if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
            st->parser = av_parser_init(st->codecpar->codec_id);
            if (!st->parser) {
                av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
                       "%s, packets or times may be invalid.\n",
                       avcodec_get_name(st->codecpar->codec_id));
                /* no parser available: just output the raw packets */
                st->need_parsing = AVSTREAM_PARSE_NONE;
            } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
                st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
            else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
                st->parser->flags |= PARSER_FLAG_ONCE;
            else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
                st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
        }

        if (!st->need_parsing || !st->parser) {
            /* no parsing needed: we just output the packet as is */
            *pkt = cur_pkt;
            compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
            if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
                (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
                ff_reduce_index(s, st->index);
                av_add_index_entry(st, pkt->pos, pkt->dts,
                                   0, 0, AVINDEX_KEYFRAME);
            }
            got_packet = 1;
        } else if (st->discard < AVDISCARD_ALL) {
            if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
                return ret;
            st->codecpar->sample_rate = st->internal->avctx->sample_rate;
            st->codecpar->bit_rate = st->internal->avctx->bit_rate;
            st->codecpar->channels = st->internal->avctx->channels;
            st->codecpar->channel_layout = st->internal->avctx->channel_layout;
            st->codecpar->codec_id = st->internal->avctx->codec_id;
        } else {
            /* free packet */
            av_packet_unref(&cur_pkt);
        }
        if (pkt->flags & AV_PKT_FLAG_KEY)
            st->skip_to_keyframe = 0;
        if (st->skip_to_keyframe) {
            av_packet_unref(&cur_pkt);
            if (got_packet) {
                *pkt = cur_pkt;
            }
            got_packet = 0;
        }
    }

    if (!got_packet && s->internal->parse_queue)
        ret = read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);

    if (ret >= 0) {
        AVStream *st = s->streams[pkt->stream_index];
        int discard_padding = 0;
        if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
            int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
            int64_t sample = ts_to_samples(st, pts);
            int duration = ts_to_samples(st, pkt->duration);
            int64_t end_sample = sample + duration;
            if (duration > 0 && end_sample >= st->first_discard_sample &&
                sample < st->last_discard_sample)
                discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
        }
        if (st->start_skip_samples && (pkt->pts == 0 || pkt->pts == RELATIVE_TS_BASE))
            st->skip_samples = st->start_skip_samples;
        if (st->skip_samples || discard_padding) {
            uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
            if (p) {
                AV_WL32(p, st->skip_samples);
                AV_WL32(p + 4, discard_padding);
                av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d / discard %d\n", st->skip_samples, discard_padding);
            }
            st->skip_samples = 0;
        }

        if (st->inject_global_side_data) {
            for (i = 0; i < st->nb_side_data; i++) {
                AVPacketSideData *src_sd = &st->side_data[i];
                uint8_t *dst_data;

                if (av_packet_get_side_data(pkt, src_sd->type, NULL))
                    continue;

                dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
                if (!dst_data) {
                    av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
                    continue;
                }

                memcpy(dst_data, src_sd->data, src_sd->size);
            }
            st->inject_global_side_data = 0;
        }

        if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
            av_packet_merge_side_data(pkt);
    }

    av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
    if (metadata) {
        s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
        av_dict_copy(&s->metadata, metadata, 0);
        av_dict_free(&metadata);
        av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
    }

#if FF_API_LAVF_AVCTX
    update_stream_avctx(s);
#endif

    if (s->debug & FF_FDEBUG_TS)
        av_log(s, AV_LOG_DEBUG,
               "read_frame_internal stream=%d, pts=%s, dts=%s, "
               "size=%d, duration=%"PRId64", flags=%d\n",
               pkt->stream_index,
               av_ts2str(pkt->pts),
               av_ts2str(pkt->dts),
               pkt->size, pkt->duration, pkt->flags);

    return ret;
}

 

函数ff_read_packet(AVFormatContext *s, AVPacket *pkt)

从指针AVFormatContext *pb读取音频或者视频数据，保存到pkt->data，同时得到音视频的编解码格式。

int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    int ret, i, err;
    AVStream *st;

    for (;;) {
        AVPacketList *pktl = s->internal->raw_packet_buffer;

        if (pktl) {
            *pkt = pktl->pkt;
            st   = s->streams[pkt->stream_index];
            if (s->internal->raw_packet_buffer_remaining_size <= 0)
                if ((err = probe_codec(s, st, NULL)) < 0)
                    return err;
            if (st->request_probe <= 0) {
                s->internal->raw_packet_buffer                 = pktl->next;
                s->internal->raw_packet_buffer_remaining_size += pkt->size;
                av_free(pktl);
                return 0;
            }
        }

        pkt->data = NULL;
        pkt->size = 0;
        av_init_packet(pkt);
        ret = s->iformat->read_packet(s, pkt);
        if (ret < 0) {
            /* Some demuxers return FFERROR_REDO when they consume
               data and discard it (ignored streams, junk, extradata).
               We must re-call the demuxer to get the real packet. */
            if (ret == FFERROR_REDO)
                continue;
            if (!pktl || ret == AVERROR(EAGAIN))
                return ret;
            for (i = 0; i < s->nb_streams; i++) {
                st = s->streams[i];
                if (st->probe_packets || st->request_probe > 0)
                    if ((err = probe_codec(s, st, NULL)) < 0)
                        return err;
                av_assert0(st->request_probe <= 0);
            }
            continue;
        }

        if (!pkt->buf) {
            AVPacket tmp = { 0 };
            ret = av_packet_ref(&tmp, pkt);
            if (ret < 0)
                return ret;
            *pkt = tmp;
        }

        if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
            (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
            av_log(s, AV_LOG_WARNING,
                   "Dropped corrupted packet (stream = %d)\n",
                   pkt->stream_index);
            av_packet_unref(pkt);
            continue;
        }

        if (pkt->stream_index >= (unsigned)s->nb_streams) {
            av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
            continue;
        }

        st = s->streams[pkt->stream_index];

        if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
            // correct first time stamps to negative values
            if (!is_relative(st->first_dts))
                st->first_dts = wrap_timestamp(st, st->first_dts);
            if (!is_relative(st->start_time))
                st->start_time = wrap_timestamp(st, st->start_time);
            if (!is_relative(st->cur_dts))
                st->cur_dts = wrap_timestamp(st, st->cur_dts);
        }

        pkt->dts = wrap_timestamp(st, pkt->dts);
        pkt->pts = wrap_timestamp(st, pkt->pts);

        force_codec_ids(s, st);

        /* TODO: audio: time filter; video: frame reordering (pts != dts) */
        if (s->use_wallclock_as_timestamps)
            pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);

        if (!pktl && st->request_probe <= 0)
            return ret;

        err = add_to_pktbuf(&s->internal->raw_packet_buffer, pkt,
                            &s->internal->raw_packet_buffer_end, 0);
        if (err)
            return err;
        s->internal->raw_packet_buffer_remaining_size -= pkt->size;

        if ((err = probe_codec(s, st, pkt)) < 0)
            return err;
    }
}

 

 

函数 parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)

如果需要解析包数据的话，分析pkt包的数据，并将pkt添加到AVFormatContext *s->internal->parse_queue。

选择哪个分析器哪? 通过调用函数av_parser_init(int codec_id)，根据codec_id选择分析器。以h264为例，codec_id为AV_CODEC_ID_H264，所以分析器为ff_h264_parser。

 



#define REGISTER_PARSER(X, x)                                           \
    {                                                                   \
        extern AVCodecParser ff_##x##_parser;                           \
        if (CONFIG_##X##_PARSER)                                        \
            av_register_codec_parser(&ff_##x##_parser);                 \
    }

void avcodec_register_all(void)
{
... ...
 /* parsers */
    REGISTER_PARSER(AAC,                aac);
    REGISTER_PARSER(AAC_LATM,           aac_latm);
    REGISTER_PARSER(AC3,                ac3);
    REGISTER_PARSER(ADX,                adx);
    REGISTER_PARSER(BMP,                bmp);
    REGISTER_PARSER(CAVSVIDEO,          cavsvideo);
    REGISTER_PARSER(COOK,               cook);
    REGISTER_PARSER(DCA,                dca);
    REGISTER_PARSER(DIRAC,              dirac);
    REGISTER_PARSER(DNXHD,              dnxhd);
    REGISTER_PARSER(DPX,                dpx);
    REGISTER_PARSER(DVAUDIO,            dvaudio);
    REGISTER_PARSER(DVBSUB,             dvbsub);
    REGISTER_PARSER(DVDSUB,             dvdsub);
    REGISTER_PARSER(DVD_NAV,            dvd_nav);
    REGISTER_PARSER(FLAC,               flac);
    REGISTER_PARSER(G729,               g729);
    REGISTER_PARSER(GSM,                gsm);
    REGISTER_PARSER(H261,               h261);
    REGISTER_PARSER(H263,               h263);
    REGISTER_PARSER(H264,               h264);
    REGISTER_PARSER(HEVC,               hevc);
    REGISTER_PARSER(MJPEG,              mjpeg);
    REGISTER_PARSER(MLP,                mlp);
    REGISTER_PARSER(MPEG4VIDEO,         mpeg4video);
    REGISTER_PARSER(MPEGAUDIO,          mpegaudio);
    REGISTER_PARSER(MPEGVIDEO,          mpegvideo);
    REGISTER_PARSER(OPUS,               opus);
    REGISTER_PARSER(PNG,                png);
    REGISTER_PARSER(PNM,                pnm);
    REGISTER_PARSER(RV30,               rv30);
    REGISTER_PARSER(RV40,               rv40);
    REGISTER_PARSER(TAK,                tak);
    REGISTER_PARSER(VC1,                vc1);
    REGISTER_PARSER(VORBIS,             vorbis);
    REGISTER_PARSER(VP3,                vp3);
    REGISTER_PARSER(VP8,                vp8);
    REGISTER_PARSER(VP9,                vp9);
}

read_frame_internal(AVFormatContext *s, AVPacket *pkt)函数pkt数据获取

AVFormatContext *s->streams[index]->need_parsing 或者s->streams[index]->parser为空时，函数ff_read_packet(AVFormatContext *s, AVPacket *pkt)获取到pkt内容。

或者通过函数 parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)，pkt指针指向的数据存储到AVFormatContext *s->internal->parse_queue。然后调用函数

read_from_packet_buffer(&s->internal->parse_queue, &s->internal->parse_queue_end, pkt);

 

static int read_from_packet_buffer(AVPacketList **pkt_buffer,
                                   AVPacketList **pkt_buffer_end,
                                   AVPacket      *pkt)
{
    AVPacketList *pktl;
    av_assert0(*pkt_buffer);
    pktl        = *pkt_buffer;
    *pkt        = pktl->pkt;
    *pkt_buffer = pktl->next;
    if (!pktl->next)
        *pkt_buffer_end = NULL;
    av_freep(&pktl);
    return 0;
}

 

总结：

函数read_frame_internal()主要作用为：

从指针AVFormatContext *pb读取音频或者视频数据，保存到pkt->data，同时得到音视频的编解码格式。

 

转载于:https://my.oschina.net/u/2326611/blog/809099

weixin_34082695
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【FFmpeg编程进阶】（16）读取一帧压缩编码数据 read_frame_internal() 代码分析
|~~~热爱生活、努力学习的小伙汁~~~|
09-30 964
【FFmpeg编程进阶】（16）读取一帧压缩编码数据 read_frame_internal 代码分析 接着前文《【FFmpeg编程进阶】（八）avformat_find_stream_info() 函数代码分析 - 获取媒体信息》， 本文链接： 本文单独拉一章出来分析下读取一帧压缩编码数据的代码流程。 # libavformat\utils.c static int read_frame_internal(AVFormatContext *s, AVPacket *pkt) { int ret
ffmpeg中的read_frame_internal函数
yihuanyihuan的博客
03-13 1288
read_frame_internal 在ffmpeg中实现了将format格式的packet,最终转换成一帧帧的es流packet，并解析填充了packet的pts,dts等信息，为最终解码提供了重要的数据,read_frame_internal,调用ff_read_packet,每次只读取一个包，然后直到parser完这个包的所有数据，才开始读取下一个包，parser完的数据被保存在parse...
(转)ffmpeg 中 av_read_frame_internal分析
dianchixian5277的博客
05-07 203
作者:chenwei1983 时间:2012-3-5 04:21 PM标题:ffmpeg 中 av_read_frame_internal分析 原出处:http://www.chinavideo.org/viewthread.php?action=printable&tid=13846av_read_frame_i...
av_read_frame_internal
hjksfw900的专栏
01-14 3963
 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt){ //初始化AVPacketav_init_packet(pkt); for(;;) { /* select current input stream component */ st = s->cu
ffmpeg笔记，av_read_frame()阻塞在哪
defence006的博客
11-04 7937
笔记一下。av_read_frame()阻塞在哪 av_read_frame() -> read_frame_internal() -> ff_read_packet() -> s->iformat->read_packet() -> /*不同demux最后都要到read url*/ -> read_from_url() -> ffurl_read() -> retry_transfer_w
ffmpeg_read_ffmpeg_
09-30
这个"ffmpeg_read_ffmpeg_"的压缩包显然是为初学者提供了一个简单的FFmpeg读取音视频数据的示例。主要涉及的知识点包括FFmpeg的基本使用、音视频流的读取以及C++编程。 1. FFmpeg基本框架： FFmpeg的核心由多个...
ffmpeg_for_mips.tgz
02-26
"ffmpeg_for_mips.tgz" 是一个专门为 MIPS 架构打包的 FFmpeg 压缩文件，可能包含了针对 MIPS 架构优化的二进制文件和库。 在深入 FFmpeg 的知识之前，我们先了解 MIPS（Microprocessor without Interlocked ...
ffmpeg.zip_c# ffmpeg_ffmpeg_ffmpeg开发
07-15
ffmpeg的开发手册，详细介绍里面的接口，很好用的文档。
ffmpeg_get_pcm_frame.c
05-11
Ubuntu 下利用ffmpeg接口获取音频输入设备的200帧PCM数据，并将其保存下来。可以通过软件，设定其通道数，采样率，采样bit等来测试保存下来的音频是否正常
ijkplayer读取rtp包过程
zds05的专栏
02-14 1318
android  ijkplayer 通过rtsp直播 ijkplayer读取rtp包过程 av_read_frame read_frame_internal static int read_frame_internal(AVFormatContext *s, AVPacket *pkt) {     int ret = 0, i, got_packet = 0
FFMPeg代码分析：AVPacket结构体和av_read_frame函数
hjwang1的专栏
01-07 3049
转自：http://blog.csdn.net/shaqoneal/article/details/16960927 AVPacket结构用于保存压缩编码过的数据。在解码时，该结构的实例通常作为解复用器（demuxer）的输出并输入到解码器中；在编码时，通常是编码器的输出，并输入到复用器（muxer）中。该结构体的定义如下： [cpp] view plaincopy
avformat_find_stream_info调用read_frame_internal死循环卡死
Lemon_D1999的博客
03-14 684
read_frame_internal这个函数调用，可以解析出不同流的es流,而read_frame_internal函数除非出错否则必须解析出一帧数据才能返回.发现服务调用ffmpeg库函数avformat_find_stream_info出现卡死，进入死循环现象，经过排查是调用了上图接口。因为原始流之中有编解码器信息，但没有数据包，所以解析不出帧，但rtsp流没有错误，所以死循环卡死在其中！具体原因还有待排查！至少定位了是卡死在哪里了！
FFmpeg长时间无响应的解决方法
zhouyongku的专栏
09-30 1万+
ffmpeg读取rtsp码流阻塞的解决方法 相机不在线、相机断开连接ffmpeg卡死的解决方法
FFmpeg学习 av_read_frame()函数分析
baiiu
07-22 930
前言 本文分析av_read_frame函数，该函数在libavformat包下。 /** * Return the next frame of a stream. * This function returns what is stored in the file, and does not validate * that what is there are valid frames for the decoder. It will split what is * stored in the fi
ffmpeg学习笔记（三）
qq_43716137的博客
09-18 278
一、FFmpeg 解码 API 分析 avformat_open_input 分析 函数 avformat_open_input 会根据所提供的文件路径判断文件的格式，其实就是通过这一步来决定到底是使用哪个Demuxer。 举个例子：如果是flv，那么Demuxer就会使用对应的ff_flv_demuxer，所以对应的关键生命周期的方法read_header、read_packet、read_seek、read_close都会使用该flv的Demuxer中函数指针指定的函数。read_header会将A
ffmpeg 读取RTSP流 av_read_frame 阻塞 卡死 的问题
baoecit的博客
09-14 5860
ffmpeg拉取RTSP流 正常操作不会有问题 但是如果途中， 把RTSP的流断了， 发现 会卡死 在avformat_find_stream_info函数中， 把这个函数注释掉的话就会卡死在av_read_frame中 ，大概需要30m才会返回 网上搜了下 无论是 设置超时方法 还是 回调函数都不管用，不知道为什么。 ...
理解ffmpeg的几个相对重要的函数
weixin_40728015的博客
08-06 2879
致敬大神——本文内容来自雷霄骅的博客。总结此文主要是对 ffmpeg的细节有个深入的理解。 首先回顾一下ffmpeg中最重要的几个结构体： AVFormatContext（统领全局，主要存储视音频封装格式中包含的信息）                      |------AVInputFormat（存储输入视音频使用的封装格式）                      |------...
FFmpeg源码分析：av_read_frame()读取音视频帧
热门推荐
徐福记456
12-01 2万+
FFmpeg使用av_read_frame()方法读取音频流、视频流、字幕流，得到AVPacket数据包。FFmpeg官方提供的samples有使用示例，或者在ffplay.c代码中：打开文件/网络流后，while循环调用av_read_frame()读取帧数据，也就是解封装demux过程，直到文件末尾EOF。
qt ffmpeg av_read_frame
最新发布
07-28
要在Qt中使用FFmpeg的av_read_frame函数，您需要按照以下步骤进行操作： 1. 首先，确保您已经在Qt项目中正确地集成了FFmpeg库。可以通过在.pro文件中添加适当的库路径和包含声明来实现。例如： ```qmake INCLUDE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值