Merge branch 'Dev'

FFmpegDemo/FFmpegDemo.md

@@ -13,9 +13,10 @@
 | VideoPlayGL2  | 使用ffmpeg音视频库【软解码 + OpenGL显示YUV图像】实现的视频播放器； |
 | VideoPlayHW   | 使用ffmpeg音视频库【硬解码】实现的视频播放器；               |
 | VideoPlayHWGL | 使用ffmpeg音视频库【软/硬解码 + OpenGL显示YUV/NV12】实现的视频播放器； |
-| VideoCamera1  | FFmpeg打开本地摄像头简单示例（软解码+OpenGL）                |
-| AVIOReading   | API示例程序，演示如何从通过AVIOContext访问的自定义缓冲区读取数据。 |
-| DecodeAudio   | 使用libavcodec API的音频解码示例（MP3转pcm）                 |
+| VideoCamera1  | FFmpeg打开本地摄像头简单示例（软解码+OpenGL）；              |
+| VideoCamera2  | 使用ffmpeg音视频库【软解码】打开本地摄像头【录制视频】保存到本地示例； |
+| AVIOReading   | API示例程序，演示如何从通过AVIOContext访问的自定义缓冲区读取数据； |
+| DecodeAudio   | 使用libavcodec API的音频解码示例（MP3转pcm）；               |
 
 
 
@@ -142,10 +143,24 @@
 > 1. 使用ffmpeg音视频库【软解码】打开【本地摄像头】；                                       
 > 2. 采用【OpenGL显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示；
 > 3. 将YUV转RGB的步骤由CPU转换改为使用GPU转换，降低CPU占用率；                          
-> 4. 视频播放支持实时开始/关闭、暂停/继续播放；                                        
+> 4. 支持Windows、Linux打开本地摄像头；                                        
 > 5. 视频解码、线程控制、显示各部分功能分离，低耦合度。                                     
 > 6. 采用最新的5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚。      
 
 ![VideoCamera1](FFmpegDemo.assets/VideoCamera1.gif)
 
 ![image-20221027235118681](FFmpegDemo.assets/image-20221027235118681.png)
+
+
+
+### 1.9 VideoCamera2
+
+> 1. 使用ffmpeg音视频库【软解码】打开本地摄像头【录制视频】保存到本地；                             
+> 2. 采用【OpenGL显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示； 
+> 3. 将YUV转RGB的步骤由CPU转换改为使用GPU转换，降低CPU占用率；                           
+> 4. 支持Windows、Linux打开本地摄像头；                                        
+> 5. 支持使用【静态帧率】、【动态帧率】录制视频；                                         
+> 6. 视频解码、线程控制、显示各部分功能分离，低耦合度。                                      
+> 7. 采用最新的5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚。       
+
+![VideoCamera2-tuya](FFmpegDemo.assets/VideoCamera2-tuya.gif)

FFmpegDemo/FFmpegDemo.pro

@@ -16,6 +16,7 @@ SUBDIRS += VideoPlayGL2    # 使用软解码实现的视频播放器 使用OpenG
 SUBDIRS += VideoPlayHW     # 使用硬件解码实现的视频播放器
 SUBDIRS += VideoPlayHWGL   # 使用硬件解码实现的视频播放器 使用OpenGL显示YUV/NV12图像
 SUBDIRS += VideoCamera1    # FFmpeg打开本地摄像头简单示例（软解码+OpenGL）
+SUBDIRS += VideoCamera2    # FFmpeg打开本地摄像头【录制视频】保存到本地示例（软解码+OpenGL）
 
 SUBDIRS += AVIOReading     # 使用libavformat解复用器通过自定义AVIOContext读取回调访问媒体内容。
 SUBDIRS += DecodeAudio     # 使用libavcodec API的音频解码示例（MP3转pcm）

FFmpegDemo/VideoCamera1/VideoCamera1.pro

@@ -9,7 +9,7 @@
 # @备注       1、使用ffmpeg音视频库【软解码】打开本地摄像头；
 #             2、采用【OpenGL显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示；
 #             3、将YUV转RGB的步骤由CPU转换改为使用GPU转换，降低CPU占用率；
-#             4、视频播放支持实时开始/关闭、暂停/继续播放；
+#             4、支持Windows、Linux打开本地摄像头；
 #             5、视频解码、线程控制、显示各部分功能分离，低耦合度。
 #             6、采用最新的5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚。
 #---------------------------------------------------------------------------------------

FFmpegDemo/VideoCamera1/VideoPlay/videodecode.cpp

@@ -29,9 +29,9 @@ VideoDecode::VideoDecode()
      * video4linux2：Linux输入视频设备
      */
 #if defined(Q_OS_WIN)
-    m_inputFormat = av_find_input_format("dshow");
+    m_inputFormat = av_find_input_format("dshow");            // Windows下如果没有则不能打开摄像头
 #elif defined(Q_OS_LINUX)
-    m_inputFormat = av_find_input_format("video4linux2");       // 也可以不需要
+    m_inputFormat = av_find_input_format("video4linux2");       // Linux也可以不需要就可以打开摄像头
 #elif defined(Q_OS_MAC)
     m_inputFormat = av_find_input_format("avfoundation");
 #endif

FFmpegDemo/VideoCamera2/VideoCamera2.pro

