ffmpeg源码优化之推流发送篇

最新推荐文章于 2024-06-22 15:02:21 发布
最新推荐文章于 2024-06-22 15:02:21 发布
阅读量2.1k 收藏 17
点赞数 3
分类专栏： 流媒体开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43512657/article/details/106026064
版权
本文介绍了在使用ffmpeg推流时遇到的网络不稳定导致的av_interleaved_write_frame函数卡死问题。通过源码分析，揭示了发送封装包的过程，特别是在网络发送数据的环节。提出了三个优化方案：增大发送数据大小、设置超时时间避免阻塞、降低网络负载以提高效率。文章深入探讨了ffmpeg与RTMP协议的交互，以及TCP协议在其中的角色，帮助读者理解并解决网络阻塞问题。
摘要由CSDN通过智能技术生成

1.引言

大家好，距离上篇文章已经过去有一段时间了，主要是最近太忙了，一直没有更新。今天总算能抽出一点时间，说说ffmpeg源码级别的优化了，这块应该会连载，请大家持续关注。废话不多说，接下来就进入正题，说说怎么样进行优化。

在这里插入图片描述
2.问题引出及解决

使用ffmpeg接口去推流，当网络不稳定时，av_interleaved_write_frame有时候会出现长期无法返回，也就是卡死在里面，造成无法退出或不能进行下一步处理。下面我们就来分析下该接口究竟干了什么，揭开其神秘的面纱。

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

    ret = prepare_input_packet(s, pkt);
    if (ret < 0)
        goto fail;

    if (pkt) {
   
        AVStream *st = s->streams[pkt->stream_index];

        ret = do_packet_auto_bsf(s, pkt);
        if (ret == 0)
            return 0;
        else if (ret < 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;
        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;
}

上面就是发送封装包的源代码，下面来一一分析。

static int prepare_input_packet(AVFormatContext *s, AVPacket *pkt)
{
   
    int ret;
	/*数据包是否合格*/
    ret = check_packet(s, pkt);
    if (ret < 0)
        return ret;

#if !FF_API_COMPUTE_PKT_FIELDS2 || !FF_API_LAVF_AVCTX
    /* 清除时间戳 */
    if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
   
        AVStream *st = s->streams[pkt->stream_index];

        /* 当没有重新排序时，也就是pts等于dts，则需要把pts和dts分别进行设置*/
        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;
        }

        /* 检查是否设置了时间戳 */
        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);
        }

        /*检查dts是否增加，如果dts没有增加，则需要去检查是否在封包时有其它异常*/
        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);
        }
			/*
      如果pts小于dts，则视为异常，因为dts是解码时间戳，pts是显示时间戳
      正常情况是，先解码，后显示，所以pts应该是要大于dts，这样才会合理。
      */
        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;
}

static int do_packet_auto_bsf(AVFormatContext *s, AVPacket *pkt) {
   
    AVStream *st = s->streams[pkt->stream_index];
    int i, ret;

    if (!(s->flags & AVFMT_FLAG_AUTO_BSF))
        return 1;
	/*检查是否设置了码流过滤，以及额外数据提取*/
    if (s->oformat->check_bitstream) {
   
        if (!st->internal->bitstream_checked) {
   
            if ((ret = s->oformat->check_bitstream(s, pkt)) < 0)
                return ret;
            else if (ret == 1)
                st->internal->bitstream_checked = 1;
        }
    }

#if FF_API_LAVF_MERGE_SD
FF_DISABLE_DEPRECATION_WARNINGS
    if (st->internal->nb_bsfcs) {
   
      /*分离出头部数据*/
        ret = av_packet_split_side_data(pkt);
        if (ret < 0)
            av_log(s, AV_LOG_WARNING, "Failed to split side data before bitstream filter\n");
    }
FF_ENABLE_DEPRECATION_WARNINGS
#endif

    for (i = 0; i < st->internal->nb_bsfcs; i++) {
   
        AVBSFContext *ctx = st->internal->bsfcs[i];
        /*当任何过滤器需要在流结束时刷新，则我们需要在刷新整个BSF数据链表*/
        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\n",
                    ctx->filter->name, pkt->stream_index);
            return ret;
        }
        /*当有多个码流过滤器，需要循环去生成，并调用*/
        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\n",
                    ctx->filter->name, pkt->stream_index);
            return ret;
        }
    }
    return 1;
}

下面就是开始循环发包的过程，详细分析如下:

