ffmpeg——av_write_frame/av_interleaved_write_frame写文件包

最新推荐文章于 2024-08-09 16:22:48 发布
最新推荐文章于 2024-08-09 16:22:48 发布
阅读量1.9w 收藏 17
点赞数 1
分类专栏： 视频/音频 文章标签： ffmpeg AVOutputFormat mp4 Mux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yibu_refresh/article/details/52884413
版权

一：介绍

1.1 ffmpeg 的 Mux 主要分为 三步操作：

    avformat_write_header ： 写文件头

    av_write_frame/av_interleaved_write_frame： 写packet

    av_write_trailer ： 写文件尾

本文主要分析 av_write_frame/av_interleaved_write_frame 。

可额外参考： http://blog.csdn.net/leixiaohua1020/article/details/44199673


1.2 av_write_frame

参考官网说明 ：http://ffmpeg.org/doxygen/3.1/group__lavf__encoding.html#gaa85cc1774f18f306cd20a40fc50d0b36

av_write_frame 直接将包写进Mux，没有缓存和重新排序，一切都需要用户自己设置。

  • Packet's stream_index field must be set to the index of the corresponding stream ins->streams.
  • The timestamps (pts, dts) must be set to correct values in the stream's timebase (unless the output format is flagged with the AVFMT_NOTIMESTAMPS flag, then they can be set to AV_NOPTS_VALUE). The dts for subsequent packets passed to this function must be strictly increasing when compared in their respective timebases (unless the output format is flagged with the AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).duration) should also be set if known.


1.3 av_interleaved_write_frame

参考官网说明： http://ffmpeg.org/doxygen/3.1/group__lavf__encoding.html#ga37352ed2c63493c38219d935e71db6c1

av_interleaved_write_frame 将对 packet 进行缓存和 pts 检查，这是区别于 av_write_frame 的地方。

  • If the packet is reference-counted, this function will take ownership of this reference and unreference it later when it sees fit. The caller must not access the data through this reference after this function returns. If the packet is not reference-counted, libavformat will make a copy.
  • This parameter can be NULL (at any time, not just at the end), to flush the interleaving queues.
  • Packet's stream_index field must be set to the index of the corresponding stream ins->streams.
  • The timestamps (pts, dts) must be set to correct values in the stream's timebase (unless the output format is flagged with the AVFMT_NOTIMESTAMPS flag, then they can be set to AV_NOPTS_VALUE). The dts for subsequent packets in one stream must be strictly increasing (unless the output format is flagged with the AVFMT_TS_NONSTRICT, then they merely have to be nondecreasing).duration) should also be set if known.



二：分析

2.1 av_write_frame


int av_write_frame(AVFormatContext *s, AVPacket *pkt)
{
    int ret;

	//对包预处理
    ret = prepare_input_packet(s, pkt);
    if (ret < 0)
        return ret;

	//空包,flush
    if (!pkt) {
        if (s->oformat->flags & AVFMT_ALLOW_FLUSH) {
            if (!s->internal->header_written) {
                ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
                if (ret < 0)
                    return ret;
            }
            ret = s->oformat->write_packet(s, NULL);
            if (s->flush_packets && s->pb && s->pb->error >= 0 && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
                avio_flush(s->pb);
            if (ret >= 0 && s->pb && s->pb->error < 0)
                ret = s->pb->error;
            return ret;
        }
        return 1;
    }

	//计算包信息
#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
    ret = compute_muxer_pkt_fields(s, s->streams[pkt->stream_index], pkt);

    if (ret < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
        return ret;
#endif

	//写包
    ret = write_packet(s, pkt);
    if (ret >= 0 && s->pb && s->pb->error < 0)
        ret = s->pb->error;

    if (ret >= 0)
        s->streams[pkt->stream_index]->nb_frames++;
    return ret;
}
下面来看看具体做了什么。

prepare_input_packet（检查流通道 和 包的pts，dts是否符合）：

static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
{
    int ret;

	//检查流通道
    ret = check_packet(s, pkt);
    if (ret < 0)
        return ret;

	//检查PTS , DTS
#if !FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
    /* sanitize the timestamps */
    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
        AVStream *st = s->streams[pkt->stream_index];

        /* when there is no reordering (so dts is equal to pts), but
         * only one of them is set, set the other as well */
        if (!st->internal->reorder) {
            if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE)
                pkt->pts = pkt->dts;
            if (pkt->dts == AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE)
                pkt->dts = pkt->pts;
        }

        /* check that the timestamps are set */
        if (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE) {
            av_log(s, AV_LOG_ERROR,
                   "Timestamps are unset in a packet for stream %d\n", st->index);
            return AVERROR(EINVAL);
        }

        /* check that the dts are increasing (or at least non-decreasing,
         * if the format allows it */
        if (st->cur_dts != AV_NOPTS_VALUE &&
            ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) ||
             st->cur_dts > pkt->dts)) {
            av_log(s, AV_LOG_ERROR,
                   "Application provided invalid, non monotonically increasing "
                   "dts to muxer in stream %d: %" PRId64 " >= %" PRId64 "\n",
                   st->index, st->cur_dts, pkt->dts);
            return AVERROR(EINVAL);
        }

        if (pkt->pts < pkt->dts) {
            av_log(s, AV_LOG_ERROR, "pts %" PRId64 " < dts %" PRId64 " in stream %d\n",
                   pkt->pts, pkt->dts, st->index);
            return AVERROR(EINVAL);
        }
    }