+#---------------------------------------------------------------------------------------
+# @功能：       使用ffmpeg音视频库【软解码】打开本地摄像头【录制视频】保存到本地示例；
+# @编译器：     Desktop Qt 5.12.5 MSVC2017 64bit 32bit（也支持其它编译器）
+# @Qt IDE：    D:/Qt/Qt5.12.5/Tools/QtCreator/share/qtcreator
+#
+# @开发者     mhf
+# @邮箱       1603291350@qq.com
+# @时间       2022-09-14 14:13:52
+# @备注       1、使用ffmpeg音视频库【软解码】打开本地摄像头【录制视频】保存到本地；
+#             2、采用【OpenGL显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示；
+#             3、将YUV转RGB的步骤由CPU转换改为使用GPU转换，降低CPU占用率；
+#             4、支持Windows、Linux打开本地摄像头；
+#             5、支持使用【静态帧率】、【动态帧率】录制视频；
+#             6、视频解码、线程控制、显示各部分功能分离，低耦合度。
+#             7、采用最新的5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚。
+#---------------------------------------------------------------------------------------
+QT       += core gui multimedia
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+CONFIG += c++11
+DEFINES += QT_DEPRECATED_WARNINGS
+
+SOURCES += \
+    playimage.cpp \
+    main.cpp \
+    widget.cpp
+
+HEADERS += \
+    playimage.h \
+    widget.h
+
+FORMS += \
+    widget.ui
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+# ffmpeg读取视频图像模块
+include(./VideoPlay/VideoPlay.pri)
+INCLUDEPATH += ./VideoPlay
+
+#  定义程序版本号
+VERSION = 1.2.0
+DEFINES += APP_VERSION=\\\"$$VERSION\\\"
+TARGET  = VideoCamera2
+
+contains(QT_ARCH, i386){        # 使用32位编译器
+DESTDIR = $$PWD/../bin          # 程序输出路径
+}else{
+DESTDIR = $$PWD/../bin64        # 使用64位编译器
+}
+# msvc  编译器使用utf-8编码
+msvc {
+QMAKE_CFLAGS += /utf-8
+QMAKE_CXXFLAGS += /utf-8
+}
+
+DISTFILES += \
+    fragment.fsh \
+    vertex.vsh
+
+RESOURCES += \
+    rc.qrc

FFmpegDemo/VideoCamera2/VideoPlay/VideoPlay.pri

+#---------------------------------------------------------------------------------------
+# @功能：       ffmpeg读取视频图像模块
+# @编译器：     Desktop Qt 5.12.5 MSVC2017 64bit（也支持其它编译器）
+# @Qt IDE：    D:/Qt/Qt5.12.5/Tools/QtCreator/share/qtcreator
+#
+# @开发者     mhf
+# @邮箱       1603291350@qq.com
+# @时间       2022-09-15 14:27:25
+# @备注
+#---------------------------------------------------------------------------------------
+
+# 加载库，ffmpeg n5.1.2版本
+win32{
+LIBS += -LE:/lib/ffmpeg5-1-2/lib/ -lavcodec -lavfilter -lavformat -lswscale -lavutil -lswresample -lavdevice
+INCLUDEPATH += E:/lib/ffmpeg5-1-2/include
+DEPENDPATH += E:/lib/ffmpeg5-1-2/include
+
+#INCLUDEPATH += E:/lib/ffmpeg4/include
+#LIBS += -LE:/lib/ffmpeg4/lib/win64/ -lavcodec -lavdevice -lavfilter -lavformat -lavutil -lpostproc -lswresample -lswscale
+}
+
+unix:!macx{
+LIBS += -L/home/mhf/lib/ffmpeg/ffmpeg-5-1-2/lib -lavcodec -lavfilter -lavformat -lswscale -lavutil -lswresample -lavdevice
+INCLUDEPATH += /home/mhf/lib/ffmpeg/ffmpeg-5-1-2/include
+DEPENDPATH += /home/mhf/lib/ffmpeg/ffmpeg-5-1-2/include
+}
+
+HEADERS += \
+    $$PWD/readthread.h \        # 视频读取线程类
+    $$PWD/videodecode.h \       # ffmpeg解码类
+    $$PWD/videosave.h           # ffmpeg编码保存视频类
+
+SOURCES += \
+    $$PWD/readthread.cpp \
+    $$PWD/videodecode.cpp \
+    $$PWD/videosave.cpp

FFmpegDemo/VideoCamera2/VideoPlay/readthread.cpp

+#include "readthread.h"
+#include "videodecode.h"
+#include "videosave.h"
+
+#include<QVariant>
+
+#include <QEventLoop>
+#include <QTimer>
+#include <QDebug>
+#include <qimage.h>
+#include <playimage.h>
+
+extern "C" {        // 用C规则编译指定的代码
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
+#include "libavutil/avutil.h"
+#include "libswscale/swscale.h"
+#include "libavutil/imgutils.h"
+}
+
+ReadThread::ReadThread(QObject *parent) : QThread(parent)
+{
+    m_videoDecode = new VideoDecode();
+    m_videoSave   = new VideoSave();
+
+    // 注册自定义枚举类型，否则信号槽无法发送
+    qRegisterMetaType<PlayState>("PlayState");
+}
+
+ReadThread::~ReadThread()
+{
+    if(m_videoSave)
+    {
+        delete m_videoSave;
+    }
+    if(m_videoDecode)
+    {
+        delete m_videoDecode;
+    }
+}
+
+/**
+ * @brief      传入播放的视频地址并开启线程
+ * @param url
+ */
+void ReadThread::open(const QString &url)
+{
+    if(!this->isRunning())
+    {
+        m_url = url;
+        emit this->start();
+    }
+}
+
+
+/**
+ * @brief 关闭播放
+ */
+void ReadThread::close()
+{
+    m_play = false;
+}
+
+/**
+ * @brief    返回当前播放的地址
+ * @return
+ */
+const QString &ReadThread::url()
+{
+    return m_url;
+}
+
+void ReadThread::savaVideo(const QString &fileName)
+{
+    m_videoSave->open(m_videoDecode->getVideoStream(), fileName);
+}
+
+void ReadThread::stop()
+{
+    m_videoSave->close();
+}
+
+/**
+ * @brief      非阻塞延时
+ * @param msec 延时毫秒
+ */
+void  sleepMsec(int msec)
+{
+    if(msec <= 0) return;
+    QEventLoop loop;		//定义一个新的事件循环
+    QTimer::singleShot(msec, &loop, SLOT(quit()));//创建单次定时器，槽函数为事件循环的退出函数
+    loop.exec();			//事件循环开始执行，程序会卡在这里，直到定时时间到，本循环被退出
+}
+
+void ReadThread::run()
+{
+    bool ret = m_videoDecode->open(m_url);         // 打开网络流时会比较慢，如果放到Ui线程会卡
+    if(ret)
+    {
+        m_play = true;
+        emit playState(play);
+    }
+    else
+    {
+        qWarning() << "打开失败！";
+    }
+
+    // 循环读取视频图像
+    while (m_play)
+    {
+        AVFrame* frame = m_videoDecode->read();  // 读取视频图像
+        if(frame)
+        {
+            m_videoSave->write(frame);
+            emit repaint(frame);
+        }
+        else
+        {
+            // 当前读取到无效图像时判断是否读取完成
+            if(m_videoDecode->isEnd())
+            {
+                break;
+            }
+            sleepMsec(1);   // 这里不能使用QThread::msleep()延时，否则会很不稳定
+        }
+    }
+
+    qDebug() << "关闭摄像头！" ;
+    m_videoDecode->close();
+    emit playState(end);
+}

