Qt-FFmpeg開發-影片播放【軟解碼 + OpenGL顯示RGB影像】(3)

mahuifa發表於2023-03-02

Qt-FFmpeg開發-影片播放【軟解碼 + OpenGL顯示RGB影像】

更多精彩內容
?個人內容分類彙總 ?
?音影片開發 ?

1、概述

  • 最近研究了一下FFmpeg開發,功能實在是太強大了,網上ffmpeg3、4的文章還是很多的,但是學習嘛,最新的還是不能放過,就選了一個最新的ffmpeg n5.1.2版本,和3、4版本api變化還是挺大的;
  • 在這個Demo裡主要使用Qt + FFmpeg開發一個簡單的影片播放器,這裡使用的是硬解碼,軟解碼在之前的文章中有;
  • 同時為了儘可能的簡單,這裡沒有進行音訊解碼和播放,只是單獨的進行影片解碼播放;
  • 在之前的文章中使用了QPainter進行繪製顯示,這裡為了降低CPU佔用率,改為使用了OpenGL進行顯示,但是這裡是將FFmpeg解碼後的YUV420P影像轉換位RGB影像後再使用OpenGL顯示,只修改了顯示部分程式碼,解碼部分和之前一樣。

開發環境說明

  • 系統:Windows10、Ubuntu20.04
  • Qt版本:V5.12.5
  • 編譯器:MSVC2017-64、GCC/G++64
  • FFmpeg版本:n5.1.2

2、實現效果

  1. 使用ffmpeg音影片庫【軟解碼】實現的影片播放器;
  2. 支援開啟本地影片檔案(如mp4、mov、avi等)、網路影片流(rtsp、rtmp、http等);
  3. 支援影片勻速播放;
  4. 採用【OpenGL顯示RGB】影像,支援自適應視窗縮放,支援使用QOpenGLWidget、QOpenGLWindow顯示;
  5. 影片播放支援實時開始/關閉、暫停/繼續播放;
  6. 影片解碼、執行緒控制、顯示各部分功能分離,低耦合度。
  7. 採用最新的5.1.2版本ffmpeg庫進行開發,超詳細註釋資訊,將所有踩過的坑、解決辦法、注意事項都得很寫清楚。

  • 下圖中使用OpenGL顯示RGB影像CPU佔用率是使用QPainter顯示的一半,由於我使用的是非常老的筆記本的集顯測試,所以GPU佔用率比較高。

3、FFmpeg軟解碼流程

4、主要程式碼

  • 啥也不說了,直接上程式碼,一切有註釋

