音視頻/FFmpeg #Qt

Qt-FFmpeg開發-打開本地攝像頭【軟解碼+ OpenGL顯示YUV】

音視頻/FFmpeg #Qt
Qt-FFmpeg開發-打開本地攝像頭【軟解碼+ OpenGL顯示YUV】
- 1、概述
- 2、實作效果
- 3、FFmpeg打開本地攝像頭解碼流程
- 4、查詢可用攝像頭
- 5、設定攝像頭打開引數
- 6、主要代碼
  - 6.1 解碼代碼
  - 5.2 OpenGL顯示RGB影像代碼
- 7、完整源代碼

更多精彩內容
??個人內容分類匯總 ??
??音視頻開發 ??

1、概述

最近研究了一下FFmpeg開發，功能實在是太強大了，網上ffmpeg3、4的文章還是很多的，但是學習嘛，最新的還是不能放過，就選了一個最新的ffmpeg n5.1.2版本，和3、4版本api變化還是挺大的；

在這個Demo里主要使用Qt + FFmpeg開發一個攝像頭播放器，這里主要使用的是【軟解碼】，需要使用硬解碼的可以看之前的文章；

在之前的文章中使用了QPainter進行繪制顯示，也講了使用OpenGL顯示RGB、YUV影像方式；

由于FFmpeg解碼得到的像素格式為YUVJ422P，將YUVJ422P轉換為RGB或者YUV都很麻煩，并且會消耗CPU資源，所以這里直接使用OpenGL顯示YUVJ422P影像，（將YUVJ422P轉RGB的步驟放到了GPU中進行），

開發環境說明

系統：Windows10、Ubuntu20.04
Qt版本：V5.12.5
編譯器：MSVC2017-64、GCC/G++64
FFmpeg版本：n5.1.2
- 官方下載
- 我使用的庫

2、實作效果

使用ffmpeg音視頻庫【軟解碼】打開本地攝像頭；

采用【OpenGL顯示YUV】影像，支持自適應視窗縮放，支持使用QOpenGLWidget、QOpenGLWindow顯示；

將YUV轉RGB的步驟由CPU轉換改為使用GPU轉換，降低CPU占用率；

支持Windows、Linux打開本地攝像頭；

視頻解碼、執行緒控制、顯示各部分功能分離，低耦合度，

采用最新的5.1.2版本ffmpeg庫進行開發，超詳細注釋資訊，將所有踩過的坑、解決辦法、注意事項都得很寫清楚，

使用CPU軟解碼 + OpenGL繪制

3、FFmpeg打開本地攝像頭解碼流程

FFmpeg打開本地攝像頭與打開網路攝像頭、視頻檔案的區別就是藍色部分，

4、查詢可用攝像頭

打開攝像頭之前可通過Qt自帶的QCameraInfo類獲取系統中可用的攝像頭串列；

windows下打開攝像頭需要在攝像頭名稱前加上video=，linux下不用，

    // 獲取可用攝像頭串列
    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
    }

5、設定攝像頭打開引數

打開攝像頭和讀取網路影像不同，可以選擇攝像頭的解析度、解碼器、幀率、像素格式等資訊，設定這些資訊需要打開的【攝像頭支持】才可以打開，否則會打開失敗，

查看攝像頭硬體支持的引數：

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命令查看攝像頭支持的支持的像素格式、編解碼器和幀大小

    AVDictionary* dict = nullptr;
    // 設定解碼器（Linux下打開本地攝像頭默認為rawvideo解碼器，輸入影像為YUYV420，不方便顯示，有兩種解決辦法，1：使用sws_scale把YUYV422轉為YUVJ422P；2：指定mjpeg解碼器輸出YUVJ422P影像）
    av_dict_set(&dict, "input_format", "mjpeg", 0);
//    av_dict_set(&dict, "framerate", "30", 0);             // 設定幀率
//    av_dict_set(&dict, "pixel_format", "yuvj422p", 0);   // 設定像素格式
    av_dict_set(&dict, "video_size", "800x600", 0);       // 設定視頻解析度（如果該解析度攝像頭不支持則會報錯）

6、主要代碼

啥也不說了，直接上代碼，一切有注釋

6.1 解碼代碼

videodecode.h檔案

/******************************************************************************
 * @檔案名     videodecode.h
 * @功能       視頻解碼類，在這個類中呼叫ffmpeg打開攝像頭進行解碼
 *
 * @開發者     mhf
 * @郵箱       [email protected]
 * @時間       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;
class QImage;

class VideoDecode
{
public:
    VideoDecode();
    ~VideoDecode();

    bool open(const QString& url = QString());    // 打開媒體檔案，或者流媒體rtmp、strp、http
    AVFrame* read();                               // 讀取視頻影像
    void close();                                 // 關閉
    bool isEnd();                                 // 是否讀取完成
    const qint64& pts();                          // 獲取當前幀顯示時間

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;                    // 視頻當前獲取到的幀數
    qint64 m_pts          = 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

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();      // 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", 0);
//    av_dict_set(&dict, "framerate", "30", 0);             // 設定幀率
//    av_dict_set(&dict, "pixel_format", "yuvj422p", 0);   // 設定像素格式
    av_dict_set(&dict, "video_size", "800x600", 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* 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);  // 視頻幀率

    // 通過解碼器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;
    }

    // 分配影像空間
    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;
    }

    m_pts = m_frame->pts;

    return m_frame;
}

/**
 * @brief 關閉視頻播放并釋放記憶體
 */
void VideoDecode::close()
{
    clear();
    free();

    m_totalTime     = 0;
    m_videoIndex    = 0;
    m_totalFrames   = 0;
    m_obtainFrames  = 0;
    m_pts           = 0;
    m_frameRate     = 0;
    m_size          = QSize(0, 0);
}

/**
 * @brief  視頻是否讀取完成
 * @return
 */
bool VideoDecode::isEnd()
{
    return m_end;
}

/**
 * @brief    回傳當前幀影像播放時間
 * @return
 */
const qint64 &VideoDecode::pts()
{
    return m_pts;
}

/**
 * @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;
    }
}

5.2 OpenGL顯示RGB影像代碼

滑鼠右鍵->Add New...

創建兩個GLSL著色器檔案
創建一個資源檔案，將剛創建的兩個GLSL檔案添加進資源檔案
結果如下圖所示

頂點著色器 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;
}

片段著色器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);
}

OpenGL顯示YUVJ422P影像這里可以采用QOpenGLWidget或者QOpenGLWIndow進行顯示，直接將解碼后的AVFrame傳入，

playimage.h

/******************************************************************************
 * @檔案名     playimage.h
 * @功能       使用OpenGL實作YUV影像的繪制，可通過USE_WINDOW宏切換使用QOpenGLWindow還是QOpenGLWidget
 *
 * @開發者     mhf
 * @郵箱       [email protected]
 * @時間       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

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) 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();
}

7、完整源代碼

github
gitee

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/549528.html

標籤：其他

上一篇：開啟 HTTP/3 & QUIC 在 Docker Compose+Nginx

下一篇：Qt-FFmpeg開發-回呼函式讀取資料（8）

Qt-FFmpeg開發-打開本地攝像頭（6）