FFmpegDemo/VideoCamera2/VideoPlay/readthread.h

+/******************************************************************************
+ * @文件名     readthread.h
+ * @功能       读取视频图像数据线程，在线程中解码视频
+ *
+ * @开发者     mhf
+ * @邮箱       1603291350@qq.com
+ * @时间       2022/09/15
+ * @备注
+ *****************************************************************************/
+#ifndef READTHREAD_H
+#define READTHREAD_H
+
+#include <QThread>
+#include <QTime>
+
+class VideoDecode;
+class VideoSave;
+class PlayImage;
+struct AVFrame;
+
+class ReadThread : public QThread
+{
+    Q_OBJECT
+public:
+    enum PlayState      // 视频播放状态
+    {
+        play,
+        end
+    };
+public:
+    explicit ReadThread(QObject *parent = nullptr);
+    ~ReadThread() override;
+
+    void open(const QString& url = QString());  // 打开视频
+    void pause(bool flag);                      // 暂停视频
+    void close();                               // 关闭视频
+    const QString& url();                       // 获取打开的视频地址
+    void savaVideo(const QString& fileName);    // 录制视频
+    void stop();                                // 停止录制
+
+protected:
+    void run() override;
+
+signals:
+    void repaint(AVFrame* frame);               // 重绘
+    void playState(PlayState state);            // 视频播放状态发送改变时触发
+
+private:
+    VideoDecode* m_videoDecode = nullptr;       // 视频解码类
+    VideoSave*   m_videoSave   = nullptr;       // 视频编码保存类
+    QString      m_url;                         // 打开的视频地址
+    bool         m_play        = false;         // 播放控制
+};
+
+#endif // READTHREAD_H

FFmpegDemo/VideoCamera2/VideoPlay/videodecode.cpp

+#include "videodecode.h"
+#include <QDebug>
+#include <QImage>
+#include <QMutex>
+#include <qdatetime.h>
+#include <qelapsedtimer.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();      // 5.1.2版本不需要调用了
+
+    m_error = new char[ERROR_LEN];
+
+    /**
+     * dshow：  Windows 媒体输入设备。目前仅支持音频和视频设备。
+     * gdigrab：基于 Win32 GDI 的屏幕捕获设备
+     * video4linux2：Linux输入视频设备
+     */
+#if defined(Q_OS_WIN)
+    m_inputFormat = av_find_input_format("dshow");            // Windows下如果没有则不能打开摄像头
+#elif defined(Q_OS_LINUX)
+    m_inputFormat = av_find_input_format("video4linux2");       // Linux也可以不需要就可以打开摄像头
+#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;
+    /**
+     * Windows：可使用【ffmpeg -list_options true -f dshow -i video="Lenovo EasyCamera"】命令查看摄像头支持的编码器、帧率、分辨率等信息
+     * Linux：可使用【ffmpeg -list_formats all -i /dev/video0】或【ffplay -f video4linux2 -list_formats all /dev/video0】命令查看摄像头支持的支持的像素格式、编解码器和帧大小
+     */
+    // 设置解码器（Linux下打开本地摄像头默认为rawvideo解码器，输入图像为YUYV420，不方便显示，有两种解决办法，1：使用sws_scale把YUYV422转为YUVJ422P；2：指定mjpeg解码器输出YUVJ422P图像）
+    av_dict_set(&dict, "input_format", "mjpeg", AV_OPT_SEARCH_CHILDREN);
+    av_dict_set(&dict, "framerate", "30", 0);                // 设置帧率
+//    av_dict_set(&dict, "pixel_format", "yuvj422p", 0);     // 设置像素格式
+    av_dict_set(&dict, "video_size", "1280x720", 0);       // 设置视频分辨率（如果该分辨率摄像头不支持则会报错）
+
+    // 打开输入流并返回解封装上下文
+    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* m_outStream = m_formatContext->streams[m_videoIndex];  // 通过查询到的索引获取视频流
+
+    // 获取视频图像分辨率（AVStream中的AVCodecContext在新版本中弃用，改为使用AVCodecParameters）
+    m_size.setWidth(m_outStream->codecpar->width);
+    m_size.setHeight(m_outStream->codecpar->height);
+    m_frameRate = rationalToDouble(&m_outStream->avg_frame_rate);  // 视频帧率
+
+    // 通过解码器ID获取视频解码器（新版本返回值必须使用const）
+    const AVCodec* codec = avcodec_find_decoder(m_outStream->codecpar->codec_id);
+    m_totalFrames = m_outStream->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, m_outStream->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;
+    }
+
+    // 分配图像空间
+    int size = av_image_get_buffer_size(AV_PIX_FMT_RGBA, m_size.width(), m_size.height(), 4);
+    /**
+     * 【注意：】这里可以多分配一些，否则如果只是安装size分配，大部分视频图像数据拷贝没有问题，
+     *         但是少部分视频图像在使用sws_scale()拷贝时会超出数组长度，在使用使用msvc debug模式时delete[] m_buffer会报错（HEAP CORRUPTION DETECTED: after Normal block(#32215) at 0x000001AC442830370.CRT delected that the application wrote to memory after end of heap buffer）
+     *         特别是这个视频流http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4
+     */
+    m_buffer = new uchar[size + 1000];    // 这里多分配1000个字节就基本不会出现拷贝超出的情况了，反正不缺这点内存
+//    m_image = new QImage(m_buffer, m_size.width(), m_size.height(), QImage::Format_RGBA8888);  // 这种方式分配内存大部分情况下也可以，但是因为存在拷贝超出数组的情况，delete时也会报错
+    m_end = false;
+
+    return true;
+}
+
+/**
+ * @brief
+ * @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)     // 如果是图像数据则进行解码
+        {
+            // 计算当前帧时间（毫秒）
+#if 1       // 方法一：适用于所有场景，但是存在一定误差
+            m_packet->pts = qRound64(m_packet->pts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
+            m_packet->dts = qRound64(m_packet->dts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
+#else       // 方法二：适用于播放本地视频文件，计算每一帧时间较准，但是由于网络视频流无法获取总帧数，所以无法适用
+            m_obtainFrames++;
+            m_packet->pts = qRound64(m_obtainFrames * (qreal(m_totalTime) / m_totalFrames));
+#endif
+            // 将读取到的原始数据包传入解码器
+            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;
+}
+
+AVStream *VideoDecode::getVideoStream() const
+{
+    if(!m_formatContext)
+    {
+        return nullptr;
+    }
+    return m_formatContext->streams[m_videoIndex];
+}
+
+/**
+ * @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()
+{
+    // 释放上下文swsContext。
+    if(m_swsContext)
+    {
+        sws_freeContext(m_swsContext);
+        m_swsContext = nullptr;             // sws_freeContext不会把上下文置NULL
+    }
+    // 释放编解码器上下文和与之相关的所有内容，并将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);
+    }
+    if(m_buffer)
+    {
+        delete [] m_buffer;
+        m_buffer = nullptr;
+    }
+}

FFmpegDemo/VideoCamera2/VideoPlay/videodecode.h

+/******************************************************************************
+ * @文件名     videodecode.h
+ * @功能       视频解码类，在这个类中调用ffmpeg打开视频进行解码
+ *
+ * @开发者     mhf
+ * @邮箱       1603291350@qq.com
+ * @时间       2022/09/15
+ * @备注
+ *****************************************************************************/
+#ifndef VIDEODECODE_H
+#define VIDEODECODE_H
+
+#include <QString>
+#include <QSize>
+
+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();                                 // 是否读取完成
+    AVStream*  getVideoStream() const;
+
+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;   // 解码器上下文
+    SwsContext*      m_swsContext    = 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;                         // 视频读取完成
+    uchar* m_buffer = nullptr;                    // YUV图像需要转换位RGBA图像，这里保存转换后的图形数据
+};
+
+#endif // VIDEODECODE_H

