Qt-FFmpeg开发-实现录屏功能（10）

news2024/10/7 20:32:22

#音视频/FFmpeg #Qt

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

文章目录

  • Qt-FFmpeg开发-实现录屏功能💬
    • 1、概述💥
    • 2、实现效果💨
    • 3、FFmpeg录屏代码流程👁️‍🗨️
    • 4、主要代码🤙
    • 5、完整源代码🤏

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

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
 * @邮箱       1603291350@qq.com
 * @时间       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
 * @邮箱       1603291350@qq.com
 * @时间       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、完整源代码🤏

  • github
  • gitee

∧__∧
( ｀Д´ ）
(っ▄︻▇〓┳═💥💥
/　　 )
( /￣∪

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/362757.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Doris单机部署

Doris单机部署

文章目录1. 前言2. 安装3. 启动4. 使用1. 前言 Apache Doris 是一款现代 MPP (Massively Parallel Processing大规模并行处理) 的分布式 SQL 分析数据库&#xff0c;所谓分析数据库就是将其数据集分布在许多机器或节点上&#xff0c;以处理大量数据&#xff0c;采用 Apache 2.0…
阅读更多...
几十亿工单表，查询优化案例

几十亿工单表，查询优化案例

前言: 之前在某大型保险公司担任技术经理&#xff0c;负责优化话务系统模块&#xff0c;由于系统已经运行10年之久&#xff0c;尤其在话务系统中&#xff0c;沉积了几十亿的话务信息表&#xff0c;业务人员反馈&#xff0c;话务系统历史数据查询部分已经完全查询不动&#xff0…
阅读更多...
Spring Cloud Nacos源码讲解（二）- Nacos客户端服务注册源码分析

Spring Cloud Nacos源码讲解（二）- Nacos客户端服务注册源码分析

Nacos客户端服务注册源码分析 服务注册信息 ​ 我们从Nacos-Client开始说起&#xff0c;那么说到客户端就涉及到服务注册&#xff0c;我们先了解一下Nacos客户端都会将什么信息传递给服务器&#xff0c;我们直接从Nacos Client项目的NamingTest说起 public class NamingTest…
阅读更多...
less、sass、webpack（前端工程化）

less、sass、webpack（前端工程化）

目录 一、Less 1.配置less环境 1.先要安装node&#xff1a;在cmd中&#xff1a;node -v检查是否安装node 2.安装less :cnpm install -g less 3.检查less是否安装成功&#xff1a;lessc -v 4.安装成功后&#xff0c;在工作区创建xx.less文件 5.在控制台编译less,命令&…
阅读更多...
Spring Cloud——流监控Dashboard

Spring Cloud——流监控Dashboard

一、编写三个module 1. springcloud-consumer-hystrix-dashboard 1.导入依赖 <dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix</artifactId><version>1.4.6.RELEASE</version>…
阅读更多...
【服务器数据恢复】raid5磁盘阵列硬盘离线的数据恢复案例

【服务器数据恢复】raid5磁盘阵列硬盘离线的数据恢复案例

服务器数据恢复环境&#xff1a; 某公司一台服务器组建了一组raid5磁盘阵列&#xff0c;作为共享存储池使用。该服务器存储数据库文件和普通文件。 服务器故障&检测&#xff1a; RAID5磁盘阵列的硬盘掉线导致服务器操作系统识别不到D分区。管理员重启了服务器&#xff0c;服…
阅读更多...
如何发布新闻稿，包含编写新闻稿、发布渠道

如何发布新闻稿，包含编写新闻稿、发布渠道

发布新闻稿是一种重要的传播方式&#xff0c;它可以让公众了解你的新闻&#xff0c;并提高新闻的知名度和可信度。在这篇文章中&#xff0c;我将详细介绍如何发布新闻稿&#xff0c;包括选择发布渠道、编写新闻稿、发布新闻稿和推广新闻稿等方面的内容。1、选择发布渠道在发布新…
阅读更多...
VirtualBox压缩VDI文件 VDI文件瘦身方法（cenos7）

VirtualBox压缩VDI文件 VDI文件瘦身方法（cenos7）

virtualbox虚拟机运行久了之后就会发现&#xff0c;磁盘镜像vdi文件越来越大。即使你把虚拟机中的大文件删除&#xff0c;这个vdi文件占用的空间还是不变。也就是说动态扩展的vdi文件只会大&#xff0c;不会小。那么大的文件对于备份和分享都不是很方便&#xff0c;所以有必要的…
阅读更多...
Arduino-抢答器

Arduino-抢答器

抢答器实验实验器件&#xff1a;■ 按键开关&#xff1a;4 个■ 红色LED灯&#xff1a;1 个■ 黄色LED灯&#xff1a;1 个■ 绿色LED灯&#xff1a;1 个■ 220欧电阻&#xff1a;7 个■ 面包板&#xff1a;1 个■ 多彩杜邦线&#xff1a;若干实验连线将代码上传到开发板。程序代…
阅读更多...
mysql 学习、复习资料整理详细

mysql 学习、复习资料整理详细

mysql 学习、复习资料整理详细1、数据库基础1.1 数据库设计遵循的原则1.2 数据库范式1.2 数据库完整性的实现2、mysql特点3、事务3.1 事务的四大特性 – ACID3.2 并发事务问题3.3 事务的四大隔离级别3.4 事务隔离级别操作sql3.5 事务原理 – LBCC MVCC3.4.1 行的隐藏列3.4.2 Re…
阅读更多...
一文教你玩转 Apache Doris 分区分桶新功能｜新版本揭秘

一文教你玩转 Apache Doris 分区分桶新功能｜新版本揭秘

数据分片&#xff08;Sharding&#xff09;是分布式数据库分而治之 (Divide And Conquer) 这一设计思想的体现。过去的单机数据库在大数据量下往往面临存储和 IO 的限制&#xff0c;而分布式数据库则通过数据划分的规则&#xff0c;将数据打散分布至不同的机器或节点上&#xf…
阅读更多...
【7/101】101次面试之测试技术面试题

【7/101】101次面试之测试技术面试题

01、什么是兼容性测试&#xff1f;兼容性测试侧重哪些方面&#xff1f;答&#xff1a;兼容性测试是一种软件测试类型&#xff0c;它的主要目的是确保一个应用程序在不同的操作系统、不同的浏览器、不同的设备、不同的网络环境等各种环境下能够正常运行&#xff0c;并且不会产生…
阅读更多...
Vue使用ElementUI对表单元素进行自定义校验

Vue使用ElementUI对表单元素进行自定义校验

前言 在使用ElementUI的表单元素时候&#xff0c;除了做一些简单的非空处理校验&#xff0c;在一些特殊的场合&#xff0c;还需要我们做一些自定义校验。 其实ElementUI不仅提供了基本的非空校验&#xff0c;也对我们提供了自定义检验。 在使用的时候还是遇到了一些坑&#…
阅读更多...
华为OD机试 - 特异性双端队列（C++） | 附带编码思路 【2023】

华为OD机试 - 特异性双端队列（C++） | 附带编码思路 【2023】

刷算法题之前必看 参加华为od机试，一定要注意不要完全背诵代码，需要理解之后模仿写出，通过率才会高。 华为 OD 清单查看地址：https://blog.csdn.net/hihell/category_12199283.html 华为OD详细说明：https://dream.blog.csdn.net/article/details/128980730 华为OD机试题…
阅读更多...
SAP中BOM基础数量及组件数量单位比例关系的注意事项

SAP中BOM基础数量及组件数量单位比例关系的注意事项

下图是BOM展开功能CS11在正式系统和测试系统的截图。从截图中的对比不难看出&#xff0c;最下级的原材料A20981-110在组件的数量为1&#xff0c;实际按BOM中的设定比例折算&#xff0c;应该是1个成品&#xff0c;对应需要0.125件原材料。但这里显示的并不是0.125PC&#xff0c;…
阅读更多...
Ubuntu22.04 安装Mongodb6.X

Ubuntu22.04 安装Mongodb6.X

Ubuntu22.04 安装Mongodb6.X 1、Mongodb简介 1.1 什么是MongoDB? Mongodb是一个跨平台的面向文档的NoSQL数据库。它使用带有可选模式的类似JSON的BSON来存储数据。应用程序可以以JSON格式检索信息。 1.2 MongoDB的优点 可以快速开发web型应用&#xff0c;因为灵活&#xff0c;…
阅读更多...
sympy高斯光束模型

sympy高斯光束模型

文章目录Gauss模型sympy封装实战sympy.phisics.optics.gaussopt集成了高斯光学中的常见对象&#xff0c;包括光线和光学元件等&#xff0c;有了这些东西&#xff0c;就可以制作一个光学仿真系统。Gauss模型 高斯光束的基本模型为 E(r,z)E0ω0ω(z)exp⁡[−r2ω2(z)]exp⁡[−ik…
阅读更多...
自动增长配置不合理导致的性能抖动

自动增长配置不合理导致的性能抖动

背景客户收到了SQL专家云告警邮件&#xff0c;在凌晨2点到3点之间带有资源等待的会话数暴增&#xff0c;请我们协助分析。现象登录SQL专家云&#xff0c;进入活动会话的趋势分析页面&#xff0c;下钻到2点钟一个小时内的数据&#xff0c;看到每分钟的等待数都在100左右&#xf…
阅读更多...
“源启”新程，共筑数字新基石 2023年中电金信跑出转型发展加速度

“源启”新程，共筑数字新基石 2023年中电金信跑出转型发展加速度

核心提示 预计到2025年&#xff0c;我国数字经济规模将超60万亿元&#xff0c;我国数字经济投入产出效率将提升至约3.5。 近日&#xff0c;中国信通院数字经济与工业经济领域主席孙克在相关活动中表示&#xff0c;预计到2025年&#xff0c;我国数字经济规模将超60万亿元&#…
阅读更多...
2023年华为HCIE-Dacom认证题库（H12-891）

2023年华为HCIE-Dacom认证题库（H12-891）

1、如图所示是某位网络工程师在排查OSPF故障时的输出信息。据此判断&#xff0c;以下哪种原因可能导致邻接关系无法正常建立。 Hello报文发送时间不一致认证密码不一致接口的IP地址掩码不一致区域类型不一致 正确答案&#xff1a;C 2、如图所示&#xff0c;路由器的所有接口开启…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023