/*
	功能:间隔发送数据包，实际上是缓存了。这也是av_interleaved_write_frame与av_write_frame的区别之处
  AVPacket *out：表述输出数据包
  AVPacket *in:表示输入数据包
  flush:如果为1表示输入没有更多数据包，应该输出剩余数据包
  返回值:1表示输出数据包。0:表示没有数据包
  <0，表示发生错误
*/
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
      /*把数据包缓存到队列中，那什么时候发送？也就是flush什么时候为1呢?*/
        return ff_interleave_packet_per_dts(s, out, in, flush);
}

int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
                                 AVPacket *pkt, int flush)
{
   
    AVPacketList *pktl;
    int stream_count = 0;
    int noninterleaved_count = 0;
    int i, ret;
    int eof = flush;

    if (pkt) {
   
      /*比较数据包的dts添加数据包到想要队列中*/
        if ((ret = ff_interleave_add_packet(s, pkt, interleave_compare_dts)) < 0)
            return ret;
    }

    for (i = 0; i < s->nb_streams; i++) {
   
        if (s->streams[i]->last_in_packet_buffer) {
   
          /*记录数据包个数*/
            ++stream_count;
        } else if (s->streams[i]->codecpar->codec_type != AVMEDIA_TYPE_ATTACHMENT &&
                   s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP8 &&
                   s->streams[i]->codecpar->codec_id != AV_CODEC_ID_VP9) {
   
            ++noninterleaved_count;
        }
    }
	/*表示缓冲区已满，需要输出*/
    if (s->internal->nb_interleaved_streams == stream_count)
        flush = 1;

    if (s->max_interleave_delta > 0 &&
        s->internal->packet_buffer &&
        !flush &&
        s->internal->nb_interleaved_streams == stream_count+noninterleaved_count
    ) {
   
        AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
        int64_t delta_dts = INT64_MIN;
        int64_t top_dts = av_rescale_q(top_pkt->dts,
                                       s->streams[top_pkt->stream_index]->time_base,
                                       AV_TIME_BASE_Q);

        for (i = 0; i < s->nb_streams; i++) {
   
            int64_t last_dts;
            const AVPacketList *last = s->streams[i]->last_in_packet_buffer;

            if (!last)
                continue;

            last_dts = av_rescale_q(last->pkt.dts,
                                    s->streams[i]->time_base,
                                    AV_TIME_BASE_Q);
            delta_dts = FFMAX(delta_dts, last_dts - top_dts);
        }
			/*缓冲区中最老与最新数据包的dts间隔，大于了最大间隔，则需要输出数据*/
        if (delta_dts > s->max_interleave_delta) {
   
            av_log(s, AV_LOG_DEBUG,
                   "Delay between the first packet and last packet in the "
                   "muxing queue is %"PRId64" > %"PRId64": forcing output\n",
                   delta_dts, s->max_interleave_delta);
            flush = 1;
        }
    }

    if (s->internal->packet_buffer &&
        eof &&
        (s->flags & AVFMT_FLAG_SHORTEST) &&
        s->internal->shortest_end == AV_NOPTS_VALUE) {
   
        AVPacket *top_pkt = &s->internal->packet_buffer->pkt;

        s->internal->shortest_end = av_rescale_q(top_pkt->dts,
                                       s->streams[top_pkt->stream_index]->time_base,
                                       AV_TIME_BASE_Q);
    }

    if (s->internal->shortest_end != AV_NOPTS_VALUE) {
   
        while (s->internal->packet_buffer) {
   
            AVPacket *top_pkt = &s->internal->packet_buffer->pkt;
            AVStream *st;
            int64_t top_dts = av_rescale_q(top_pkt->dts,
                                        s->streams[top_pkt->stream_index]->time_base,
                                        AV_TIME_BASE_Q);

            if (s->internal->shortest_end + 1 >= top_dts)
                break;

            pktl = s->internal->packet_buffer;
            st   = s->streams[pktl->pkt.stream_index];

            s->internal->packet_buffer = pktl->next;
            if (!s->internal->packet_buffer)
                s->internal->packet_buffer_end = NULL;

            if (st->last_in_packet_buffer == pktl)
                st->last_in_packet_buffer = NULL;

            av_packet_unref(&pktl->pkt);
            av_freep(&pktl);
            flush = 0;
        }
    }

    if (stream_count && flush) {
   
        AVStream *st;
        pktl = s->internal->packet_buffer;
        *out = pktl->pkt;
        st   = s->streams[out->stream_index];

        s->internal->packet_buffer = pktl->next;
        if (!s->internal->packet_buffer)
            s->internal->packet_buffer_end = NULL;

        if (st->last_in_packet_buffer == pktl)
            st->last_in_packet_buffer = NULL;
        av_freep(&pktl);

        return 1;
    } else {
   
        av_init_packet(out);
        return 0;
    }
}