FFmpegDemo/VideoCamera2/VideoPlay/videosave.cpp

+#include "videosave.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
+#define USE_H264 0      // 使用H264编码器
+
+VideoSave::VideoSave()
+{
+}
+
+VideoSave::~VideoSave()
+{
+    close();
+}
+
+/**
+ * @brief        显示ffmpeg函数调用异常信息
+ * @param err
+ */
+void VideoSave::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
+}
+
+bool VideoSave::open(AVStream *inStream, const QString &fileName)
+{
+    if(!inStream || fileName.isEmpty()) return false;
+
+    // 通过输出文件名为输出格式分配AVFormatContext。
+#if USE_H264
+    int ret = avformat_alloc_output_context2(&m_formatContext, nullptr, "h264", fileName.toStdString().data());
+#else
+    /**
+     * 摄像头打开使用的是mjpeg编码器；
+     * MJPEG压缩技术可以获取清晰度很高的视频图像，可以【动态调整帧率】适合保存摄像头视频、分辨率。但由于没有考虑到帧间变化，造成大量冗余信息被重复存储，因此单帧视频的占用空间较大；
+     * 如果采用其它编码器，由于摄像头曝光时间长度不一定，所以录像时帧率一直在变，编码器指定固定帧率会导致视频一会快一会慢，效果很不好，适用于录制固定帧率的视频（当然其它编码器应该是有处理办法，不过我还不清楚）；
+     */
+    QString strName = avcodec_find_encoder(inStream->codecpar->codec_id)->name;    // 获取编码器名称
+    int ret = avformat_alloc_output_context2(&m_formatContext, nullptr, strName.toStdString().data(), fileName.toStdString().data());  // 这里使用和解码一样的编码器，防止保存的图像颜色出问题
+#endif
+    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;
+    }
+
+    // 分配AVCodecContext并将其字段设置为默认值。
+    m_codecContext = avcodec_alloc_context3(codec);
+    if(!m_codecContext)
+    {
+        close();
+        showError(AVERROR(ENOMEM));
+        return false;
+    }
+    // 设置编码器上下文参数
+    m_codecContext->width = inStream->codecpar->width;                          // 图片宽度/高度
+    m_codecContext->height = inStream->codecpar->height;
+#if USE_H264
+    m_codecContext->pix_fmt = AV_PIX_FMT_YUV420P;
+#else
+    m_codecContext->pix_fmt = AVPixelFormat(inStream->codecpar->format);        // 像素格式，也可以使用codec->pix_fmts[0]或AV_PIX_FMT_YUVJ422P(【注意】摄像头解码的图像格式为yuvj422p，如果这里不一样可能保存会出问题，或者后面进行格式转换)
+#endif
+    m_codecContext->time_base = {1, 10};                   //设置时间基，20为分母，1为分子，表示以1/20秒时间间隔播放一帧图像
+    m_codecContext->framerate = {10, 1};
+    m_codecContext->bit_rate = 4000000;                    // 目标的码率，即采样的码率；显然，采样码率越大，视频大小越大，画质越高
+    m_codecContext->gop_size = 10;                         // I帧间隔
+    m_codecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+//    m_codecContext->max_b_frames = 1;                      // 非B帧之间的最大B帧数(有些格式不支持)
+//    m_codecContext->qmin = 1;
+//    m_codecContext->qmax = 5;
+//    m_codecContext->colorspace = AVCOL_SPC_BT470BG;
+//    m_codecContext->color_range = AVCOL_RANGE_JPEG;
+//    m_codecContext->color_primaries = AVCOL_PRI_BT709;
+//    m_codecContext->bits_per_coded_sample = 24;
+//    m_codecContext->bits_per_raw_sample = 8;
+//    av_opt_set(m_codecContext->priv_data, "preset", "placebo", 0);
+//    qDebug() << m_codecContext->pix_fmt;
+
+    // 打开编码器
+    ret = avcodec_open2(m_codecContext, nullptr, nullptr);
+#if USE_H264
+    ret = avcodec_open2(m_codecContext, codec, nullptr);      // 使用h264时第一次打不开，第二次可以打卡，不知道什么原因
+#endif
+    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;
+    }
+    qDebug() << "开始录制视频！";
+    return true;
+}
+
+/**
+ * @brief        写入数据
+ * @param frame
+ */
+void VideoSave::write(AVFrame *frame)
+{
+    QMutexLocker locker(&m_mutex);
+    if(!m_packet)
+    {
+        return;
+    }
+
+    if(frame)
+    {
+        frame->pts = m_index;
+        m_index++;
+    }
+
+    // 将图像传入编码器
+    avcodec_send_frame(m_codecContext, 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);
+    }
+}
+
+/**
+ * @brief 关闭保存数据
+ */
+void VideoSave::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;
+    }
+    // 释放编解码器上下文并置空
+    if(m_codecContext)
+    {
+        avcodec_free_context(&m_codecContext);
+    }
+    if(m_packet)
+    {
+        av_packet_free(&m_packet);
+        qDebug() << "停止录制视频！";
+    }
+}