#endif

    return 0;
}

compute_muxer_pkt_fields （计算duration ，pts，dts等）： 

static int compute_muxer_pkt_fields(AVFormatContext *s, AVStream *st, AVPacket *pkt)
{
    int delay = FFMAX(st->codecpar->video_delay, st->internal->avctx->max_b_frames > 0);
    int num, den, i;
    int frame_size;

    if (!s->internal->missing_ts_warning &&
        !(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
        (pkt->pts == AV_NOPTS_VALUE || pkt->dts == AV_NOPTS_VALUE)) {
        av_log(s, AV_LOG_WARNING,
               "Timestamps are unset in a packet for stream %d. "
               "This is deprecated and will stop working in the future. "
               "Fix your code to set the timestamps properly\n", st->index);
        s->internal->missing_ts_warning = 1;
    }

    if (s->debug & FF_FDEBUG_TS)
        av_log(s, AV_LOG_TRACE, "compute_muxer_pkt_fields: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n",
            av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), delay, pkt->size, pkt->stream_index);

    if (pkt->duration < 0 && st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) {
        av_log(s, AV_LOG_WARNING, "Packet with invalid duration %"PRId64" in stream %d\n",
               pkt->duration, pkt->stream_index);
        pkt->duration = 0;
    }

    /* duration field */
    if (pkt->duration == 0) {
        ff_compute_frame_duration(s, &num, &den, st, NULL, pkt);
        if (den && num) {
            pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
        }
    }

    if (pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay == 0)
        pkt->pts = pkt->dts;

    //XXX/FIXME this is a temporary hack until all encoders output pts
    if ((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay) {
        static int warned;
        if (!warned) {
            av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
            warned = 1;
        }
        pkt->dts =
//        pkt->pts= st->cur_dts;
            pkt->pts = st->priv_pts->val;
    }

    //calculate dts from pts
    if (pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY) {
        st->pts_buffer[0] = pkt->pts;
        for (i = 1; i < delay + 1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
            st->pts_buffer[i] = pkt->pts + (i - delay - 1) * pkt->duration;
        for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
            FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);

        pkt->dts = st->pts_buffer[0];
    }

    if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
        ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
          st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE &&
          st->codecpar->codec_type != AVMEDIA_TYPE_DATA &&
          st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
        av_log(s, AV_LOG_ERROR,
               "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %s >= %s\n",
               st->index, av_ts2str(st->cur_dts), av_ts2str(pkt->dts));
        return AVERROR(EINVAL);
    }
    if (pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts) {
        av_log(s, AV_LOG_ERROR,
               "pts (%s) < dts (%s) in stream %d\n",
               av_ts2str(pkt->pts), av_ts2str(pkt->dts),
               st->index);
        return AVERROR(EINVAL);
    }

    if (s->debug & FF_FDEBUG_TS)
        av_log(s, AV_LOG_TRACE, "av_write_frame: pts2:%s dts2:%s\n",
            av_ts2str(pkt->pts), av_ts2str(pkt->dts));

    st->cur_dts = pkt->dts;
    st->priv_pts->val = pkt->dts;

    /* update pts */
    switch (st->codec->codec_type) {
    case AVMEDIA_TYPE_AUDIO:
        frame_size = (pkt->flags & AV_PKT_FLAG_UNCODED_FRAME) ?
                     ((AVFrame *)pkt->data)->nb_samples :
                     av_get_audio_frame_duration(st->codec, pkt->size);

        /* HACK/FIXME, we skip the initial 0 size packets as they are most
         * likely equal to the encoder delay, but it would be better if we
         * had the real timestamps from the encoder */
        if (frame_size >= 0 && (pkt->size || st->priv_pts->num != st->priv_pts->den >> 1 || st->priv_pts->val)) {
            frac_add(st->priv_pts, (int64_t)st->time_base.den * frame_size);
        }
        break;
    case AVMEDIA_TYPE_VIDEO:
        frac_add(st->priv_pts, (int64_t)st->time_base.den * st->time_base.num);
        break;
    }
    return 0;
｝
write_packet（写包）： 

static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
    int ret, did_split;

    if (s->output_ts_offset) {
        AVStream *st = s->streams[pkt->stream_index];
        int64_t offset = av_rescale_q(s->output_ts_offset, AV_TIME_BASE_Q, st->time_base);

        if (pkt->dts != AV_NOPTS_VALUE)
            pkt->dts += offset;
        if (pkt->pts != AV_NOPTS_VALUE)
            pkt->pts += offset;
    }

    if (s->avoid_negative_ts > 0) {
        AVStream *st = s->streams[pkt->stream_index];
        int64_t offset = st->mux_ts_offset;
        int64_t ts = s->internal->avoid_negative_ts_use_pts ? pkt->pts : pkt->dts;

        if (s->internal->offset == AV_NOPTS_VALUE && ts != AV_NOPTS_VALUE &&
            (ts < 0 || s->avoid_negative_ts == AVFMT_AVOID_NEG_TS_MAKE_ZERO)) {
            s->internal->offset = -ts;
            s->internal->offset_timebase = st->time_base;
        }

        if (s->internal->offset != AV_NOPTS_VALUE && !offset) {
            offset = st->mux_ts_offset =
                av_rescale_q_rnd(s->internal->offset,
                                 s->internal->offset_timebase,
                                 st->time_base,
                                 AV_ROUND_UP);
        }

        if (pkt->dts != AV_NOPTS_VALUE)
            pkt->dts += offset;
        if (pkt->pts != AV_NOPTS_VALUE)
            pkt->pts += offset;

        if (s->internal->avoid_negative_ts_use_pts) {
            if (pkt->pts != AV_NOPTS_VALUE && pkt->pts < 0) {
                av_log(s, AV_LOG_WARNING, "failed to avoid negative "
                    "pts %s in stream %d.\n"
                    "Try -avoid_negative_ts 1 as a possible workaround.\n",
                    av_ts2str(pkt->dts),
                    pkt->stream_index
                );
            }
        } else {
            av_assert2(pkt->dts == AV_NOPTS_VALUE || pkt->dts >= 0 || s->max_interleave_delta > 0);
            if (pkt->dts != AV_NOPTS_VALUE && pkt->dts < 0) {
                av_log(s, AV_LOG_WARNING,
                    "Packets poorly interleaved, failed to avoid negative "
                    "timestamp %s in stream %d.\n"
                    "Try -max_interleave_delta 0 as a possible workaround.\n",
                    av_ts2str(pkt->dts),
                    pkt->stream_index
                );
            }
        }
    }

    did_split = av_packet_split_side_data(pkt);

    if (!s->internal->header_written) {
        ret = s->internal->write_header_ret ? s->internal->write_header_ret : write_header_internal(s);
        if (ret < 0)
            goto fail;
    }

    if ((pkt->flags & AV_PKT_FLAG_UNCODED_FRAME)) {
        AVFrame *frame = (AVFrame *)pkt->data;
        av_assert0(pkt->size == UNCODED_FRAME_PACKET_SIZE);
        ret = s->oformat->write_uncoded_frame(s, pkt->stream_index, &frame, 0);
        av_frame_free(&frame);
    } else {
        ret = s->oformat->write_packet(s, pkt);
    }

    if (s->pb && ret >= 0) {
        if (s->flush_packets && s->flags & AVFMT_FLAG_FLUSH_PACKETS)
            avio_flush(s->pb);
        if (s->pb->error < 0)
            ret = s->pb->error;
    }

fail:
    if (did_split)
        av_packet_merge_side_data(pkt);

    return ret;
}
写包调用了AVOutputFormat 的 write_packet 。与write_header类似，具体的写包实现在各个封装的 AVOutputFormat 中。对此处写包未做详细分析...(-.-)...(/飙泪)。



