QT ffmpeg获取RTSP流，同时可选择保存文件为MP4格式封装类

最新推荐文章于 2024-03-18 16:32:26 发布
最新推荐文章于 2024-03-18 16:32:26 发布
阅读量1.7k 收藏 30
点赞数 1
分类专栏： QT 文章标签： qt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jcw515/article/details/111687097
版权 
#ifndef QFFMPEG_H
#define QFFMPEG_H

//必须加以下内容,否则编译不能通过,为了兼容C和C99标准
#ifndef INT64_C
#define INT64_C
#define UINT64_C
#endif

//引入ffmpeg头文件
extern "C"
{
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavfilter/avfilter.h>
#include <libswscale/swscale.h>
#include <libavutil/frame.h>
}

#include <QObject>
#include <QMutex>
#include <QImage>

class QFFmpeg : public QObject
{
    Q_OBJECT
public:
    explicit QFFmpeg(QObject *parent = 0);
    ~QFFmpeg();

    bool Init();
    void Play();
    static int CheckInterrupt(void* ctx);

    void SetUrl(QString url){this->url=url;}
    QString Url()const{return url;}
    int VideoWidth()const{return videoWidth;}
    int VideoHeight()const{return videoHeight;}

    void playclose();

    void RecordFile(QString filename);

    void StopRecord();

    time_t m_tStart;

    int time_out,firsttimeplay;

private:
    QMutex mutex;
    AVPicture  pAVPicture;
    AVFormatContext *pAVFormatContext;
    AVCodecContext *pAVCodecContext;
    AVFrame *pAVFrame;
    SwsContext * pSwsContext;
    AVPacket pAVPacket;

    QString url;
    int videoWidth;
    int videoHeight;
    int videoStreamIndex;

    bool m_bPlay;

    QString FileOutName;

    uchar m_bRecordFile;

    int last_pts ;
    int last_dts ;

    int64_t pts, dts;

    AVFormatContext *o_fmt_ctx;
    //AVOutputFormat *o_fmt_ctx;
    AVStream *o_video_stream;
    AVStream *i_video_stream;

    bool m_bIsBreak;

signals:
    void GetImage(const QImage &image);
    void SendRtsppImage(uchar *);

public slots:

};

#endif // QFFMPEG_H


#include "qffmpeg.h"
#include <QDateTime>
#include <QDebug>
QFFmpeg::QFFmpeg(QObject *parent) :
    QObject(parent)
{    
    videoStreamIndex=-1;
    av_register_all();//注册库中所有可用的文件格式和解码器
    avformat_network_init();//初始化网络流格式,使用RTSP网络流时必须先执行
    pAVFormatContext = avformat_alloc_context();//申请一个AVFormatContext结构的内存,并进行简单初始化
    pAVFrame=av_frame_alloc();

    // auto ctx = avformat_alloc_context();

    // pAVFormatContext->interrupt_callback.callback = CheckInterrupt;//超时回调
    // pAVFormatContext->interrupt_callback.opaque = this;

    //
    //  m_tStart = time(NULL);

    o_fmt_ctx = nullptr;
    o_video_stream = nullptr;
    i_video_stream = nullptr;

    last_pts = 0 ;
    last_dts = 0;
    pts = 0;
    dts = 0;

    pSwsContext = nullptr;

    time_out=firsttimeplay=0;

}
//超时回调函数

int QFFmpeg::CheckInterrupt(void* ctx)
{
    auto p = (QFFmpeg*)ctx;
//    return (time(NULL) - (p->m_tStart)) >= 3 ? 1 : 0;//3秒超时
    // do something
      p->time_out++;
      if (p->time_out > 1200) {
          p->time_out=0;
          if (p->firsttimeplay) {
              p->firsttimeplay=0;
              return 1;//这个就是超时的返回
          }
      }
      return 0;
}

QFFmpeg::~QFFmpeg()
{
    if(m_bRecordFile == 1)
    {
        last_dts += dts;
        last_pts += pts;

        av_write_trailer(o_fmt_ctx);

        avcodec_close(o_fmt_ctx->streams[0]->codec);
        av_freep(&o_fmt_ctx->streams[0]->codec);
        av_freep(&o_fmt_ctx->streams[0]);

        avio_close(o_fmt_ctx->pb);
        av_free(o_fmt_ctx);

        m_bRecordFile = 0;
    }

    avformat_free_context(pAVFormatContext);
    av_frame_free(&pAVFrame);

    if(pSwsContext != nullptr)
      sws_freeContext(pSwsContext);
}