4.1 解碼程式碼

  • 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;
    class QImage;
    
    class VideoDecode
    {
    public:
        VideoDecode();
        ~VideoDecode();
    
        bool open(const QString& url = QString());    // 開啟媒體檔案,或者流媒體rtmp、strp、http
        QImage 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:
        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"
    
    }
    
    #define ERROR_LEN 1024  // 異常資訊陣列長度
    #define PRINT_LOG 1
    
    VideoDecode::VideoDecode()
    {
    //    initFFmpeg();      // 5.1.2版本不需要呼叫了
    
        m_error = new char[ERROR_LEN];
    }
    
    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();
            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;
        av_dict_set(&dict, "rtsp_transport", "tcp", 0);      // 設定rtsp流使用tcp開啟,如果開啟失敗錯誤資訊為【Error number -135 occurred】可以切換(UDP、tcp、udp_multicast、http),比如vlc推流就需要使用udp開啟
        av_dict_set(&dict, "max_delay", "3", 0);             // 設定最大複用或解複用延遲(以微秒為單位)。當透過【UDP】 接收資料時,解複用器嘗試重新排序接收到的資料包(因為它們可能無序到達,或者資料包可能完全丟失)。這可以透過將最大解複用延遲設定為零(透過max_delayAVFormatContext 欄位)來禁用。
        av_dict_set(&dict, "timeout", "1000000", 0);         // 以微秒為單位設定套接字 TCP I/O 超時,如果等待時間過短,也可能會還沒連線就返回了。
    
        // 開啟輸入流並返回解封裝上下文
        int ret = avformat_open_input(&m_formatContext,          // 返回解封裝上下文
                                      url.toStdString().data(),  // 開啟影片地址
                                      nullptr,                   // 如果非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
     */
    QImage VideoDecode::read()
    {
        // 如果沒有開啟則返回
        if(!m_formatContext)
        {
            return QImage();
        }
    
        // 讀取下一幀資料
        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時釋放空間
    
        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 QImage();
        }
    
        m_pts = m_frame->pts;
    
        // 為什麼影像轉換上下文要放在這裡初始化呢,是因為m_frame->format,如果使用硬體解碼,解碼出來的影像格式和m_codecContext->pix_fmt的影像格式不一樣,就會導致無法轉換為QImage
        if(!m_swsContext)
        {
            // 獲取快取的影像轉換上下文。首先校驗引數是否一致,如果校驗不透過就釋放資源;然後判斷上下文是否存在,如果存在直接複用,如不存在進行分配、初始化操作
            m_swsContext = sws_getCachedContext(m_swsContext,
                                                m_frame->width,                     // 輸入影像的寬度
                                                m_frame->height,                    // 輸入影像的高度
                                                (AVPixelFormat)m_frame->format,     // 輸入影像的畫素格式
                                                m_size.width(),                     // 輸出影像的寬度
                                                m_size.height(),                    // 輸出影像的高度
                                                AV_PIX_FMT_RGBA,                    // 輸出影像的畫素格式
                                                SWS_BILINEAR,                       // 選擇縮放演算法(只有當輸入輸出影像大小不同時有效),一般選擇SWS_FAST_BILINEAR
                                                nullptr,                            // 輸入影像的濾波器資訊, 若不需要傳NULL
                                                nullptr,                            // 輸出影像的濾波器資訊, 若不需要傳NULL
                                                nullptr);                          // 特定縮放演算法需要的引數(?),預設為NULL
            if(!m_swsContext)
            {
    #if PRINT_LOG
                qWarning() << "sws_getCachedContext() Error!";
    #endif
                free();
                return QImage();
            }
        }
    
        // AVFrame轉QImage
        uchar* data[]  = {m_buffer};
        int    lines[4];
        av_image_fill_linesizes(lines, AV_PIX_FMT_RGBA, m_frame->width);  // 使用畫素格式pix_fmt和寬度填充影像的平面線條大小。
        ret = sws_scale(m_swsContext,             // 縮放上下文
                        m_frame->data,            // 原影像陣列
                        m_frame->linesize,        // 包含源影像每個平面步幅的陣列
                        0,                        // 開始位置
                        m_frame->height,          // 行數
                        data,                     // 目標影像陣列
                        lines);                   // 包含目標影像每個平面的步幅的陣列
        QImage image(m_buffer, m_frame->width, m_frame->height, QImage::Format_RGBA8888);
        av_frame_unref(m_frame);
    
        return image;
    }
    
    /**
     * @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;
        }
    }
    

4.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, 1.0);
        TexCord = aTexCord;
    }
    
  • 片段著色器fragment.fsh

    #version 330 core
    out vec4 FragColor;
    in  vec2 TexCord;            // 紋理座標
    uniform sampler2D texture;  // 紋理取樣器
    void main()
    {
        FragColor = texture2D(texture, TexCord);  // 取樣紋理函式
    }
    
  • OpenGL顯示RGB影像這裡可以採用QOpenGLWidget或者QOpenGLWIndow進行顯示

  • playimage.h

    /******************************************************************************
     * @檔名     playimage.h
     * @功能       使用OpenGL實現RGB影像的繪製,可透過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>
    
    #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 updateImage(const QImage& image);
    
    
    protected:
        void initializeGL() override;               // 初始化gl
        void resizeGL(int w, int h) override;       // 視窗尺寸變化
        void paintGL() override;                    // 重新整理顯示
    
    private:
        QOpenGLShaderProgram* m_program = nullptr;
        QOpenGLTexture* m_texture = nullptr;
    
        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"
    
    
    #if USE_WINDOW
    PlayImage::PlayImage(QOpenGLWindow::UpdateBehavior updateBehavior, QWindow *parent):QOpenGLWindow(updateBehavior, parent)
    {
    }
    #else
    PlayImage::PlayImage(QWidget *parent, Qt::WindowFlags f): QOpenGLWidget(parent, f)
    {
    
    }
    #endif
    
    
    PlayImage::~PlayImage()
    {
        if(!isValid()) return;        // 如果控制元件和OpenGL資源(如上下文)已成功初始化,則返回true。
        this->makeCurrent(); // 透過將相應的上下文設定為當前上下文並在該上下文中繫結幀緩衝區物件,為呈現此小部件的OpenGL內容做準備。
        // 釋放紋理
        if(m_texture)
        {
            m_texture->destroy();
            delete m_texture;
        }
        this->doneCurrent();    // 釋放上下文
        // 釋放
        glDeleteBuffers(1, &VBO);
        glDeleteBuffers(1, &EBO);
        glDeleteVertexArrays(1, &VAO);
    }
    
    /**
     * @brief        傳入Qimage圖片顯示
     * @param image
     */
    void PlayImage::updateImage(const QImage& image)
    {
        if(image.isNull()) return;
    
        m_size = image.size();
        if(!m_texture)
        {
            m_texture = new QOpenGLTexture(image.mirrored());
            resizeGL(this->width(), this->height());
        }
        else
        {
            m_texture->destroy();
            m_texture->setData(image.mirrored());
        }
        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();
    
        m_program = new QOpenGLShaderProgram(this);
        m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex.vsh");
        m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment.fsh");
        m_program->link();
    
        // 返回屬性名稱在此著色器程式的引數列表中的位置。如果名稱不是此著色器程式的有效屬性,則返回-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_texture)
        {
            m_texture->bind();
        }
    
        glBindVertexArray(VAO);           // 繫結VAO
    
        glDrawElements(GL_TRIANGLES,      // 繪製的圖元型別
                       6,                 // 指定要渲染的元素數(點數)
                       GL_UNSIGNED_INT,   // 指定索引中值的型別(indices)
                       nullptr);          // 指定當前繫結到GL_ELEMENT_array_buffer目標的緩衝區的資料儲存中陣列中第一個索引的偏移量。
        glBindVertexArray(0);
        if(m_texture)
        {
            m_texture->release();
        }
        m_program->release();
    }
    
    

5、完整原始碼

相關文章