1. Overview
Recently studied FFmpeg development, the function is too powerful, there are still many articles on ffmpeg 3 and 4 on the Internet, but learn well, the latest or can not let go, I chose a new ffmpeg n5.1.2 version, and the 3, 4 version API changes are still quite big;
In this Demo, Qt + FFmpeg is mainly used to develop a [simple screen recording software], here the main use is [soft decoding], you can see the previous article if you need to use hard decoding;
In order to facilitate learning, only video images are recorded here, and no information such as audio is introduced;
Since the recorded video image format and the saved image format are not necessarily the same, so the image format conversion is required in the middle, and the sws_scale () that comes with FFmpeg is used here, and I heard that libyuv has stronger performance, and I am studying it later.
Description of the development environment
- System: Windows 10, Ubuntu 20.04
- Qt version: V5.12.5
- Compilers: MSVC2017-64, GCC/G++64
- FFmpeg version: n5.1.2 (Note: If the version is wrong, the program may not run)
- Official download
- The library I use
2. Achieve the effect
Grab desktop images and transcode them and save them to local video files;
Support a variety of common video file types;
Support Windows, Linux screen recording function;
Support full-screen recording function, recording specified area function;
By default, the recorded video is saved to the system's video folder;
The main functions are divided into four parts: screen recording thread, screen recording decoding, image pixel conversion, and encoding and saving.
3. FFmpeg screen recording code process
- White part: mainly for grabbing desktop image decoding process;
- Green part: Transcode/encode desktop images to a video file.
How to get C++ audio and video learning materials for free: Follow the audio and video development brother, click "Link" to get the latest C++ audio and video development advanced exclusive free learning package in 2023 for free!
4. Main code
Don't say anything, go directly to the code, everything is commented
4.1 videodecode.h file
/******************************************************************************
* @文件名 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 4.2 Videodecode .cpp files
#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);
}
} 4.3 videocodec.h file
/******************************************************************************
* @文件名 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 4.4 Videocodec .cpp files
#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. Complete source code
- github
- gitee
Original link: Qt-FFmpeg Liao € 鍙 - 瀹炵幇夰曞睆熻兘锛 10 锛 - 鍺橀晾