bool QFFmpeg::Init()
{
    //打开视频流

    AVDictionary *opts = NULL;
    av_dict_set(&opts,"stimeout","5000000",0);
    //av_dict_set(&opts, "buffer_size", "1024000", 0);
    pAVFormatContext->flags |= AVFMT_FLAG_NONBLOCK;  // 加上既可.
    av_dict_set(&opts, "rtsp_transport", "udp", 0); //以udp方式打开，如果以tcp方式打开将udp替换为tcp
    av_dict_set(&opts, "max_delay", "200000", 0); //设置最大时延
    int result=avformat_open_input(&pAVFormatContext, url.toStdString().c_str(),NULL,&opts);

  //  pAVFormatContext->interrupt_callback.callback = CheckInterrupt;//超时回调
  //  pAVFormatContext->interrupt_callback.opaque = this;

    m_tStart = time(NULL);

    if (result<0){
        avformat_free_context(pAVFormatContext);
        qDebug()<<"打开视频流失败";
        return false;
    }

    //获取视频流信息
    result=avformat_find_stream_info(pAVFormatContext,NULL);
    if (result<0){
        qDebug()<<"获取视频流信息失败";
        return false;
    }

    //获取视频流索引
    videoStreamIndex = -1;
    int icount = pAVFormatContext->nb_streams;
    for (uint i = 0; i < pAVFormatContext->nb_streams; i++) {
        if (pAVFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
            videoStreamIndex = i;
            i_video_stream = pAVFormatContext->streams[i];
            break;
        }
    }

    if (videoStreamIndex==-1){
        qDebug()<<"获取视频流索引失败";
        return false;
    }

    //获取视频流的分辨率大小
    pAVCodecContext = pAVFormatContext->streams[videoStreamIndex]->codec;
    videoWidth=pAVCodecContext->width;
    videoHeight=pAVCodecContext->height;

    avpicture_alloc(&pAVPicture,AV_PIX_FMT_RGB24,videoWidth,videoHeight);

    AVCodec *pAVCodec;

    //获取视频流解码器
    pAVCodec = avcodec_find_decoder(pAVCodecContext->codec_id);
    pSwsContext = sws_getContext(videoWidth,videoHeight,AV_PIX_FMT_YUV420P,videoWidth,videoHeight,AV_PIX_FMT_RGB24,SWS_BICUBIC,0,0,0);
    pAVCodecContext->bit_rate = 0;

    pAVCodecContext->time_base.num = 1;
    pAVCodecContext->time_base.den = 10;
    pAVCodecContext->frame_number = 1;
    pAVCodecContext->flags |= AV_CODEC_FLAG_LOW_DELAY;//低延时
    pAVCodecContext->err_recognition |= AV_EF_EXPLODE;//错误解码跳过该帧
    pAVCodecContext->active_thread_type |= FF_THREAD_FRAME;
    //pAVCodecContext->thread_count = 6;

//    av_opt_set(pAVCodecContext->priv_data,"preset","ultrafast",0);
//    av_opt_set(pAVCodecContext->priv_data,"tune","stillimage,fastcode,zerolatency",0);
//    av_opt_set(pAVCodecContext->priv_data,"h264opts","crf=26:vbv-maxrate=728:vbv-bufsize=364:keyint=25",0);
//    pAVCodecContext->delay = 0;

    //打开对应解码器
    result=avcodec_open2(pAVCodecContext,pAVCodec,NULL);
    if (result<0){
        qDebug()<<"打开解码器失败";
        return false;
    }
    qDebug()<<"初始化视频流成功";

    m_bPlay = true;

    m_bIsBreak = true;

    firsttimeplay = 1;

    return true;
}

