Qt-FFmpeg开发-实现录屏功能(10)

音视频/FFmpeg #Qt

Qt-FFmpeg开发-实现录屏功能💬

更多精彩内容
👉个人内容分类汇总 👈
👉音视频开发 👈

1、概述💥

  • 最近研究了一下FFmpeg开发,功能实在是太强大了,网上ffmpeg3、4的文章还是很多的,但是学习嘛,最新的还是不能放过,就选了一个最新的ffmpeg n5.1.2版本,和3、4版本api变化还是挺大的;
  • 在这个Demo里主要使用Qt + FFmpeg开发一个【简易录屏软件】,这里主要使用的是【软解码】,需要使用硬解码的可以看之前的文章;
  • 为了便于学习,这里只是录制视频图像,没有引入音频等信息;
  • 由于录制的视频图像格式和保存的图像格式不一定相同,所以中间需要进行图像格式转换,这里使用的是FFmpeg自带的sws_scale(),听说libyuv性能更强,后续在研究研究。

开发环境说明

  • 系统:Windows10、Ubuntu20.04
  • Qt版本:V5.12.5
  • 编译器:MSVC2017-64、GCC/G++64
  • FFmpeg版本:n5.1.2
    • 注意:如果使用了较低版本的库,程序中部分功能可能会存在问题,不会兼容。
    • 官方下载
    • 我使用的库

2、实现效果💨

  1. 抓取桌面图像转码后保存到本地视频文件中;
  2. 支持各种常见视频文件类型;
  3. 支持Windows、Linux录屏功能;
  4. 支持全屏录制功能、录制指定区域功能;
  5. 默认将录制视频保存到系统的视频文件夹下;
  6. 主要功能分为录屏线程、录屏解码、图像像素转换、编码保存4部分。

3、FFmpeg录屏代码流程👁️‍🗨️

  • 白色部分: 主要为抓取桌面图像解码流程;
  • 绿色部分: 将桌面图像转码/编码保存到视频文件。