FFmpegDemo/VideoCamera2/VideoPlay/videosave.h

+/******************************************************************************
+ * @文件名     videosave.h
+ * @功能       将视频编码后保存到文件中
+ *
+ * @开发者     mhf
+ * @邮箱       1603291350@qq.com
+ * @时间       2022/11/29
+ * @备注
+ *****************************************************************************/
+#ifndef VIDEOSAVE_H
+#define VIDEOSAVE_H
+
+#include <QString>
+#include <qmutex.h>
+
+
+struct AVCodecParameters;
+struct AVFormatContext;
+struct AVCodecContext;
+struct AVStream;
+struct AVFrame;
+struct AVPacket;
+struct AVOutputFormat;
+
+class VideoSave
+{
+public:
+    VideoSave();
+    ~VideoSave();
+
+    bool open(AVStream *inStream, const QString& fileName);
+    void write(AVFrame* frame);
+    void close();
+
+private:
+    void showError(int err);
+
+private:
+    AVFormatContext* m_formatContext = nullptr;
+    AVCodecContext * m_codecContext  = nullptr;    // 编码器上下文
+    AVStream       * m_videoStream   = nullptr;
+    AVPacket       * m_packet        = nullptr;    // 数据包
+    int m_index = 0;
+    bool             m_writeHeader   = false;      // 是否写入头
+    QMutex           m_mutex;
+};
+
+#endif // VIDEOSAVE_H

FFmpegDemo/VideoCamera2/fragment.fsh

+#version 330 core
+in  vec2 TexCord;            // 纹理坐标
+uniform sampler2D tex_y;
+uniform sampler2D tex_u;
+uniform sampler2D tex_v;
+
+void main()
+{
+    vec3 yuv;
+    vec3 rgb;
+
+    // YUV转RGB
+    yuv.x = texture2D(tex_y, TexCord).r;
+    yuv.y = texture2D(tex_u, TexCord).r-0.5;
+    yuv.z = texture2D(tex_v, TexCord).r-0.5;
+
+    rgb = mat3(1.0, 1.0, 1.0,
+               0.0, -0.39465, 2.03211,
+               1.13983, -0.58060, 0.0) * yuv;
+    gl_FragColor = vec4(rgb, 1.0);
+}

FFmpegDemo/VideoCamera2/main.cpp

+#include "widget.h"
+
+#include <QApplication>
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    Widget w;
+    w.show();
+    return a.exec();
+}

FFmpegDemo/VideoCamera2/playimage.cpp