void QFFmpeg::Play()
{
    //一帧一帧读取视频
    int frameFinished=0;
    uchar itt = 0;
    while (m_bPlay){

        if(m_bIsBreak)
        {
            if (av_read_frame(pAVFormatContext, &pAVPacket) >= 0){
                if(pAVPacket.stream_index==videoStreamIndex){
                    // qDebug()<<"开始解码"<<QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss");

                    int ret = avcodec_decode_video2(pAVCodecContext, pAVFrame, &frameFinished, &pAVPacket);

                    if(ret >= 0)
                    {
                        if (frameFinished){
                            mutex.lock();
                            sws_scale(pSwsContext,(const uint8_t* const *)pAVFrame->data,pAVFrame->linesize,0,videoHeight,pAVPicture.data,pAVPicture.linesize);
                            //发送获取一帧图像信号
                            // emit SendRtsppImage(pAVPicture.data[0]);

                            QImage image(pAVPicture.data[0],videoWidth,videoHeight,QImage::Format_RGB888);

                            emit GetImage(image);
                            mutex.unlock();
                        }
                    }
                    else
                    {
                        avcodec_flush_buffers(pAVCodecContext);
                    }

                    if(m_bRecordFile == 1)
                    {
                        /*
                      * pts and dts should increase monotonically
                      * pts should be >= dts
                      */

                        pAVPacket.flags |= AV_PKT_FLAG_KEY;
                        pts = pAVPacket.pts;
                        pAVPacket.pts += last_pts;
                        dts = pAVPacket.dts;
                        pAVPacket.dts += last_dts;
                        pAVPacket.stream_index = 0;

                        //printf("%lld %lld\n", i_pkt.pts, i_pkt.dts);
                        //static int num = 1;
                        //printf("frame %d\n", num++);
                        av_interleaved_write_frame(o_fmt_ctx, &pAVPacket);
                       // av_write_frame(o_fmt_ctx, &pAVPacket);
                    }
                    else if(m_bRecordFile == 2)
                    {
                        last_dts += dts;
                        last_pts += pts;

                        av_write_trailer(o_fmt_ctx);

                        avcodec_close(o_fmt_ctx->streams[0]->codec);
                        av_freep(&o_fmt_ctx->streams[0]->codec);
                        av_freep(&o_fmt_ctx->streams[0]);

                        avio_close(o_fmt_ctx->pb);
                        av_free(o_fmt_ctx);

                        m_bRecordFile = 0;
                    }
                }
            }

            av_free_packet(&pAVPacket);//释放资源,否则内存会一直上升

            firsttimeplay = 1;
        }
        else
        {
            break;
        }
    }
}

void QFFmpeg::playclose()
{
    m_bIsBreak = false;
    m_bPlay = false;
    if(m_bRecordFile == 1)
    {
        last_dts += dts;
        last_pts += pts;

        av_write_trailer(o_fmt_ctx);

        avcodec_close(o_fmt_ctx->streams[0]->codec);
        av_freep(&o_fmt_ctx->streams[0]->codec);
        av_freep(&o_fmt_ctx->streams[0]);

        avio_close(o_fmt_ctx->pb);
        av_free(o_fmt_ctx);

        m_bRecordFile = 0;
    }
}

void QFFmpeg::RecordFile(QString filename)
{
    FileOutName = filename;
    avformat_alloc_output_context2(&o_fmt_ctx, NULL, "mp4", filename.toStdString().c_str());
    /*
        * since all input files are supposed to be identical (framerate, dimension, color format, ...)
        * we can safely set output codec values from first input file
        */
    o_video_stream = avformat_new_stream(o_fmt_ctx, NULL);
    {
        AVCodecContext *c;
        c = o_video_stream->codec;
        c->bit_rate = 200000;
        c->codec_id = i_video_stream->codec->codec_id;
        c->codec_type = i_video_stream->codec->codec_type;
        c->time_base.num = i_video_stream->time_base.num;
        c->time_base.den = i_video_stream->time_base.den;
        // fprintf(stderr, "time_base.num = %d time_base.den = %d\n", c->time_base.num, c->time_base.den);
        c->width = i_video_stream->codec->width;
        c->height = i_video_stream->codec->height;
        c->pix_fmt = i_video_stream->codec->pix_fmt;
        // printf("%d %d %d", c->width, c->height, c->pix_fmt);
        c->flags = i_video_stream->codec->flags;
        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
        c->me_range = i_video_stream->codec->me_range;
        c->max_qdiff = i_video_stream->codec->max_qdiff;

        c->qmin = i_video_stream->codec->qmin;
        c->qmax = i_video_stream->codec->qmax;

        c->qcompress = i_video_stream->codec->qcompress;
    }
    av_dump_format(o_fmt_ctx,0,filename.toStdString().c_str(),1);

    avio_open(&o_fmt_ctx->pb, filename.toStdString().c_str(), AVIO_FLAG_WRITE);

    avformat_write_header(o_fmt_ctx, NULL);

    last_pts = 0;
    last_dts = 0;

    pts = dts = 0;

    m_bRecordFile = 1;
}