4、主要代码🤙

  • 啥也不说了,直接上代码,一切有注释

  • videodecode.h文件

    /******************************************************************************
     * @文件名     videodecode.h
     * @功能       视频解码类,在这个类中调用ffmpeg打开捕获桌面图像进行解码
     *
     * @开发者     mhf
     * @邮箱       [email protected]
     * @时间       2022/09/15
     * @备注
     *****************************************************************************/
    #ifndef VIDEODECODE_H
    #define VIDEODECODE_H
    
    #include <QString>
    #include <QSize>
    #include <qfile.h>
    #include <QPoint>
    
    struct AVFormatContext;
    struct AVCodecContext;
    struct AVRational;
    struct AVPacket;
    struct AVFrame;
    struct SwsContext;
    struct AVBufferRef;
    struct AVInputFormat;
    struct AVStream;
    class QImage;
    
    class VideoDecode
    {
    public:
        VideoDecode();
        ~VideoDecode();
    
        bool open(const QString& url = QString());    // 打开媒体文件,或者流媒体rtmp、strp、http
        AVFrame* read();                               // 读取视频图像
        void close();                                 // 关闭
        bool isEnd();                                 // 是否读取完成
        AVCodecContext* getCodecContext(){return m_codecContext;}
        QPoint avgFrameRate(){return m_avgFrameRate;}
    
    private:
        void initFFmpeg();                            // 初始化ffmpeg库(整个程序中只需加载一次)
        void showError(int err);                      // 显示ffmpeg执行错误时的错误信息
        qreal rationalToDouble(AVRational* rational); // 将AVRational转换为double
        void clear();                                 // 清空读取缓冲
        void free();                                  // 释放
    
    private:
        const AVInputFormat* m_inputFormat = nullptr;
        AVFormatContext* m_formatContext = nullptr;   // 解封装上下文
        AVCodecContext*  m_codecContext  = nullptr;   // 解码器上下文
        AVPacket* m_packet = nullptr;                 // 数据包
        AVFrame*  m_frame  = nullptr;                 // 解码后的视频帧
        int    m_videoIndex   = 0;                    // 视频流索引
        qint64 m_totalTime    = 0;                    // 视频总时长
        qint64 m_totalFrames  = 0;                    // 视频总帧数
        qint64 m_obtainFrames = 0;                    // 视频当前获取到的帧数
        qreal  m_frameRate    = 0;                    // 视频帧率
        QSize  m_size;                                // 视频分辨率大小
        char*  m_error = nullptr;                     // 保存异常信息
        bool   m_end = false;                         // 视频读取完成
        QPoint m_avgFrameRate;
    
    };
    
    #endif // VIDEODECODE_H
    
    
  • videodecode.cpp文件

    #include "videodecode.h"
    #include <QDebug>
    #include <QImage>
    #include <QMutex>
    #include <qdatetime.h>
    
    
    extern "C" {        // 用C规则编译指定的代码
    #include "libavcodec/avcodec.h"
    #include "libavformat/avformat.h"
    #include "libavutil/avutil.h"
    #include "libswscale/swscale.h"
    #include "libavutil/imgutils.h"
    #include "libavdevice/avdevice.h"    // 调用输入设备需要的头文件
    }
    
    #define ERROR_LEN 1024  // 异常信息数组长度
    #define PRINT_LOG 1
    
    VideoDecode::VideoDecode()
    {
        initFFmpeg();
    
        m_error = new char[ERROR_LEN];
    
        /**
         * dshow:  Windows 媒体输入设备。目前仅支持音频和视频设备。
         * gdigrab:基于 Win32 GDI 的屏幕捕获设备
         * video4linux2:Linux输入视频设备
         * x11grab:x11屏幕捕获设备
         */
    #if defined(Q_OS_WIN)
        m_inputFormat = av_find_input_format("gdigrab");            // Windows下如果没有则不能打开设备
    #elif defined(Q_OS_LINUX)
        m_inputFormat = av_find_input_format("x11grab");
    #elif defined(Q_OS_MAC)
    //    m_inputFormat = av_find_input_format("avfoundation");
    #endif
    
        if(!m_inputFormat)
        {
            qWarning() << "查询AVInputFormat失败!";
        }
    }
    
    VideoDecode::~VideoDecode()
    {
        close();
    }
    
    /**
     * @brief 初始化ffmpeg库(整个程序中只需加载一次)
     *        旧版本的ffmpeg需要注册各种文件格式、解复用器、对网络库进行全局初始化。
     *        在新版本的ffmpeg中纷纷弃用了,不需要注册了
     */
    void VideoDecode::initFFmpeg()
    {
        static bool isFirst = true;
        static QMutex mutex;
        QMutexLocker locker(&mutex);
        if(isFirst)
        {
            //        av_register_all();         // 已经从源码中删除
            /**
             * 初始化网络库,用于打开网络流媒体,此函数仅用于解决旧GnuTLS或OpenSSL库的线程安全问题。
             * 一旦删除对旧GnuTLS和OpenSSL库的支持,此函数将被弃用,并且此函数不再有任何用途。
             */
            avformat_network_init();
            // 初始化libavdevice并注册所有输入和输出设备。
            avdevice_register_all();
            isFirst = false;
        }
    }
    
    /**
     * @brief      打开媒体文件,或者流媒体,例如rtmp、strp、http
     * @param url  视频地址
     * @return     true:成功  false:失败
     */
    bool VideoDecode::open(const QString &url)
    {
        if(url.isNull()) return false;
    
        AVDictionary* dict = nullptr;
    
        // 所有参数:https://ffmpeg.org/ffmpeg-devices.html
        av_dict_set(&dict, "framerate", "20", 0);          // 设置帧率,默认的是30000/1001,但是实际可能达不到30的帧率,所以最好手动设置
        av_dict_set(&dict, "draw_mouse", "1", 0);          // 指定是否绘制鼠标指针。0:不包含鼠标,1:包含鼠标
        av_dict_set(&dict, "video_size", "500x400", 0);    // 录制视频的大小(宽高),默认为全屏
    #if defined(Q_OS_WIN)
    //    av_dict_set(&dict, "offset_x", "100", 0);          // 录制视频的起点X坐标
    //    av_dict_set(&dict, "offset_y", "500", 0);          // 录制视频的起点Y坐标
    #elif defined(Q_OS_LINUX)
    //    av_dict_set(&dict, "select_region", "1", 0);          // 1:指定是否使用指针以图形方式选择抓取区域 0:不使用
    
        // 当video_size设置,并且video_size加上grab_x、grab_y后不超出桌面区域时,可以通过grab_x、grab_y设置录屏的起始坐标,如果超出桌面区域则会设置失败
    //       av_dict_set(&dict, "grab_x", "300", 0);          // 录制视频的起点X坐标
    //       av_dict_set(&dict, "grab_y", "500", 0);          // 录制视频的起点Y坐标
    #endif
    
        // 打开输入流并返回解封装上下文
        int ret = avformat_open_input(&m_formatContext,          // 返回解封装上下文
                                      url.toStdString().data(),  // 打开视频地址
                                      m_inputFormat,             // 如果非null,此参数强制使用特定的输入格式。自动选择解封装器(文件格式)
                                      &dict);                    // 参数设置
    
        // 释放参数字典
        if(dict)
        {
            av_dict_free(&dict);
        }
        // 打开视频失败
        if(ret < 0)
        {
            showError(ret);
            free();
            return false;
        }
    
        // 读取媒体文件的数据包以获取流信息。
        ret = avformat_find_stream_info(m_formatContext, nullptr);
        if(ret < 0)
        {
            showError(ret);
            free();
            return false;
        }
        m_totalTime = m_formatContext->duration / (AV_TIME_BASE / 1000); // 计算视频总时长(毫秒)
    #if PRINT_LOG
        qDebug() << QString("视频总时长:%1 ms,[%2]").arg(m_totalTime).arg(QTime::fromMSecsSinceStartOfDay(int(m_totalTime)).toString("HH:mm:ss zzz"));
    #endif
    
        // 通过AVMediaType枚举查询视频流ID(也可以通过遍历查找),最后一个参数无用
        m_videoIndex = av_find_best_stream(m_formatContext, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
        if(m_videoIndex < 0)
        {
            showError(m_videoIndex);
            free();
            return false;
        }
    
        AVStream* videoStream = m_formatContext->streams[m_videoIndex];  // 通过查询到的索引获取视频流
    
        // 获取视频图像分辨率(AVStream中的AVCodecContext在新版本中弃用,改为使用AVCodecParameters)
        m_size.setWidth(videoStream->codecpar->width);
        m_size.setHeight(videoStream->codecpar->height);
        m_frameRate = rationalToDouble(&videoStream->avg_frame_rate);  // 视频帧率
        m_avgFrameRate.setX(videoStream->avg_frame_rate.num);
        m_avgFrameRate.setY(videoStream->avg_frame_rate.den);
    
        // 通过解码器ID获取视频解码器(新版本返回值必须使用const)
        const AVCodec* codec = avcodec_find_decoder(videoStream->codecpar->codec_id);
        m_totalFrames = videoStream->nb_frames;
    
    #if PRINT_LOG
        qDebug() << QString("分辨率:[w:%1,h:%2] 帧率:%3  总帧数:%4  解码器:%5")
                    .arg(m_size.width()).arg(m_size.height()).arg(m_frameRate).arg(m_totalFrames).arg(codec->name);
    #endif
    
        // 分配AVCodecContext并将其字段设置为默认值。
        m_codecContext = avcodec_alloc_context3(codec);
        if(!m_codecContext)
        {
    #if PRINT_LOG
            qWarning() << "创建视频解码器上下文失败!";
    #endif
            free();
            return false;
        }
    
        // 使用视频流的codecpar为解码器上下文赋值
        ret = avcodec_parameters_to_context(m_codecContext, videoStream->codecpar);
        if(ret < 0)
        {
            showError(ret);
            free();
            return false;
        }
    
        m_codecContext->flags2 |= AV_CODEC_FLAG2_FAST;    // 允许不符合规范的加速技巧。
        m_codecContext->thread_count = 8;                 // 使用8线程解码
    
        // 初始化解码器上下文,如果之前avcodec_alloc_context3传入了解码器,这里设置NULL就可以
        ret = avcodec_open2(m_codecContext, nullptr, nullptr);
        if(ret < 0)
        {
            showError(ret);
            free();
            return false;
        }
    
        // 分配AVPacket并将其字段设置为默认值。
        m_packet = av_packet_alloc();
        if(!m_packet)
        {
    #if PRINT_LOG
            qWarning() << "av_packet_alloc() Error!";
    #endif
            free();
            return false;
        }
        // 分配AVFrame并将其字段设置为默认值。
        m_frame = av_frame_alloc();
        if(!m_frame)
        {
    #if PRINT_LOG
            qWarning() << "av_frame_alloc() Error!";
    #endif
            free();
            return false;
        }
    
        m_end = false;
        return true;
    }
    
    /**
     * @brief   读取图像并将图像转换为YUV420P格式
     * @return
     */
    AVFrame* VideoDecode::read()
    {
        // 如果没有打开则返回
        if(!m_formatContext)
        {
            return nullptr;
        }
    
        // 读取下一帧数据
        int readRet = av_read_frame(m_formatContext, m_packet);
        if(readRet < 0)
        {
            avcodec_send_packet(m_codecContext, m_packet); // 读取完成后向解码器中传如空AVPacket,否则无法读取出最后几帧
        }
        else
        {
    
            if(m_packet->stream_index == m_videoIndex)     // 如果是图像数据则进行解码
            {
                // 将读取到的原始数据包传入解码器
                int ret = avcodec_send_packet(m_codecContext, m_packet);
                if(ret < 0)
                {
                    showError(ret);
                }
            }
        }
        av_packet_unref(m_packet);  // 释放数据包,引用计数-1,为0时释放空间
    
        av_frame_unref(m_frame);
        int ret = avcodec_receive_frame(m_codecContext, m_frame);
        if(ret < 0)
        {
            av_frame_unref(m_frame);
            if(readRet < 0)
            {
                m_end = true;     // 当无法读取到AVPacket并且解码器中也没有数据时表示读取完成
            }
            return nullptr;
        }
    
        return m_frame;
    }
    
    /**
     * @brief 关闭视频播放并释放内存
     */
    void VideoDecode::close()
    {
        clear();
        free();
    
        m_totalTime     = 0;
        m_videoIndex    = 0;
        m_totalFrames   = 0;
        m_obtainFrames  = 0;
        m_frameRate     = 0;
        m_size          = QSize(0, 0);
    }
    
    /**
     * @brief  视频是否读取完成
     * @return
     */
    bool VideoDecode::isEnd()
    {
        return m_end;
    }
    
    
    /**
     * @brief        显示ffmpeg函数调用异常信息
     * @param err
     */
    void VideoDecode::showError(int err)
    {
    #if PRINT_LOG
        memset(m_error, 0, ERROR_LEN);        // 将数组置零
        av_strerror(err, m_error, ERROR_LEN);
        qWarning() << "DecodeVideo Error:" << m_error;
    #else
        Q_UNUSED(err)
    #endif
    }
    
    /**
     * @brief          将AVRational转换为double,用于计算帧率
     * @param rational
     * @return
     */
    qreal VideoDecode::rationalToDouble(AVRational* rational)
    {
        qreal frameRate = (rational->den == 0) ? 0 : (qreal(rational->num) / rational->den);
        return frameRate;
    }
    
    /**
     * @brief 清空读取缓冲
     */
    void VideoDecode::clear()
    {
        // 因为avformat_flush不会刷新AVIOContext (s->pb)。如果有必要,在调用此函数之前调用avio_flush(s->pb)。
        if(m_formatContext && m_formatContext->pb)
        {
            avio_flush(m_formatContext->pb);
        }
        if(m_formatContext)
        {
            avformat_flush(m_formatContext);   // 清理读取缓冲
        }
    }
    
    void VideoDecode::free()
    {
        // 释放编解码器上下文和与之相关的所有内容,并将NULL写入提供的指针
        if(m_codecContext)
        {
            avcodec_free_context(&m_codecContext);
        }
        // 关闭并失败m_formatContext,并将指针置为null
        if(m_formatContext)
        {
            avformat_close_input(&m_formatContext);
        }
        if(m_packet)
        {
            av_packet_free(&m_packet);
        }
        if(m_frame)
        {
            av_frame_free(&m_frame);
        }
    }
    
    
  • videocodec.h文件

    /******************************************************************************
     * @文件名     videocodec.h
     * @功能       视频编码保存类,将AVFrame图像进行格式转换后编码保存到视频文件中
     *
     * @开发者     mhf
     * @邮箱       [email protected]
     * @时间       2022/12/26
     * @备注
     *****************************************************************************/
    #ifndef VIDEOCODEC_H
    #define VIDEOCODEC_H
    
    #include <QPoint>
    #include <qmutex.h>
    #include <qstring.h>
    
    
    struct AVCodecParameters;
    struct AVFormatContext;
    struct AVCodecContext;
    struct AVStream;
    struct AVFrame;
    struct AVPacket;
    struct AVOutputFormat;
    struct SwsContext;
    
    class VideoCodec
    {
    public:
        VideoCodec();
        ~VideoCodec();
    
        bool open(AVCodecContext *codecContext, QPoint point, const QString& fileName);
        void write(AVFrame* frame);
        void close();
    
    private:
        void showError(int err);
        bool swsFormat(AVFrame* frame);
    
    private:
        AVFormatContext* m_formatContext = nullptr;
        AVCodecContext * m_codecContext  = nullptr;    // 编码器上下文
        SwsContext     * m_swsContext    = nullptr;    // 图像转换上下文
        AVStream       * m_videoStream   = nullptr;
        AVPacket       * m_packet        = nullptr;    // 数据包
        AVFrame        * m_frame         = nullptr;    // 解码后的视频帧
        int m_index = 0;
        bool             m_writeHeader   = false;      // 是否写入头
        QMutex           m_mutex;
    };
    
    #endif // VIDEOCODEC_H
    
    
  • videocodec.cpp文件

    #include "videocodec.h"
    #include <QDebug>
    
    extern "C" {        // 用C规则编译指定的代码
    #include "libavcodec/avcodec.h"
    #include "libavformat/avformat.h"
    #include "libavutil/avutil.h"
    #include "libswscale/swscale.h"
    #include "libavutil/imgutils.h"
    #include "libavdevice/avdevice.h"
    }
    
    #define ERROR_LEN 1024  // 异常信息数组长度
    #define PRINT_LOG 1
    
    VideoCodec::VideoCodec()
    {
    
    }
    
    VideoCodec::~VideoCodec()
    {
        close();
    }
    
    bool VideoCodec::open(AVCodecContext *codecContext, QPoint point, const QString &fileName)
    {
        if(!codecContext || fileName.isEmpty()) return false;
    
        // 通过输出文件名为输出格式分配AVFormatContext。参数3编码器设置为空,由参数4文件名后缀推测合适的编码器
        int ret = avformat_alloc_output_context2(&m_formatContext, nullptr, nullptr, fileName.toStdString().data());
    
        if(ret < 0)
        {
            close();
            showError(ret);
            return false;
        }
        // 创建并初始化AVIOContext以访问url所指示的资源。
        ret = avio_open(&m_formatContext->pb, fileName.toStdString().data(), AVIO_FLAG_WRITE);
        if(ret < 0)
        {
            close();
            showError(ret);
            return false;
        }
    
        // 查询编码器
        const AVCodec* codec = avcodec_find_encoder(m_formatContext->oformat->video_codec);
        if(!codec)
        {
            close();
            showError(AVERROR(ENOMEM));
            return false;
        }
        qDebug() << codec->id <<" " << codec->name;
    
        // 分配AVCodecContext并将其字段设置为默认值。
        m_codecContext = avcodec_alloc_context3(codec);
        if(!m_codecContext)
        {
            close();
            showError(AVERROR(ENOMEM));
            return false;
        }
    
        // 设置编码器上下文参数
        m_codecContext->width = codecContext->width;                          // 图片宽度/高度
        m_codecContext->height = codecContext->height;
        m_codecContext->pix_fmt = codec->pix_fmts[0];                         // 像素格式(这里通过编码器赋值,不需要自己指定)
        m_codecContext->time_base = {point.y(), point.x()};                   //设置时间基,20为分母,1为分子,表示以1/20秒时间间隔播放一帧图像
        m_codecContext->framerate = {point.x(), point.y()};
        m_codecContext->bit_rate = 1000000;                                   // 目标的码率,即采样的码率;显然,采样码率越大,视频大小越大,画质越高
        m_codecContext->gop_size = 12;                                        // I帧间隔(值越大,视频文件越小,编解码延时越长)
        m_codecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
    
        // 打开编码器
        ret = avcodec_open2(m_codecContext, nullptr, nullptr);
        if(ret < 0)
        {
            close();
            showError(ret);
            return false;
        }
    
        // 向媒体文件添加新流
        m_videoStream = avformat_new_stream(m_formatContext, nullptr);
        if(!m_videoStream)
        {
            close();
            showError(AVERROR(ENOMEM));
            return false;
        }
    
        //拷贝一些参数,给codecpar赋值
        ret = avcodec_parameters_from_context(m_videoStream->codecpar,m_codecContext);
        if(ret < 0)
        {
            close();
            showError(ret);
            return false;
        }
    
        // 写入文件头
        ret = avformat_write_header(m_formatContext, nullptr);
        if(ret < 0)
        {
            close();
            showError(ret);
            return false;
        }
        m_writeHeader = true;
    
        // 分配一个AVPacket
        m_packet = av_packet_alloc();
        if(!m_packet)
        {
            close();
            showError(AVERROR(ENOMEM));
            return false;
        }
    
        m_frame = av_frame_alloc();
        if(!m_frame)
        {
            close();
            showError(AVERROR(ENOMEM));
            return false;
        }
        m_frame->format = codec->pix_fmts[0];
    
        qDebug() << "开始录制视频!";
        return true;
    }
    
    /**
     * @brief          将图像帧编码写入视频文件
     * @param frame
     */
    void VideoCodec::write(AVFrame *frame)
    {
        QMutexLocker locker(&m_mutex);
        if(!m_packet)
        {
            return;
        }
    
        if(!swsFormat(frame))              // 由于解码的图像格式和编码需要的图像格式不一定相同,所以需要转换一下格式
        {
            return;
        }
        if(m_frame)
        {
            m_frame->pts = m_index;         // pts从0开始增加,保存的视频才会时间从0开始增加
            m_index++;
        }
    
    
        avcodec_send_frame(m_codecContext, m_frame); // 将图像传入编码器
    
        // 循环读取所有编码完的帧
        while (true)
        {
            // 从编码器中读取图像帧
            int ret = avcodec_receive_packet(m_codecContext, m_packet);
            if(ret < 0)
            {
                break;
            }
    
            // 将数据包中的有效时间字段(时间戳/持续时间)从一个时基转换为 输出流的时间
            av_packet_rescale_ts(m_packet, m_codecContext->time_base, m_videoStream->time_base);
            av_write_frame(m_formatContext, m_packet);   // 将数据包写入输出媒体文件
            av_packet_unref(m_packet);
        }
    }
    
    void VideoCodec::close()
    {
        write(nullptr);   // 传入空帧,读取所有编码数据
        QMutexLocker locker(&m_mutex);    // 如果不加锁可能在点击关闭时,write函数正在写入数据,导致崩溃
        if(m_formatContext)
        {
            // 写入文件尾
            if(m_writeHeader)
            {
                m_writeHeader = false;
                int ret = av_write_trailer(m_formatContext);
                if(ret < 0)
                {
                    showError(ret);
                    return;
                }
            }
            int ret = avio_close(m_formatContext->pb);
            if(ret < 0)
            {
                showError(ret);
                return;
            }
            avformat_free_context(m_formatContext);
            m_formatContext = nullptr;
            m_videoStream = nullptr;
        }
        // 释放编解码器上下文并置空
        if(m_codecContext)
        {
            avcodec_free_context(&m_codecContext);
        }
        if(m_packet)
        {
            av_packet_free(&m_packet);
        }
        // 释放上下文swsContext。
        if(m_swsContext)
        {
            sws_freeContext(m_swsContext);
            m_swsContext = nullptr;             // sws_freeContext不会把上下文置NULL
        }
        if(m_frame)
        {
            av_frame_free(&m_frame);
        }
        m_index = 0;
    }
    
    void VideoCodec::showError(int err)
    {
    #if PRINT_LOG
        static char  m_error[ERROR_LEN];         // 保存异常信息
        memset(m_error, 0, ERROR_LEN);           // 将数组置零
        av_strerror(err, m_error, ERROR_LEN);
        qWarning() << "VideoSave Error:" << m_error;
    #else
        Q_UNUSED(err)
    #endif
    }
    
    /**
     * @brief        将解码图像帧的像素格式转换未编码图像帧的像素格式
     * @param frame
     * @return       true:转换成功  false:转换失败
     */
    bool VideoCodec::swsFormat(AVFrame *frame)
    {
        if(!frame || frame->width <= 0 || frame->height <= 0)
        {
            return false;
        }
        // 为什么图像转换上下文要放在这里初始化呢,是因为m_frame->format,如果使用硬件解码,解码出来的图像格式和m_codecContext->pix_fmt的图像格式不一样,就会导致无法转换为QImage
        // 由于解码后的图像格式不一定支持保存裸流,或者不支持直接编码为H264,所以需要转换格式
        if(!m_swsContext)
        {
            // 获取缓存的图像转换上下文。首先校验参数是否一致,如果校验不通过就释放资源;然后判断上下文是否存在,如果存在直接复用,如不存在进行分配、初始化操作
            m_swsContext = sws_getCachedContext(m_swsContext,
                                                frame->width,                     // 输入图像的宽度
                                                frame->height,                    // 输入图像的高度
                                                (AVPixelFormat)frame->format,     // 输入图像的像素格式
                                                frame->width,                     // 输出图像的宽度
                                                frame->height,                    // 输出图像的高度
                                                (AVPixelFormat)m_frame->format,   // 输出图像的像素格式
                                                SWS_BILINEAR,                     // 选择缩放算法(只有当输入输出图像大小不同时有效),一般选择SWS_FAST_BILINEAR
                                                nullptr,                          // 输入图像的滤波器信息, 若不需要传NULL
                                                nullptr,                          // 输出图像的滤波器信息, 若不需要传NULL
                                                nullptr);                         // 特定缩放算法需要的参数(?),默认为NULL
            if(!m_swsContext)
            {
    #if PRINT_LOG
                qWarning() << "sws_getCachedContext() Error!";
    #endif
    
                av_frame_unref(frame);
                return false;
            }
    
            if(m_frame)
            {
                // 创建一个图像帧用于保存YUV420P图像
                m_frame->width = frame->width;
                m_frame->height = frame->height;
                av_frame_get_buffer(m_frame, 3 * 8);
            }
        }
    
        if(m_frame->width <= 0 || m_frame->height <= 0)      // 如果m_frame没有分配空间则返回
        {
            return false;
        }
    
        // 开始转换格式
        bool ret = sws_scale(m_swsContext,             // 缩放上下文
                        frame->data,                   // 原图像数组
                        frame->linesize,               // 包含源图像每个平面步幅的数组
                        0,                             // 开始位置
                        frame->height,                 // 行数
                        m_frame->data,                 // 目标图像数组
                        m_frame->linesize);            // 包含目标图像每个平面的步幅的数组
        av_frame_unref(frame);
        return ret;
    }
    
    

5、完整源代码🤏

∧__∧
( `Д´ )
(っ▄︻▇〓┳═💥💥
/   )
( / ̄∪

热门相关:地球第一剑   豪门闪婚:帝少的神秘冷妻   仗剑高歌   网游之逆天飞扬   刺客之王