+#include "playimage.h"
+
+extern "C" {        // 用C规则编译指定的代码
+#include "libavcodec/avcodec.h"
+
+}
+
+#if USE_WINDOW
+PlayImage::PlayImage(QOpenGLWindow::UpdateBehavior updateBehavior, QWindow *parent):QOpenGLWindow(updateBehavior, parent)
+{
+    // 初始化视图大小，由于Shader里面有YUV转RGB的代码，会初始化显示为绿色，这里通过将视图大小设置为0避免显示绿色背景
+    m_pos = QPointF(0, 0);
+    m_zoomSize = QSize(0, 0);
+}
+#else
+PlayImage::PlayImage(QWidget *parent, Qt::WindowFlags f): QOpenGLWidget(parent, f)
+{
+    // 初始化视图大小，由于Shader里面有YUV转RGB的代码，会初始化显示为绿色，这里通过将视图大小设置为0避免显示绿色背景
+    m_pos = QPointF(0, 0);
+    m_zoomSize = QSize(0, 0);
+}
+#endif
+
+
+PlayImage::~PlayImage()
+{
+    if(!isValid()) return;        // 如果控件和OpenGL资源（如上下文）已成功初始化，则返回true。
+    this->makeCurrent(); // 通过将相应的上下文设置为当前上下文并在该上下文中绑定帧缓冲区对象，为呈现此小部件的OpenGL内容做准备。
+    // 释放纹理
+    if(m_texY)
+    {
+        m_texY->destroy();
+        delete m_texY;
+    }
+    if(m_texU)
+    {
+        m_texU->destroy();
+        delete m_texU;
+    }
+    if(m_texV)
+    {
+        m_texV->destroy();
+        delete m_texV;
+    }
+    this->doneCurrent();    // 释放上下文
+    // 释放
+    glDeleteBuffers(1, &VBO);
+    glDeleteBuffers(1, &EBO);
+    glDeleteVertexArrays(1, &VAO);
+}
+
+void PlayImage::repaint(AVFrame *frame)
+{
+    // 如果帧长宽为0则不需要绘制
+    if(!frame || frame->width == 0 || frame->height == 0)
+    {
+        av_frame_unref(frame);  //  取消引用帧引用的所有缓冲区并重置帧字段。
+        return;
+    }
+
+    // 当切换显示的视频后，如果分辨率不同则需要重新创建纹理，否则会崩溃
+    if(frame->width != m_size.width() || frame->height != m_size.height())
+    {
+        if(m_texY && m_texU && m_texV)
+        {
+            m_texY->destroy();
+            m_texU->destroy();
+            m_texV->destroy();
+            delete m_texY;
+            delete m_texU;
+            delete m_texV;
+            m_texY = nullptr;
+            m_texU = nullptr;
+            m_texV = nullptr;
+        }
+    }
+    if(!m_texY) // 初始化纹理
+    {
+        // 创建2D纹理
+        m_texY = new QOpenGLTexture(QOpenGLTexture::Target2D);
+        m_texU = new QOpenGLTexture(QOpenGLTexture::Target2D);
+        m_texV = new QOpenGLTexture(QOpenGLTexture::Target2D);
+
+        // 设置纹理大小                                                //  YUV444    YUV422    YUV422
+        m_texY->setSize(frame->width, frame->height);                //   w,h      w,h       w,h
+        m_texU->setSize(frame->width / 2, frame->height);            //   w,h      w/2,h      w/2,h/2
+        m_texV->setSize(frame->width / 2, frame->height);            //   w,h      w/2,h      w/2,h/2
+
+        // 设置放大、缩小过滤器
+        m_texY->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
+        m_texU->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
+        m_texV->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
+
+        // 设置图像格式
+        m_texY->setFormat(QOpenGLTexture::R8_UNorm);
+        m_texU->setFormat(QOpenGLTexture::R8_UNorm);
+        m_texV->setFormat(QOpenGLTexture::R8_UNorm);
+
+        // 分配内存
+        m_texY->allocateStorage();
+        m_texU->allocateStorage();
+        m_texV->allocateStorage();
+
+        // 记录图像分辨率
+        m_size.setWidth(frame->width);
+        m_size.setHeight(frame->height);
+        resizeGL(this->width(), this->height());
+    }
+    m_options.setImageHeight(frame->height);
+    m_options.setRowLength(frame->linesize[0]);
+    m_texY->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[0]), &m_options);   // 设置图像数据 Y
+    m_options.setRowLength(frame->linesize[1]);
+    m_texU->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[1]), &m_options);   // 设置图像数据 U
+    m_options.setRowLength(frame->linesize[2]);
+    m_texV->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[2]), &m_options);   // 设置图像数据 V
+
+    av_frame_unref(frame);  //  取消引用帧引用的所有缓冲区并重置帧字段。
+
+    this->update();
+}
+
+// 三个顶点坐标XYZ，VAO、VBO数据播放，范围时[-1 ~ 1]直接
+static GLfloat vertices[] = {  // 前三列点坐标，后两列为纹理坐标
+     1.0f,  1.0f, 0.0f, 1.0f, 1.0f,      // 右上角
+     1.0f, -1.0f, 0.0f, 1.0f, 0.0f,      // 右下
+    -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,      // 左下
+    -1.0f,  1.0f, 0.0f, 0.0f, 1.0f      // 左上
+};
+static GLuint indices[] = {
+    0, 1, 3,
+    1, 2, 3
+};
+void PlayImage::initializeGL()
+{
+    initializeOpenGLFunctions();
+
+    // 加载shader脚本程序
+    m_program = new QOpenGLShaderProgram(this);
+    m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex.vsh");
+    m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment.fsh");
+    m_program->link();
+
+    // 绑定YUV 变量值
+    m_program->bind();
+    m_program->setUniformValue("tex_y", 0);
+    m_program->setUniformValue("tex_u", 1);
+    m_program->setUniformValue("tex_v", 2);
+
+    // 返回属性名称在此着色器程序的参数列表中的位置。如果名称不是此着色器程序的有效属性，则返回-1。
+    GLuint posAttr = GLuint(m_program->attributeLocation("aPos"));
+    GLuint texCord = GLuint(m_program->attributeLocation("aTexCord"));
+
+    glGenVertexArrays(1, &VAO);
+    glBindVertexArray(VAO);
+
+    glGenBuffers(1, &VBO);
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glGenBuffers(1, &EBO);    // 创建一个EBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+
+
+    // 为当前绑定到的缓冲区对象创建一个新的数据存储target。任何预先存在的数据存储都将被删除。
+    glBufferData(GL_ARRAY_BUFFER,        // 为VBO缓冲绑定顶点数据
+                       sizeof (vertices),      // 数组字节大小
+                       vertices,               // 需要绑定的数组
+                       GL_STATIC_DRAW);        // 指定数据存储的预期使用模式,GL_STATIC_DRAW： 数据几乎不会改变
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);  // 将顶点索引数组传入EBO缓存
+    // 设置顶点坐标数据
+    glVertexAttribPointer(posAttr,                     // 指定要修改的通用顶点属性的索引
+                          3,                     // 指定每个通用顶点属性的组件数（如vec3：3，vec4：4）
+                          GL_FLOAT,              // 指定数组中每个组件的数据类型(数组中一行有几个数)
+                          GL_FALSE,              // 指定在访问定点数据值时是否应规范化 ( GL_TRUE) 或直接转换为定点值 ( GL_FALSE)，如果vertices里面单个数超过-1或者1可以选择GL_TRUE
+                          5 * sizeof(GLfloat),   // 指定连续通用顶点属性之间的字节偏移量。
+                          nullptr);              // 指定当前绑定到目标的缓冲区的数据存储中数组中第一个通用顶点属性的第一个组件的偏移量。初始值为0 (一个数组从第几个字节开始读)
+    // 启用通用顶点属性数组
+    glEnableVertexAttribArray(posAttr);                // 属性索引是从调用glGetAttribLocation接收的，或者传递给glBindAttribLocation。
+
+    // 设置纹理坐标数据
+    glVertexAttribPointer(texCord, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), reinterpret_cast<const GLvoid *>(3 * sizeof (GLfloat)));              // 指定当前绑定到目标的缓冲区的数据存储中数组中第一个通用顶点属性的第一个组件的偏移量。初始值为0 (一个数组从第几个字节开始读)
+    // 启用通用顶点属性数组
+    glEnableVertexAttribArray(texCord);                // 属性索引是从调用glGetAttribLocation接收的，或者传递给glBindAttribLocation。
+
+    // 释放
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);                        // 设置为零以破坏现有的顶点数组对象绑定
+
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);        // 指定颜色缓冲区的清除值(背景色)
+
+
+}
+
+void PlayImage::resizeGL(int w, int h)
+{
+    if(m_size.width()  < 0 || m_size.height() < 0) return;
+
+    // 计算需要显示图片的窗口大小，用于实现长宽等比自适应显示
+    if((double(w) / h) < (double(m_size.width()) / m_size.height()))
+    {
+        m_zoomSize.setWidth(w);
+        m_zoomSize.setHeight(((double(w) / m_size.width()) * m_size.height()));   // 这里不使用QRect，使用QRect第一次设置时有误差bug
+    }
+    else
+    {
+        m_zoomSize.setHeight(h);
+        m_zoomSize.setWidth((double(h) / m_size.height()) * m_size.width());
+    }
+    m_pos.setX(double(w - m_zoomSize.width()) / 2);
+    m_pos.setY(double(h - m_zoomSize.height()) / 2);
+    this->update(QRect(0, 0, w, h));
+}
+
+void PlayImage::paintGL()
+{
+    glClear(GL_COLOR_BUFFER_BIT);     // 将窗口的位平面区域（背景）设置为先前由glClearColor、glClearDepth和选择的值
+    glViewport(m_pos.x(), m_pos.y(), m_zoomSize.width(), m_zoomSize.height());  // 设置视图大小实现图片自适应
+
+    m_program->bind();               // 绑定着色器
+    // 绑定纹理
+    if(m_texY && m_texU && m_texV)
+    {
+        m_texY->bind(0);
+        m_texU->bind(1);
+        m_texV->bind(2);
+    }
+
+    glBindVertexArray(VAO);           // 绑定VAO
+
+    glDrawElements(GL_TRIANGLES,      // 绘制的图元类型
+                   6,                 // 指定要渲染的元素数(点数)
+                   GL_UNSIGNED_INT,   // 指定索引中值的类型(indices)
+                   nullptr);          // 指定当前绑定到GL_ELEMENT_array_buffer目标的缓冲区的数据存储中数组中第一个索引的偏移量。
+    glBindVertexArray(0);
+    if(m_texY && m_texU && m_texV)
+    {
+        m_texY->release();
+        m_texU->release();
+        m_texV->release();
+    }
+    m_program->release();
+}