void QFFmpeg::StopRecord()
{
    if(m_bRecordFile == 1)
    {
      m_bRecordFile = 2;
    }
}

 

jcw515
关注
  • 1
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
QT+FFMPEG设计的流媒体播放器（播放rtsp+rtmp流）
走向CTO的路上...
05-27 213
支持Windows、Linux、macOS等多种操作系统。支持RTSP、RTMP、HTTP等多种流媒体协议。采用FFMPEG强大的解码能力，确保视频流畅播放。支持暂停、播放、快进、快退、音量控制等功能。支持自定义界面和功能扩展。QT+FFMPEG设计的流媒体播放器功能强大、跨平台兼容，可满足多种流媒体播放需求。QT和FFMPEG均为开源软件，可免费使用。支持多种流媒体协议、视频解码格式和播放功能。支持自定义界面和功能扩展，满足个性化需求。
ffmpeg读取rtsp并保存到mp4文件
热门推荐
zhouyongku的专栏
11-03 2万+
第一步：初始化网络环境
ffmpeg之rtsp保存为mp4文件
ZONGXP的博客
06-11 1万+
参考：https://www.cnblogs.com/wenjingu/p/3990071.html 参考了很多网上现有的例子，流程大同小异，基本上都是上述链接的翻版，但实际测试时存在一些问题，因此自己参考官方的例程实现了将rtsp视频流保存为mp4文件的功能。关于ffmpeg的具体介绍，本文不做赘述，直接上代码，有问题可以讨论。在ffmpeg的源码中，有很多有用的例程，其中remuxing.c...
QT+FFMPEG 从摄像机拉取rtsp裸h264流，播放并保存到本地
asdasfdgdhh的博客
12-04 1697
QT+FFMPEG 从摄像机拉取rtsp裸h264流，播放并保存到本地
Qt/C++视频监控拉流显示/各种rtsp/rtmp/http视频流/摄像头采集/视频监控回放/录像存储
Qt/C++视频监控/推流/物联网/大屏系统/自定义控件/UI定制/输入法
12-06 2470
本视频播放组件陆陆续续写了6年多，一直在持续更新迭代，视频监控行业客户端软件开发首要需求就是拉流显示，比如给定一个rtsp视频流地址，你需要在软件上显示实时画面，其次就是录像保存，再次就是一些周边的处理比如贴OSD，做图片分析等。拉流显示是第一步，如果有跨平台的需求，个人推荐用ffmpeg去实现，毕竟ffmpeg很底层，在做的过程中可以了解很多音视频的知识，缺点就是难，很多都是需要自己用代码去处理，按照ffmpeg自己的规范去处理。
Qt-FFmpeg开发-保存视频流裸流（11）
mahuifa的博客
02-22 5367
在使用ffmpeg打开网络视频流时，如果是【h264裸流可以直接保存为本地文件】，不需要进行编码操作。
qt+ffmpeg 实现音视频播放（二）之音频播放
最新发布
ckg3824278的博客
03-18 1611
通过() 打开媒体文件并分配和初始化结构体。参数说明：- `ps`：指向 `AVFormatContext` 结构体指针的指针，用于存储打开的媒体文件的信息。- `url`：要打开的媒体文件的 URL 或文件路径。- `fmt`：指定输入格式，通常可以设置为 `NULL`，由 FFmpeg 根据文件内容自动检测。- `options`：附加选项，可以传入一些额外的选项参数。
QT +FFMPEG4.3 拉取 RTMP/http-flv 流播放 AVFrame转Qimage
weixin_34854320的博客
05-17 709
QT +FFMPEG4.3 拉取 RTMP/http-flv 流播放 废话不多说直接上代码 - 欢迎评论区交流 或者加VX Cc_Video_thread.h #ifndef CC_VIDEO_THREAD_H #define CC_VIDEO_THREAD_H #include <QThread> #include <QAtomicInt> #include <QImage> #ifdef __cplusplus extern "C" { #endif #incl
ffmpeg源码学习-2、ffplay源码学习(qt环境搭建到代码解析)
zw1996的博客
02-21 1007
ffmpeg的ffplay源码学习， 源码迁移到qt上进行编译 研究ffplay框架调用流程 音视频同步技术 音视频seek操作
Qt编写的RTSP播放器+视频监控(vlc版本)
03-31
Qt的RTSP播放器+视频监控(vlc版本)
C++ MP4v2获取rtsp流并保存为MP4文件
08-07
在本文中，我们将深入探讨如何使用C++ MP4v2库和FFmpeg 4.0.1版本来从RTSP流中捕获视频并将其保存为MP4文件。这一过程涉及多个技术层面，包括网络协议处理、媒体编码解码以及文件格式封装。首先，我们来看一下关键...
android 移植ffmpeg源码 实现rtsp流实时播放及保存成MP4文件可以回放
12-27
在Android平台上实现RTSP流的实时播放以及将流媒体数据保存为MP4文件，通常涉及到多个技术栈的集成，其中包括FFmpeg、Android多媒体框架以及文件处理等。以下是对这个项目中涉及的关键知识点的详细说明： 1. **...
可编译运行的FFMPEG接口RTSP保存为MP4
03-07
在本场景中，我们关注的是如何通过FFmpeg的接口将RTSP（Real-Time Streaming Protocol）流转换并保存为MP4格式的文件。RTSP是一种网络协议，常用于实时流媒体传输，如监控视频等。而MP4是广泛应用的多媒体容器格式，...
实现ffmpeg将RTSP流封装成mp4、avi、flv文件的源码
07-28
通过以上介绍，我们了解了FFmpeg如何实现将RTSP流封装为MP4、AVI和FLV文件的基本原理和流程。如果你有这方面的编程经验，并且掌握了FFmpeg的API，那么`videotransform.cpp`和`videotransform.h`将是你实现这一功能的...
C++ 通过FFmpeg将rtsp视频流到本地mp4文件.zip
08-07
在C++环境中，使用FFmpeg库可以实现从RTSP（Real Time Streaming Protocol）视频流中捕获数据，并将其保存为本地的MP4文件。这个过程涉及到了网络协议处理、多媒体数据解析和文件封装等多个技术点。 首先，RTSP是一...
Qt+FFmpeg简单实现录屏并保存为MP4视频
寒木休思的博客
04-21 4262
最近需要实现一个录屏功能，网上查了好多资料，最可靠的方案当然还是用FFmpeg实现，但是也踩了很多坑，包括FFmpeg版本问题，vs2019里相关编译问题，FFmpeg也不太熟悉，很多代码不太容易看懂，想要按自己熟悉的方式实现录屏功能，花了一番功夫。
ffmpeg抓取rtsp流并保存_ffmpeg通过rtsp获取H264裸流并保存到mp4文件
weixin_31749595的博客
02-01 1102
1、VS2010建立VC++ win32控制台项目2、在工程目录下建立lib目录和include目录，将已编译好的lib拷打lib下，include拷到include下，dll拷到Debug目录下3、工程属性--配置属性--VC++目录--包含目录，添加ffmpeg头文件目录及其他第三方头文件目录链接器--常规--附加库目录，添加lib目录链接器--输入--附加依赖项，添加各个lib名4、设计和...
ffmpeg 获取rtsp 视频流封装格式
07-28
根据引用\[1\]和引用\[2\]的内容，可以得知使用ffmpeg获取rtsp视频流的封装格式是FLV。在引用\[2\]中的命令中，使用了"-f flv"参数来指定输出的封装格式为FLV。因此，ffmpeg获取rtsp视频流时使用的封装格式是FLV。 #### 引用[.reference_title] - *1* [用ffmpeg获取rtsp视频流的宽高帧率及其他信息](https://blog.csdn.net/weixin_42432281/article/details/88351227)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [Android 引入FFmpeg 读取RTSP流 解封装获取H264原始数据](https://blog.csdn.net/baoecit/article/details/124192260)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值