2.2 av_interleaved_write_frame


int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
{
    int ret, flush = 0, i;

	//对包预处理
    ret = prepare_input_packet(s, pkt);
    if (ret < 0)
        goto fail;

	//bitstream filters (过滤器,也是区别于av_write_frame 的地方)
    if (pkt) {
        AVStream *st = s->streams[pkt->stream_index];

        if (s->oformat->check_bitstream) {
            if (!st->internal->bitstream_checked) {
                if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
                    goto fail;
                else if (ret == 1)
                    st->internal->bitstream_checked = 1;
            }
        }

        for (i = 0; i < st->internal->nb_bsfcs; i++) {
            AVBSFContext *ctx = st->internal->bsfcs[i];
            if (i > 0) {
                AVBSFContext* prev_ctx = st->internal->bsfcs[i - 1];
                if (prev_ctx->par_out->extradata_size != ctx->par_in->extradata_size) {
                    if ((ret = avcodec_parameters_copy(ctx->par_in, prev_ctx->par_out)) < 0)
                        goto fail;
                }
            }
            // TODO: when any bitstream filter requires flushing at EOF, we'll need to
            // flush each stream's BSF chain on write_trailer.
            if ((ret = av_bsf_send_packet(ctx, pkt)) < 0) {
                av_log(ctx, AV_LOG_ERROR,
                       "Failed to send packet to filter %s for stream %d",
                       ctx->filter->name, pkt->stream_index);
                goto fail;
            }
            // TODO: when any automatically-added bitstream filter is generating multiple
            // output packets for a single input one, we'll need to call this in a loop
            // and write each output packet.
            if ((ret = av_bsf_receive_packet(ctx, pkt)) < 0) {
                if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
                    return 0;
                av_log(ctx, AV_LOG_ERROR,
                       "Failed to send packet to filter %s for stream %d",
                       ctx->filter->name, pkt->stream_index);
                goto fail;
            }
            if (i == st->internal->nb_bsfcs - 1) {
                if (ctx->par_out->extradata_size != st->codecpar->extradata_size) {
                    if ((ret = avcodec_parameters_copy(st->codecpar, ctx->par_out)) < 0)
                        goto fail;
                }
            }
        }

        if (s->debug & FF_FDEBUG_TS)
            av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame size:%d dts:%s pts:%s\n",
                pkt->size, av_ts2str(pkt->dts), av_ts2str(pkt->pts));

#if FF_API_COMPUTE_PKT_FIELDS2 && FF_API_LAVF_AVCTX
        if ((ret = compute_muxer_pkt_fields(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
            goto fail;
#endif

        if (pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
            ret = AVERROR(EINVAL);
            goto fail;
        }
    } else {
        av_log(s, AV_LOG_TRACE, "av_interleaved_write_frame FLUSH\n");
        flush = 1;
    }

	//写包
    for (;; ) {
        AVPacket opkt;

		//此处也是与av_write_frame的区别
        int ret = interleave_packet(s, &opkt, pkt, flush);
        if (pkt) {
            memset(pkt, 0, sizeof(*pkt));
            av_init_packet(pkt);
            pkt = NULL;
        }
        if (ret <= 0) //FIXME cleanup needed for ret<0 ?
            return ret;

		//写入
        ret = write_packet(s, &opkt);
        if (ret >= 0)
            s->streams[opkt.stream_index]->nb_frames++;

        av_packet_unref(&opkt);

        if (ret < 0)
            return ret;
        if(s->pb && s->pb->error)
            return s->pb->error;
    }
fail:
    av_packet_unref(pkt);
    return ret;
}
prepare_input_packet 函数与 av_write_frame 的一致，主要是 bitstream filters 和 interleave_packet 的区别： 

static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
{
    if (s->oformat->interleave_packet) {
        int ret = s->oformat->interleave_packet(s, out, in, flush);
        if (in)
            av_packet_unref(in);
        return ret;
    } else
        return ff_interleave_packet_per_dts(s, out, in, flush);
}
后续可参考 ： http://blog.csdn.net/dancing_night/article/details/46469865



一步-refresh
关注
专栏目录
av_interleaved_write_frame -32 broken pipe
宝安小雨
10-29 5501
这个错误是底层socket传递给ffmpeg的，它是一个管道错误，意思是在管道两端，当一端不停的写，另一边却断开接收。那么就会出现： broken pipe 这个时候有几个可排查的选项： 1.发送的码流是多少，网络带宽是否足够。 2.查看服务器的日志，比如srs流媒体，与推流端连接和断开时都会有日志，记录，看是否连接后，推流时又断开连接了。 解释一下两个函数: avio_open(&octx->pb, URL, AVIO_FLAG_READ_WRITE) 如果URL是文件，这里就完成打开文
av_interleaved_write_frame
顺其自然~专栏
06-15 5126
音频和视频来自外部来源(麦克风和摄像头)，并且无需任何压缩即可捕获为原始数据(即使是视频)。我使用h264编码视频，而没有压缩音频(PCM)。捕获的音频为:16位，44100khz，立体声。捕获的视频为25FPS。如何进行音视频交替写入？最好的办法是使用此类应用程序将音频/视频捕获为pts和dts时给出的时间戳。因此，这些并非完全实时的时间戳（来自时钟），而是媒体捕获的时间戳。以这种方式写入otput数据包，以使它们正确交织(也许在内部对其进行排队)。 “正确插入”取决于容器格式，但是通常这意味着输出文件中
[h264 @ 00000169d2f4a540] Application provided invalid, non monotonically increasing dts to muxer in
最新发布
mynaiskey的博客
08-09 199
用ffmpeg通过mp4文件获取h264文件时，报错。要没有报错的话，就不能用copy，要强制重新编码。这个报错其实没有什么影响。
av_write_frame()
qq_35044535的博客
09-07 4436
av_write_frame()用于输出一帧视音频数据，它的声明位于libavformat\avformat.h，如下所示。/** * Write a packet to an output media file. * * This function passes the packet directly to the muxer, without any buffering * or
av_write_frame 与 av_interleaved_write_frame
liuty2006的专栏
06-29 1210
1、函数介绍 av_interleaved_write_frame函数介绍： [cpp] view plain copy /**   * Write a packet to an output media file ensuring correct interleaving.   *   * This function will bu
av_write_frame与av_interleaved_write_frame
evsqiezi
02-18 5939
ffmpeg的 Mux 主要分为三步操作：avformat_write_header： 写文件头。av_write_frame/av_interleaved_write_frame： 写packet。av_write_trailer： 写文件尾。 av_write_frame()用于输出一帧视音频数据，它的声明位于libavformat\avformat.h，直接将包写进Mux，没有缓存和重新排序...
ffmpeg源码跟踪笔记之av_write_frame 与 av_interleaved_write_frame
dancing_night的专栏
06-12 2万+
1、函数介绍 2、函数调用图 3、han
FFmpeg源码分析：写音视频帧av_write_frame()
徐福记456
02-13 2万+
FFmpeg在libavformat模块提供音视频的muxer封装与demuxer解封装。其中muxer封装文件包括avformat_write_header()、av_write_frame()和av_write_trailer()。本文主要探讨av_write_frame函数如何写入音视频帧数据，包括音视频交错与音视频非交错两种情况。
av_interleaved_write_frame 如何写aac音频到文件
06-09
要使用 `av_interleaved_write_frame` 来将 AAC 音频写入文件，需要执行以下步骤： 1. 打开输出文件并为其分配 AVFormatContext。 ```c++ AVFormatContext *outFormatCtx = nullptr; avformat_alloc_output_context...
av_interleaved_write_frame 内存
05-18
av_interleaved_write_frame是FFmpeg库中的一个函数，用于往AVFormatContext中写入一帧音频或视频数据。这个函数需要传入一个AVFormatContext结构体，它包含了输出文件的格式信息、编码信息和输出文件的IO操作相关...
av_write_frame
07-11
在调用该函数前，需要先通过avformat_write_header函数打开输出文件并写入文件头信息，然后使用av_interleaved_write_frame函数将音视频帧写入缓冲区，最后调用av_write_frame函数将缓冲区中的数据写入文件。...
音视频开发系列(51）FFmpeg代码架构
yinshipin007的博客
04-22 648
FFmpeg模块分类 打开FFmpeg源码，会发现有一系列libavxxx的模块，这些模块很好地划分了代码的结构和分工。 libavformat，format，格式封装 libavcodec，codec，编码、解码 libavutil，util，通用音视频工具，像素、IO、时间等工具 libavfilter，filter，过滤器，可以用作音视频特效处理 libavdevice，device，设备（摄像头、拾音器） libswscale，scale，
FFmpeg5.0源码阅读——av_interleaved_write_frame
梦的灰色边沿...
07-30 1673
本文主要详细描述FFmpeg中封装时写packet到媒体文件的函数。
从零到一学FFmpeg：av_interleaved_write_frame 函数详析与实战
十年饮冰，难凉热血，保持热爱，奔赴星海！
06-22 1140
av_interleaved_write_frame是FFmpeg库中的一个函数，用于将一个已编码的媒体数据包（AVPacket）写入到输出媒体文件或流中。此函数特别关注于维护正确的交错（interleaving）顺序，即确保视频和音频帧按照它们应该播放的顺序被写入，这对于生成可正确播放的多媒体文件至关重要。提示：以下是本篇文章正文内容，下面案例可供参考。
av_interleaved_write_frame av_write_frame区别
wxl1986622的专栏
11-15 2446
6. 由于切片这块我们借助了FFMPEG，大概思路就是收到一个GOP时完成一个TS切片，切完后立即通知上传模块的线程进行读取文件上传对象存储。既然读的模块没有上传完整，大概想原因可能在读取文件时，实际切片还没完全写到磁盘的文件时，收到通知后发现有文件就开始上传了。后来也验证了猜想的正确，因为毕竟丢帧都丢在TS文件的末尾几帧数据上，那什么原因导致写磁盘的过程滞后读文件的线程呢，毕竟这里是同步操作的。再后来发现切片写文件我们用的FFmpeg接口是av_interleaved_write_frame 而不是av_
从头用脚分析FFmpeg源码 - av_interleaved_write_frame ｜ av_write_frame
qq_35585843的博客
04-10 921
本文所使用的是FFmpeg n4.4的源码，所有分析均来自博主瞎猜，如果有误，欢迎批评指正。
FFmpeg源代码简单分析：av_write_frame()
热门推荐
雷霄骅(leixiaohua1020)的专栏
03-11 4万+
打算写两篇文章简单分析FFmpeg的写文件用到的3个函数avformat_write_header()，av_write_frame()以及av_write_trailer()。上篇文章已经分析了avformat_write_header()，这篇文章继续分析av_write_frame()。
FFmpeg源代码简单分析-编码-av_write_frame()
CHYabc123456hh的博客
06-22 1325
FFmpeg源代码简单分析-编码-av_write_frame()
【FFmpeg】转载 ffmpeg源码优化之推流发送篇 ：av_interleaved_write_frame 网络阻塞 : 源码深度解析
突围
01-11 3974
1.引言 大家好，距离上篇文章已经过去有一段时间了，主要是最近太忙了，一直没有更新。今天总算能抽出一点时间，说说ffmpeg源码级别的优化了，这块应该会连载，请大家持续关注。废话不多说，接下来就进入正题，说说怎么样进行优化。 在这里插入图片描述 2.问题引出及解决 使用ffmpeg接口去推流，当网络不稳定时，av_interleaved_write_frame有时候会出现长期无法返回，也就是卡死在里面，造成无法退出或不能进行下一步处理。下面我们就来分析下该接口究竟干了什么，揭开其神秘的面纱。 1 2 3 4
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值