FFmpegDemo/VideoCamera2/playimage.h

+/******************************************************************************
+ * @文件名     playimage.h
+ * @功能       使用OpenGL实现YUV图像的绘制，可通过USE_WINDOW宏切换使用QOpenGLWindow还是QOpenGLWidget
+ *
+ * @开发者     mhf
+ * @邮箱       1603291350@qq.com
+ * @时间       2022/10/14
+ * @备注
+ *****************************************************************************/
+#ifndef PLAYIMAGE_H
+#define PLAYIMAGE_H
+
+#include <QWidget>
+#include <QOpenGLFunctions_3_3_Core>
+#include <qopenglshaderprogram.h>
+#include <QOpenGLTexture>
+#include <qopenglpixeltransferoptions.h>
+
+struct AVFrame;
+
+#define USE_WINDOW 0    // 1:使用QOpenGLWindow显示, 0：使用QOpenGLWidget显示
+
+#if USE_WINDOW
+#include <QOpenGLWindow>
+class PlayImage : public QOpenGLWindow, public  QOpenGLFunctions_3_3_Core
+#else
+#include <QOpenGLWidget>
+class PlayImage : public QOpenGLWidget, public  QOpenGLFunctions_3_3_Core
+#endif
+{
+    Q_OBJECT
+public:
+#if USE_WINDOW
+    explicit PlayImage(UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr);
+#else
+    explicit PlayImage(QWidget* parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
+#endif
+     ~PlayImage() override;
+
+    void repaint(AVFrame* frame);             // 重绘
+
+
+protected:
+    void initializeGL() override;               // 初始化gl
+    void resizeGL(int w, int h) override;       // 窗口尺寸变化
+    void paintGL() override;                    // 刷新显示
+
+private:
+    QOpenGLShaderProgram* m_program = nullptr;
+    QOpenGLTexture* m_texY = nullptr;           // 存储YUV图像中的Y数据
+    QOpenGLTexture* m_texU = nullptr;           // 存储YUV图像中的U数据
+    QOpenGLTexture* m_texV = nullptr;           // 存储YUV图像中的V数据
+    QOpenGLPixelTransferOptions m_options;
+
+    GLuint VBO = 0;       // 顶点缓冲对象,负责将数据从内存放到缓存，一个VBO可以用于多个VAO
+    GLuint VAO = 0;       // 顶点数组对象,任何随后的顶点属性调用都会储存在这个VAO中，一个VAO可以有多个VBO
+    GLuint EBO = 0;       // 元素缓冲对象,它存储 OpenGL 用来决定要绘制哪些顶点的索引
+    QSize  m_size;
+    QSizeF  m_zoomSize;
+    QPointF m_pos;
+};
+
+#endif // PLAYIMAGE_H

FFmpegDemo/VideoCamera2/rc.qrc

+<RCC>
+    <qresource prefix="/">
+        <file>fragment.fsh</file>
+        <file>vertex.vsh</file>
+    </qresource>
+</RCC>

FFmpegDemo/VideoCamera2/vertex.vsh

+#version 330 core
+layout (location = 0) in vec3 aPos;
+layout (location = 1) in vec2 aTexCord;
+out vec2 TexCord;    // 纹理坐标
+void main()
+{
+    gl_Position =  vec4(aPos.x, -aPos.y, aPos.z, 1.0);   // 图像坐标和OpenGL坐标Y轴相反，
+    TexCord = aTexCord;
+}

FFmpegDemo/VideoCamera2/widget.cpp

+#include "widget.h"
+#include "ui_widget.h"
+#include <QCameraInfo>
+#include <QFileDialog>
+
+extern "C" {        // 用C规则编译指定的代码
+#include "libavcodec/avcodec.h"
+}
+Q_DECLARE_METATYPE(AVFrame)  //注册结构体，否则无法通过信号传递AVFrame
+
+Widget::Widget(QWidget *parent)
+    : QWidget(parent)
+    , ui(new Ui::Widget)
+{
+    ui->setupUi(this);
+    this->setWindowTitle(QString("Qt+ffmpeg打开本地摄像头录像Demo V%1").arg(APP_VERSION));
+
+
+    // 使用QOpenGLWindow绘制
+    playImage = new PlayImage;
+#if USE_WINDOW
+    ui->verticalLayout->addWidget(QWidget::createWindowContainer(playImage));   // 这一步加载速度要比OpenGLWidget慢一点
+#else
+    ui->verticalLayout->addWidget(playImage);
+#endif
+
+    m_readThread = new ReadThread();
+    connect(m_readThread, &ReadThread::repaint, playImage, &PlayImage::repaint, Qt::BlockingQueuedConnection);
+    connect(m_readThread, &ReadThread::playState, this, &Widget::on_playState);
+
+    // 获取可用摄像头列表
+    QList<QCameraInfo> cameras = QCameraInfo::availableCameras();
+    for(auto camera : cameras)
+    {
+#if defined(Q_OS_WIN)
+        ui->com_url->addItem("video=" + camera.description());    // ffmpeg在Window下要使用video=description()
+#elif defined(Q_OS_LINUX)
+        ui->com_url->addItem(camera.deviceName());                // ffmpeg在linux下要使用deviceName()
+#elif defined(Q_OS_MAC)
+#endif
+    }
+}
+
+Widget::~Widget()
+{
+    // 释放视频读取线程
+    if(m_readThread)
+    {
+        // 由于使用了BlockingQueuedConnection，所以在退出时如果信号得不到处理就会卡死，所以需要取消绑定
+        disconnect(m_readThread, &ReadThread::repaint, playImage, &PlayImage::repaint);
+        m_readThread->close();
+        m_readThread->wait();
+        delete m_readThread;
+    }
+    delete ui;
+}
+
+/**
+ * @brief  视频播放/停止
+ */
+void Widget::on_but_open_clicked()
+{
+    if(ui->but_open->text() == "开始播放")
+    {
+        m_readThread->open(ui->com_url->currentText());
+    }
+    else
+    {
+        m_readThread->close();
+    }
+}
+
+/**
+ * @brief        根据视频播放状态切换界面设置
+ * @param state
+ */
+void Widget::on_playState(ReadThread::PlayState state)
+{
+    if(state == ReadThread::play)
+    {
+        this->setWindowTitle(QString("正在播放：%1").arg(m_readThread->url()));
+        ui->but_open->setText("停止播放");
+    }
+    else
+    {
+        ui->but_open->setText("开始播放");
+        this->setWindowTitle(QString("Qt+ffmpeg打开本地摄像头录像Demo V%1").arg(APP_VERSION));
+    }
+}
+
+/**
+ * @brief 录制视频保存到本地
+ */
+void Widget::on_but_save_clicked()
+{
+    if(ui->but_save->text() == "开始录制")
+    {
+        m_readThread->savaVideo(QString("%1.mp4").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_HH-mm-ss")));
+        ui->but_save->setText("停止");
+    }
+    else
+    {
+        m_readThread->stop();
+        ui->but_save->setText("开始录制");
+    }
+}

FFmpegDemo/VideoCamera2/widget.h

+#ifndef WIDGET_H
+#define WIDGET_H
+
+#include <QWidget>
+#include "readthread.h"
+#include "playimage.h"
+
+QT_BEGIN_NAMESPACE
+namespace Ui { class Widget; }
+QT_END_NAMESPACE
+
+class Widget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    Widget(QWidget *parent = nullptr);
+    ~Widget();
+
+private slots:
+    void on_but_open_clicked();
+
+    void on_playState(ReadThread::PlayState state);
+
+    void on_but_save_clicked();
+
+private:
+    Ui::Widget *ui;
+
+    PlayImage* playImage = nullptr;
+    ReadThread* m_readThread = nullptr;
+};
+#endif // WIDGET_H

FFmpegDemo/VideoCamera2/widget.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Widget</class>
+ <widget class="QWidget" name="Widget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Widget</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QComboBox" name="com_url">
+       <property name="editable">
+        <bool>true</bool>
+       </property>
+       <property name="insertPolicy">
+        <enum>QComboBox::InsertAtBottom</enum>
+       </property>
+       <property name="sizeAdjustPolicy">
+        <enum>QComboBox::AdjustToMinimumContentsLengthWithIcon</enum>
+       </property>
+       <property name="duplicatesEnabled">
+        <bool>false</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="but_open">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>开始播放</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="but_save">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>开始录制</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

OpenCVDemo/VideoPlay/VideoPlay.pro

 #---------------------------------------------------------------------------------------
 # @功能：       需要opencv是包含ffmpeg的，如果不包含则打开本地视频功能和网络视频功能无法使用
+#              1、支持打开本地摄像头；
+#              2、支持打开网络视频流，如rtsp、rtmp、http等；
+#              3、支持打开本地视频文件；
+#              4、支持显示图像自适应大小；
+#              5、支持将读取到的视频保存到本地；
 # @编译器：     MSVC2017-64（也支持其它编译器）
 # @Qt IDE：    D:/Qt/Qt5.12.5/Tools/QtCreator/share/qtcreator
 #
@@ -42,7 +47,7 @@ INCLUDEPATH += E:/lib/opencv_MSVC2/build/include
 DEPENDPATH += E:/lib/opencv_MSVC2/build/include
 
 #  定义程序版本号
-VERSION = 1.0.0
+VERSION = 1.1.0
 DEFINES += APP_VERSION=\\\"$$VERSION\\\"
 
 contains(QT_ARCH, i386){        # 使用32位编译器

OpenCVDemo/VideoPlay/videodisplay.cpp

@@ -111,16 +111,34 @@ void VideoDisplay::quitThread()
  */
 void VideoDisplay::readImage()
 {
+    //获取当前摄像头的视频长宽信息
+    Size s = Size(int(m_cap->get(CAP_PROP_FRAME_WIDTH)), int(m_cap->get(CAP_PROP_FRAME_HEIGHT)));
+    VideoWriter   writer;
+    double fps = m_cap->get(CAP_PROP_FPS);   // 获取帧率，有时候获取不到帧率，如摄像头，就使用默认帧率25
+    if(fps < 1)
+    {
+        fps = 25;
+    }
+    writer.open("./1.avi", VideoWriter::fourcc('M','J','P','G'), fps, s, true);   // 打开保存视频文件，帧率25
+
     while (m_play && m_cap->isOpened())
     {
         bool ret = m_cap->read(mat);
         if(ret)
         {
+            if(writer.isOpened())
+            {
+                writer.write(mat);   // 保存视频
+            }
             emit this->updateImage(MatToQImage(mat));   // 将mat转换为Qimage并发送给显示界面
         }
+        else
+        {
+            QThread::msleep(1);           // 防止频繁读取或者读取不到
+        }
 
-        QThread::msleep(1);           // 防止频繁读取或者读取不到
     }
+    writer.release();
     m_play = true;
 }