前面做了数据包的合格性检查，pts与dts的检查，缓冲到队列中，并在合适的时机，去发送数据包。接下来就该主角上场了。

/**
 功能:发送数据包
 AVFormatContext *s:封装上下文
 AVPacket *pkt:需要发送的数据包
 */
static int write_packet(AVFormatContext *s, AVPacket *pkt)
{
   
    int ret, did_split;
    int64_t pts_backup, dts_backup;

    pts_backup = pkt->pts;
    dts_backup = pkt->dts;

  /*调整pts与dts时间偏移，这个偏移值是可以灵活调整*/
    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-
最低0.47元/天 解锁文章
antonio@qaa
关注
  • 3
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
ffmpeg rtmp推流源码
08-07
一份可以直接将本地视频推送到服务器的推流源代码， 是学习推流的很好的资料， 代码基于ffmpeg rtmp推流， 采用nginx+rtmp module搭建本地流媒体服务器
流媒体测试笔记记录之————阿里云监控、OBS、FFmpeg拉流和推流变化比较记录...
Tinywan
01-06 1505
  OBS设置视频（512kbps）和音频（128kbps）比特率   阿里云监控结果：    使用FFmpeg拉流到Nginx 服务器测试比特率        第二次测试，修改视频和音频比特率   OBS设置   阿里云监控     Nginx 比特率变化    FFMPEG 拉流截图     ...
从零到一学FFmpeg：av_interleaved_write_frame 函数详析与实战
最新发布
十年饮冰，难凉热血，保持热爱，奔赴星海！
06-22 1115
av_interleaved_write_frame是FFmpeg库中的一个函数，用于将一个已编码的媒体数据包（AVPacket）写入到输出媒体文件或流中。此函数特别关注于维护正确的交错（interleaving）顺序，即确保视频和音频帧按照它们应该播放的顺序被写入，这对于生成可正确播放的多媒体文件至关重要。提示：以下是本篇文章正文内容，下面案例可供参考。
ffmpeg代码：推流降低延迟的优化
yangops的博客
03-20 9834
ffmpeg推流降低延迟的优化 一.针对编码器上下文的参数配置 AVCodecContext *vc = NULL; // AV_CODEC_FLAG_GLOBAL_HEADER -- 将全局头文件放在引渡文件中，而不是每个关键帧中。 //AV_CODEC_FLAG_LOW_DELAY --较低延迟 vc->flags |= AV_CODEC_FLAG_GLOBAL_...
FFMPEG文件转封装
牧羊女
05-07 1747
前段时间开发了一个基于FFMPEG的文件录制功能，具体来讲，就是把在线码流转封装成本地文件。当然，实际应用过程中，需要考虑指定的封装格式与输入文件或码流的编码格式是否兼容，录制固定大小或时长的文件时对于文件size或时间戳的处理，等等。这里先将这些细节省略，只讲一下大体流程。媒体转封装的过程可参考如下框图：左侧为输入文件(或码流)，右侧为输出文件。推流的流程大抵也是如此，但要加上网络初始化函数，并...
FFmpeg RTP拉流源码分析
qw_stone的博客
09-23 2050
原因：由于需要进行RTP拉流分析，故在此分析FFmpeg拉流流程. 概况：FFmpeg通过url进行udp连通，然后通过sps和pps进行解码器参数初始化，然后进行解码。 伪代码详细分析如下：由于输入文件可以是sdp文件，也可是url，故通过avformat_open_input简单分析可知通过输入文件类型,通过源码可以看出无论是文件操作还是协议操作都是定义为URLProtocol类型，...
ffmpeg 推流技术
09-28
这为学习者提供了一个极好的机会，不仅能够理解推流的工作原理，还能实践调用和优化推流库。 FFmpeg推流的基本流程如下： 1. **初始化**: 首先，你需要配置推流参数，包括目标服务器的URL、输出的流格式（如RTMP、...
最简单的基于FFmpeg的推流器（以推送RTMP为例） 1.1
02-13
这个简单的FFmpeg推流器的核心原理在于调用FFmpeg的API来读取本地视频文件，并将其封装成RTMP格式的数据包，然后通过网络发送到指定的服务器。FFmpeg库提供了解析、编码、封装和传输多媒体数据的一系列功能，使得...
FFmpeg RTSP 推流北京时间
04-19
在FFmpeg源码中，推流至RTSP涉及的主要部分是`libavformat/rtsp.c`文件，这里实现了RTSP协议的相关功能。 - `AVFormatContext`：FFmpeg中的上下文结构体，包含了关于输入/输出的所有信息，如URL、时钟、流等。 - ...
ffmpeg进行rtmp推流时随机卡死中断后从中断位置接续推流（监控cpu版）
tansuo2005的专栏
05-09 3830
实现ffmpeg推流过程中随机卡死后，自动断点续推。
ffmpeg4.1 源码学习之-转封装
xfc_1939的博客
03-27 830
基于一个转封装命令分析ffmpeg.c的代码
最简单的基于FFmpeg的推流器（以推送RTMP为例）
翻肚鱼儿的博客
08-12 1252
本文记录一个最简单的基于FFmpeg的推流器（simplest ffmpeg streamer）。推流器的作用就是将本地的视频数据推送至流媒体服务器。本文记录的推流器，可以将本地的 MOV / AVI / MKV / MP4 / FLV 等格式的媒体文件，通过流媒体协议（例如RTMP，HTTP，UDP，TCP，RTP等等）以直播流的形式推送出去。由于流媒体协议种类繁多，不一一记录。在这里记录将本地文件以RTMP直播流的形式推送至RTMP流媒体服务器（例如 Flash Media Server，Red5，Wo
FFmpeg 音视频采集输出视频文件、推流端实现
03-04 2321
之前项目需要实现双录功能，客户办理 业务时录制音频视频保存做凭证使用。当前使用FFmpeg实现采集外交的USB摄像头数据，采样H264、ACC编码生成mkv视频格式文件。对外是Windows OCX接口给上传的html应用使用的，以下是以前项目使用的测试页面。 现在直播行业发展很快，由于对视频敢兴趣最近也去了解了下，把之前做的东西整理后重写了个测试Demo，用于验证与测试。ffmp...
ffmpeg推流实现实时播放监控画面（rtsp to rtmp）
weixin_45020562的博客
05-15 8202
大萨达
RTP推送mpegts流及验证方法
samssm的专栏
02-25 2384
RTP推送mpegts流及验证方法 参考了下wiki及ffmpeg源码发现，还有一个rtp_mpegts的muxer，可以支持推送mpeg-ts流（这也是我能找到的RTP唯一支持的容器格式）。 验证下命令如下，首先推流端： ./ffmpeg -re -stream_loop -1 -i zhen_h264+mp2.ts -vcodec copy -acodec copy -f rtp_mpe...
ffmpeg源码分析之mpegts.c——精简分析
阿小步
01-11 2327
文章编辑中。。。
mediasoup源码分析（十） ffmpeg推流到mediasoup 及调试
lcalqf的专栏
08-20 2585
一、PlainTransport 介绍 mediasoup提供了PlainTransport可以接收裸RTP数据，所以可以通过ffmpeg.sh脚本推本地文件到mediasoup。 二、ffmpeg.sh推流介绍 脚本路径：mediasoup-demo/broadcasters/ffmpeg.sh 注意：需要通过chrome网页请求提前创建好一个房间。 1、安装脚本运行时的依赖库 安装httpie yum install httpie 安装urlib easy_install...
如何优化ffmpeg推流
06-03
优化ffmpeg推流可以从以下几个方面入手： 1. 使用硬件加速：可以通过使用支持GPU加速的硬件或软件编解码器，加速ffmpeg推流的视频编码和解码过程，从而提高推流的性能。 2. 调整视频编码参数：可以通过调整视频编码器的参数，例如调整码率、帧率、分辨率、GOP大小等，来优化视频质量和推流性能。 3. 调整音频编码参数：可以通过调整音频编码器的参数，例如调整采样率、码率、声道数等，来优化音频质量和推流性能。 4. 使用多线程编码：可以通过启用多线程编码器，来提高ffmpeg推流的编码性能。 5. 调整推流缓冲区大小：可以通过调整ffmpeg推流的缓冲区大小，来优化推流的稳定性和性能。 6. 调整网络参数：可以通过调整网络参数，例如调整网络带宽、网络拥塞控制算法等，来优化ffmpeg推流的网络传输性能。 7. 调整服务器硬件配置：可以通过升级服务器的CPU、内存等硬件配置，来提高ffmpeg推流的性能。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值