音视频/FFmpeg #Qt

Qt-FFmpeg开发-视频播放【软解码 + OpenGL显示YUV420P图像】

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

1、概述

  • 最近研究了一下FFmpeg开发，功能实在是太强大了，网上ffmpeg3、4的文章还是很多的，但是学习嘛，最新的还是不能放过，就选了一个最新的ffmpeg n5.1.2版本，和3、4版本api变化还是挺大的；
  • 在这个Demo里主要使用Qt + FFmpeg开发一个简单的视频播放器，这里使用的是硬解码，软解码在之前的文章中有；
  • 同时为了尽可能的简单，这里没有进行音频解码和播放，只是单独的进行视频解码播放；
  • 在之前的文章中使用了QPainter进行绘制显示，上一篇文章中使用了OpenGL显示RGB图像，但是由于FFmpeg软解码得到的是YUV图像，将YUV图像转换位RGB图像的步骤是在CPU中进行，所以也会消耗一定CPU资源；
  • 这篇文章中将直接使用OpenGL显示YUV图像，去掉使用sws_scale()将YUV转换为RGB的步骤（实际上是将YUV转RGB的步骤放到了GPU中进行）；
  • 由于去掉了YUV转RGB部分功能，所以这篇文章中的解码代码和之前文章中的有一点小的区别。

开发环境说明

  • 系统：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显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示；
  5. 将YUV转RGB的步骤由CPU转换改为使用GPU转换，降低CPU占用率；
  6. 视频播放支持实时开始/关闭、暂停/继续播放；
  7. 视频解码、线程控制、显示各部分功能分离，低耦合度。
  8. 采用最新的5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚。

  • 下图中使用OpenGL显示YUV图像CPU占用率是使用QPainter显示的1/3左右，由于我使用的是非常老的笔记本的集显测试，所以GPU占用率比较高。

3、FFmpeg软解码流程

4、主要代码

  • 啥也不说了，直接上代码，一切有注释

4.1 解码代码

  • videodecode.h文件

    1. /******************************************************************************
    2.  * @文件名     videodecode.h
    3.  * @功能       视频解码类，在这个类中调用ffmpeg打开视频进行解码
    4.  *
    5.  * @开发者     mhf
    6.  * @邮箱       1603291350@qq.com
    7.  * @时间       2022/09/15
    8.  * @备注
    9.  *****************************************************************************/
    10. #ifndef VIDEODECODE_H
    11. #define VIDEODECODE_H
    13. #include <QString>
    14. #include <QSize>
    16. struct AVFormatContext;
    17. struct AVCodecContext;
    18. struct AVRational;
    19. struct AVPacket;
    20. struct AVFrame;
    21. struct SwsContext;
    22. struct AVBufferRef;
    23. class QImage;
    25. class VideoDecode
    26. {
    27. public:
    28.     VideoDecode();
    29.     ~VideoDecode();
    31.     bool open(const QString& url = QString());    // 打开媒体文件，或者流媒体rtmp、strp、http
    32.     AVFrame* read();                              // 读取视频图像
    33.     void close();                                 // 关闭
    34.     bool isEnd();                                 // 是否读取完成
    35.     const qint64& pts();                          // 获取当前帧显示时间
    37. private:
    38.     void initFFmpeg();                            // 初始化ffmpeg库（整个程序中只需加载一次）
    39.     void showError(int err);                      // 显示ffmpeg执行错误时的错误信息
    40.     qreal rationalToDouble(AVRational* rational); // 将AVRational转换为double
    41.     void clear();                                 // 清空读取缓冲
    42.     void free();                                  // 释放
    44. private:
    45.     AVFormatContext* m_formatContext = nullptr;   // 解封装上下文
    46.     AVCodecContext*  m_codecContext  = nullptr;   // 解码器上下文
    47.     SwsContext*      m_swsContext    = nullptr;   // 图像转换上下文
    48.     AVPacket* m_packet = nullptr;                 // 数据包
    49.     AVFrame*  m_frame  = nullptr;                 // 解码后的视频帧
    50.     int    m_videoIndex   = 0;                    // 视频流索引
    51.     qint64 m_totalTime    = 0;                    // 视频总时长
    52.     qint64 m_totalFrames  = 0;                    // 视频总帧数
    53.     qint64 m_obtainFrames = 0;                    // 视频当前获取到的帧数
    54.     qint64 m_pts          = 0;                    // 图像帧的显示时间
    55.     qreal  m_frameRate    = 0;                    // 视频帧率
    56.     QSize  m_size;                                // 视频分辨率大小
    57.     char*  m_error = nullptr;                     // 保存异常信息
    58.     bool   m_end = false;                         // 视频读取完成
    59.     uchar* m_buffer = nullptr;                    // YUV图像需要转换位RGBA图像，这里保存转换后的图形数据
    60. };
    62. #endif // VIDEODECODE_H

  • videodecode.cpp文件

    1. #include "videodecode.h"
    2. #include <QDebug>
    3. #include <QImage>
    4. #include <QMutex>
    5. #include <qdatetime.h>
    7. extern "C" {        // 用C规则编译指定的代码
    8. #include "libavcodec/avcodec.h"
    9. #include "libavformat/avformat.h"
    10. #include "libavutil/avutil.h"
    11. #include "libswscale/swscale.h"
    12. #include "libavutil/imgutils.h"
    13. }
    15. #define ERROR_LEN 1024  // 异常信息数组长度
    16. #define PRINT_LOG 1
    18. VideoDecode::VideoDecode()
    19. {
    20. //    initFFmpeg();      // 5.1.2版本不需要调用了
    22.     m_error = new char[ERROR_LEN];
    23. }
    25. VideoDecode::~VideoDecode()
    26. {
    27.     close();
    28. }
    30. /**
    31.  * @brief 初始化ffmpeg库（整个程序中只需加载一次）
    32.  *        旧版本的ffmpeg需要注册各种文件格式、解复用器、对网络库进行全局初始化。
    33.  *        在新版本的ffmpeg中纷纷弃用了，不需要注册了
    34.  */
    35. void VideoDecode::initFFmpeg()
    36. {
    37.     static bool isFirst = true;
    38.     static QMutex mutex;
    39.     QMutexLocker locker(&mutex);
    40.     if(isFirst)
    41.     {
    42.         //        av_register_all();         // 已经从源码中删除
    43.         /**
    44.          * 初始化网络库,用于打开网络流媒体，此函数仅用于解决旧GnuTLS或OpenSSL库的线程安全问题。
    45.          * 一旦删除对旧GnuTLS和OpenSSL库的支持，此函数将被弃用，并且此函数不再有任何用途。
    46.          */
    47.         avformat_network_init();
    48.         isFirst = false;
    49.     }
    50. }
    52. /**
    53.  * @brief      打开媒体文件，或者流媒体，例如rtmp、strp、http
    54.  * @param url  视频地址
    55.  * @return     true：成功  false：失败
    56.  */
    57. bool VideoDecode::open(const QString &url)
    58. {
    59.     if(url.isNull()) return false;
    61.     AVDictionary* dict = nullptr;
    62.     av_dict_set(&dict, "rtsp_transport", "tcp", 0);      // 设置rtsp流使用tcp打开，如果打开失败错误信息为【Error number -135 occurred】可以切换（UDP、tcp、udp_multicast、http），比如vlc推流就需要使用udp打开
    63.     av_dict_set(&dict, "max_delay", "3", 0);             // 设置最大复用或解复用延迟（以微秒为单位）。当通过【UDP】 接收数据时，解复用器尝试重新排序接收到的数据包（因为它们可能无序到达，或者数据包可能完全丢失）。这可以通过将最大解复用延迟设置为零（通过max_delayAVFormatContext 字段）来禁用。
    64.     av_dict_set(&dict, "timeout", "1000000", 0);         // 以微秒为单位设置套接字 TCP I/O 超时，如果等待时间过短，也可能会还没连接就返回了。
    66.     // 打开输入流并返回解封装上下文
    67.     int ret = avformat_open_input(&m_formatContext,          // 返回解封装上下文
    68.                                   url.toStdString().data(),  // 打开视频地址
    69.                                   nullptr,                   // 如果非null，此参数强制使用特定的输入格式。自动选择解封装器（文件格式）
    70.                                   &dict);                    // 参数设置
    71.     // 释放参数字典
    72.     if(dict)
    73.     {
    74.         av_dict_free(&dict);
    75.     }
    76.     // 打开视频失败
    77.     if(ret < 0)
    78.     {
    79.         showError(ret);
    80.         free();
    81.         return false;
    82.     }
    84.     // 读取媒体文件的数据包以获取流信息。
    85.     ret = avformat_find_stream_info(m_formatContext, nullptr);
    86.     if(ret < 0)
    87.     {
    88.         showError(ret);
    89.         free();
    90.         return false;
    91.     }
    92.     m_totalTime = m_formatContext->duration / (AV_TIME_BASE / 1000); // 计算视频总时长（毫秒）
    93. #if PRINT_LOG
    94.     qDebug() << QString("视频总时长：%1 ms，[%2]").arg(m_totalTime).arg(QTime::fromMSecsSinceStartOfDay(int(m_totalTime)).toString("HH:mm:ss zzz"));
    95. #endif
    97.     // 通过AVMediaType枚举查询视频流ID（也可以通过遍历查找），最后一个参数无用
    98.     m_videoIndex = av_find_best_stream(m_formatContext, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
    99.     if(m_videoIndex < 0)
    100.     {
    101.         showError(m_videoIndex);
    102.         free();
    103.         return false;
    104.     }
    106.     AVStream* videoStream = m_formatContext->streams[m_videoIndex];  // 通过查询到的索引获取视频流
    108.     // 获取视频图像分辨率（AVStream中的AVCodecContext在新版本中弃用，改为使用AVCodecParameters）
    109.     m_size.setWidth(videoStream->codecpar->width);
    110.     m_size.setHeight(videoStream->codecpar->height);
    111.     m_frameRate = rationalToDouble(&videoStream->avg_frame_rate);  // 视频帧率
    113.     // 通过解码器ID获取视频解码器（新版本返回值必须使用const）
    114.     const AVCodec* codec = avcodec_find_decoder(videoStream->codecpar->codec_id);
    115.     m_totalFrames = videoStream->nb_frames;
    117. #if PRINT_LOG
    118.     qDebug() << QString("分辨率：[w:%1,h:%2] 帧率：%3  总帧数：%4  解码器：%5")
    119.                 .arg(m_size.width()).arg(m_size.height()).arg(m_frameRate).arg(m_totalFrames).arg(codec->name);
    120. #endif
    122.     // 分配AVCodecContext并将其字段设置为默认值。
    123.     m_codecContext = avcodec_alloc_context3(codec);
    124.     if(!m_codecContext)
    125.     {
    126. #if PRINT_LOG
    127.         qWarning() << "创建视频解码器上下文失败！";
    128. #endif
    129.         free();
    130.         return false;
    131.     }
    133.     // 使用视频流的codecpar为解码器上下文赋值
    134.     ret = avcodec_parameters_to_context(m_codecContext, videoStream->codecpar);
    135.     if(ret < 0)
    136.     {
    137.         showError(ret);
    138.         free();
    139.         return false;
    140.     }
    142.     m_codecContext->flags2 |= AV_CODEC_FLAG2_FAST;    // 允许不符合规范的加速技巧。
    143.     m_codecContext->thread_count = 8;                 // 使用8线程解码
    145.     // 初始化解码器上下文，如果之前avcodec_alloc_context3传入了解码器，这里设置NULL就可以
    146.     ret = avcodec_open2(m_codecContext, nullptr, nullptr);
    147.     if(ret < 0)
    148.     {
    149.         showError(ret);
    150.         free();
    151.         return false;
    152.     }
    154.     // 分配AVPacket并将其字段设置为默认值。
    155.     m_packet = av_packet_alloc();
    156.     if(!m_packet)
    157.     {
    158. #if PRINT_LOG
    159.         qWarning() << "av_packet_alloc() Error！";
    160. #endif
    161.         free();
    162.         return false;
    163.     }
    164.     // 分配AVFrame并将其字段设置为默认值。
    165.     m_frame = av_frame_alloc();
    166.     if(!m_frame)
    167.     {
    168. #if PRINT_LOG
    169.         qWarning() << "av_frame_alloc() Error！";
    170. #endif
    171.         free();
    172.         return false;
    173.     }
    175.     // 分配图像空间
    176.     int size = av_image_get_buffer_size(AV_PIX_FMT_RGBA, m_size.width(), m_size.height(), 4);
    177.     /**
    178.      * 【注意：】这里可以多分配一些，否则如果只是安装size分配，大部分视频图像数据拷贝没有问题，
    179.      *         但是少部分视频图像在使用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）
    180.      *         特别是这个视频流http://vfx.mtime.cn/Video/2019/02/04/mp4/190204084208765161.mp4
    181.      */
    182.     m_buffer = new uchar[size + 1000];    // 这里多分配1000个字节就基本不会出现拷贝超出的情况了，反正不缺这点内存
    183. //    m_image = new QImage(m_buffer, m_size.width(), m_size.height(), QImage::Format_RGBA8888);  // 这种方式分配内存大部分情况下也可以，但是因为存在拷贝超出数组的情况，delete时也会报错
    184.     m_end = false;
    185.     return true;
    186. }
    188. /**
    189.  * @brief    读取图像数据
    190.  * @return
    191.  */
    192. AVFrame* VideoDecode::read()
    193. {
    194.     // 如果没有打开则返回
    195.     if(!m_formatContext)
    196.     {
    197.         return nullptr;
    198.     }
    200.     // 读取下一帧数据
    201.     int readRet = av_read_frame(m_formatContext, m_packet);
    202.     if(readRet < 0)
    203.     {
    204.         avcodec_send_packet(m_codecContext, m_packet); // 读取完成后向解码器中传如空AVPacket，否则无法读取出最后几帧
    205.     }
    206.     else
    207.     {
    208.         if(m_packet->stream_index == m_videoIndex)     // 如果是图像数据则进行解码
    209.         {
    210.             // 计算当前帧时间（毫秒）
    211. #if 1       // 方法一：适用于所有场景，但是存在一定误差
    212.             m_packet->pts = qRound64(m_packet->pts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
    213.             m_packet->dts = qRound64(m_packet->dts * (1000 * rationalToDouble(&m_formatContext->streams[m_videoIndex]->time_base)));
    214. #else       // 方法二：适用于播放本地视频文件，计算每一帧时间较准，但是由于网络视频流无法获取总帧数，所以无法适用
    215.             m_obtainFrames++;
    216.             m_packet->pts = qRound64(m_obtainFrames * (qreal(m_totalTime) / m_totalFrames));
    217. #endif
    218.             // 将读取到的原始数据包传入解码器
    219.             int ret = avcodec_send_packet(m_codecContext, m_packet);
    220.             if(ret < 0)
    221.             {
    222.                 showError(ret);
    223.             }
    224.         }
    225.     }
    226.     av_packet_unref(m_packet);  // 释放数据包，引用计数-1，为0时释放空间
    228.     av_frame_unref(m_frame);
    229.     int ret = avcodec_receive_frame(m_codecContext, m_frame);
    230.     if(ret < 0)
    231.     {
    232.         av_frame_unref(m_frame);
    233.         if(readRet < 0)
    234.         {
    235.             m_end = true;     // 当无法读取到AVPacket并且解码器中也没有数据时表示读取完成
    236.         }
    237.         return nullptr;
    238.     }
    240.     m_pts = m_frame->pts;
    242.     return m_frame;
    243. }
    245. /**
    246.  * @brief 关闭视频播放并释放内存
    247.  */
    248. void VideoDecode::close()
    249. {
    250.     clear();
    251.     free();
    253.     m_totalTime     = 0;
    254.     m_videoIndex    = 0;
    255.     m_totalFrames   = 0;
    256.     m_obtainFrames  = 0;
    257.     m_pts           = 0;
    258.     m_frameRate     = 0;
    259.     m_size          = QSize(0, 0);
    260. }
    262. /**
    263.  * @brief  视频是否读取完成
    264.  * @return
    265.  */
    266. bool VideoDecode::isEnd()
    267. {
    268.     return m_end;
    269. }
    271. /**
    272.  * @brief    返回当前帧图像播放时间
    273.  * @return
    274.  */
    275. const qint64 &VideoDecode::pts()
    276. {
    277.     return m_pts;
    278. }
    280. /**
    281.  * @brief        显示ffmpeg函数调用异常信息
    282.  * @param err
    283.  */
    284. void VideoDecode::showError(int err)
    285. {
    286. #if PRINT_LOG
    287.     memset(m_error, 0, ERROR_LEN);        // 将数组置零
    288.     av_strerror(err, m_error, ERROR_LEN);
    289.     qWarning() << "DecodeVideo Error：" << m_error;
    290. #else
    291.     Q_UNUSED(err)
    292. #endif
    293. }
    295. /**
    296.  * @brief          将AVRational转换为double，用于计算帧率
    297.  * @param rational
    298.  * @return
    299.  */
    300. qreal VideoDecode::rationalToDouble(AVRational* rational)
    301. {
    302.     qreal frameRate = (rational->den == 0) ? 0 : (qreal(rational->num) / rational->den);
    303.     return frameRate;
    304. }
    306. /**
    307.  * @brief 清空读取缓冲
    308.  */
    309. void VideoDecode::clear()
    310. {
    311.     // 因为avformat_flush不会刷新AVIOContext (s->pb)。如果有必要，在调用此函数之前调用avio_flush(s->pb)。
    312.     if(m_formatContext && m_formatContext->pb)
    313.     {
    314.         avio_flush(m_formatContext->pb);
    315.     }
    316.     if(m_formatContext)
    317.     {
    318.         avformat_flush(m_formatContext);   // 清理读取缓冲
    319.     }
    320. }
    322. void VideoDecode::free()
    323. {
    324.     // 释放上下文swsContext。
    325.     if(m_swsContext)
    326.     {
    327.         sws_freeContext(m_swsContext);
    328.         m_swsContext = nullptr;             // sws_freeContext不会把上下文置NULL
    329.     }
    330.     // 释放编解码器上下文和与之相关的所有内容，并将NULL写入提供的指针
    331.     if(m_codecContext)
    332.     {
    333.         avcodec_free_context(&m_codecContext);
    334.     }
    335.     // 关闭并失败m_formatContext，并将指针置为null
    336.     if(m_formatContext)
    337.     {
    338.         avformat_close_input(&m_formatContext);
    339.     }
    340.     if(m_packet)
    341.     {
    342.         av_packet_free(&m_packet);
    343.     }
    344.     if(m_frame)
    345.     {
    346.         av_frame_free(&m_frame);
    347.     }
    348.     if(m_buffer)
    349.     {
    350.         delete [] m_buffer;
    351.         m_buffer = nullptr;
    352.     }
    353. }

4.2 OpenGL显示RGB图像代码

  • 鼠标右键->Add New...

  • 创建两个GLSL着色器文件

  • 创建一个资源文件，将刚创建的两个GLSL文件添加进资源文件

  • 结果如下图所示

  • 顶点着色器 vertex.vsh

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

  • 片段着色器fragment.fsh，由于要显示YUV图像，就需要在GLSL中调用GPU将YUV图像转换为RGB图像，所以片段着色器会有不同

    1. #version 330 core
    2. in  vec2 TexCord;            // 纹理坐标
    3. uniform sampler2D tex_y;
    4. uniform sampler2D tex_u;
    5. uniform sampler2D tex_v;
    7. void main()
    8. {
    9.     vec3 yuv;
    10.     vec3 rgb;
    12.     // YUV转RGB
    13.     yuv.x = texture2D(tex_y, TexCord).r;
    14.     yuv.y = texture2D(tex_u, TexCord).r-0.5;
    15.     yuv.z = texture2D(tex_v, TexCord).r-0.5;
    17.     rgb = mat3(1.0, 1.0, 1.0,
    18.                0.0, -0.39465, 2.03211,
    19.                1.13983, -0.58060, 0.0) * yuv;
    20.     gl_FragColor = vec4(rgb, 1.0);
    21. }

  • OpenGL显示YUV图像这里可以采用QOpenGLWidget或者QOpenGLWIndow进行显示，直接将解码后的AVFrame传入

  • playimage.h

    1. /******************************************************************************
    2.  * @文件名     playimage.h
    3.  * @功能       使用OpenGL实现YUV图像的绘制，可通过USE_WINDOW宏切换使用QOpenGLWindow还是QOpenGLWidget
    4.  *
    5.  * @开发者     mhf
    6.  * @邮箱       1603291350@qq.com
    7.  * @时间       2022/10/14
    8.  * @备注
    9.  *****************************************************************************/
    10. #ifndef PLAYIMAGE_H
    11. #define PLAYIMAGE_H
    13. #include <QWidget>
    14. #include <QOpenGLFunctions_3_3_Core>
    15. #include <qopenglshaderprogram.h>
    16. #include <QOpenGLTexture>
    17. #include <qopenglpixeltransferoptions.h>
    19. struct AVFrame;
    21. #define USE_WINDOW 0    // 1:使用QOpenGLWindow显示, 0：使用QOpenGLWidget显示
    23. #if USE_WINDOW
    24. #include <QOpenGLWindow>
    25. class PlayImage : public QOpenGLWindow, public  QOpenGLFunctions_3_3_Core
    26. #else
    27. #include <QOpenGLWidget>
    28. class PlayImage : public QOpenGLWidget, public  QOpenGLFunctions_3_3_Core
    29. #endif
    30. {
    31.     Q_OBJECT
    32. public:
    33. #if USE_WINDOW
    34.     explicit PlayImage(UpdateBehavior updateBehavior = NoPartialUpdate, QWindow *parent = nullptr);
    35. #else
    36.     explicit PlayImage(QWidget* parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags());
    37. #endif
    38.      ~PlayImage() override;
    40.     void repaint(AVFrame* frame);             // 重绘
    42. protected:
    43.     void initializeGL() override;               // 初始化gl
    44.     void resizeGL(int w, int h) override;       // 窗口尺寸变化
    45.     void paintGL() override;                    // 刷新显示
    47. private:
    48.     QOpenGLShaderProgram* m_program = nullptr;
    49.     QOpenGLTexture* m_texY = nullptr;           // 存储YUV图像中的Y数据
    50.     QOpenGLTexture* m_texU = nullptr;           // 存储YUV图像中的U数据
    51.     QOpenGLTexture* m_texV = nullptr;           // 存储YUV图像中的V数据
    52.     QOpenGLPixelTransferOptions m_options;
    54.     GLuint VBO = 0;       // 顶点缓冲对象,负责将数据从内存放到缓存，一个VBO可以用于多个VAO
    55.     GLuint VAO = 0;       // 顶点数组对象,任何随后的顶点属性调用都会储存在这个VAO中，一个VAO可以有多个VBO
    56.     GLuint EBO = 0;       // 元素缓冲对象,它存储 OpenGL 用来决定要绘制哪些顶点的索引
    57.     QSize  m_size;
    58.     QSizeF  m_zoomSize;
    59.     QPointF m_pos;
    60. };
    62. #endif // PLAYIMAGE_H

  • playimage.cpp

    1. #include "playimage.h"
    3. extern "C" {        // 用C规则编译指定的代码
    4. #include "libavcodec/avcodec.h"
    5. }
    7. #if USE_WINDOW
    8. PlayImage::PlayImage(QOpenGLWindow::UpdateBehavior updateBehavior, QWindow *parent):QOpenGLWindow(updateBehavior, parent)
    9. {
    10.     // 初始化视图大小，由于Shader里面有YUV转RGB的代码，会初始化显示为绿色，这里通过将视图大小设置为0避免显示绿色背景
    11.     m_pos = QPointF(0, 0);
    12.     m_zoomSize = QSize(0, 0);
    13. }
    14. #else
    15. PlayImage::PlayImage(QWidget *parent, Qt::WindowFlags f): QOpenGLWidget(parent, f)
    16. {
    17.     // 初始化视图大小，由于Shader里面有YUV转RGB的代码，会初始化显示为绿色，这里通过将视图大小设置为0避免显示绿色背景
    18.     m_pos = QPointF(0, 0);
    19.     m_zoomSize = QSize(0, 0);
    20. }
    21. #endif
    23. PlayImage::~PlayImage()
    24. {
    25.     if(!isValid()) return;        // 如果控件和OpenGL资源（如上下文）已成功初始化，则返回true。
    26.     this->makeCurrent(); // 通过将相应的上下文设置为当前上下文并在该上下文中绑定帧缓冲区对象，为呈现此小部件的OpenGL内容做准备。
    27.     // 释放纹理
    28.     if(m_texY)
    29.     {
    30.         m_texY->destroy();
    31.         delete m_texY;
    32.     }
    33.     if(m_texU)
    34.     {
    35.         m_texU->destroy();
    36.         delete m_texU;
    37.     }
    38.     if(m_texV)
    39.     {
    40.         m_texV->destroy();
    41.         delete m_texV;
    42.     }
    43.     this->doneCurrent();    // 释放上下文
    44.     // 释放
    45.     glDeleteBuffers(1, &VBO);
    46.     glDeleteBuffers(1, &EBO);
    47.     glDeleteVertexArrays(1, &VAO);
    48. }
    50. void PlayImage::repaint(AVFrame *frame)
    51. {
    52.     if(!frame) return;
    54.     // 当切换显示的视频后，如果分辨率不同则需要重新创建纹理，否则会崩溃
    55.     if(frame->width != m_size.width() || frame->height != m_size.height())
    56.     {
    57.         if(m_texY && m_texU && m_texV)
    58.         {
    59.             m_texY->destroy();
    60.             m_texU->destroy();
    61.             m_texV->destroy();
    62.             delete m_texY;
    63.             delete m_texU;
    64.             delete m_texV;
    65.             m_texY = nullptr;
    66.             m_texU = nullptr;
    67.             m_texV = nullptr;
    68.         }
    69.     }
    70.     if(!m_texY) // 初始化纹理
    71.     {
    72.         // 创建2D纹理
    73.         m_texY = new QOpenGLTexture(QOpenGLTexture::Target2D);
    74.         m_texU = new QOpenGLTexture(QOpenGLTexture::Target2D);
    75.         m_texV = new QOpenGLTexture(QOpenGLTexture::Target2D);
    77.         // 设置纹理大小
    78.         m_texY->setSize(frame->width, frame->height);
    79.         m_texU->setSize(frame->width / 2, frame->height / 2);
    80.         m_texV->setSize(frame->width / 2, frame->height / 2);
    82.         // 设置放大、缩小过滤器
    83.         m_texY->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
    84.         m_texU->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
    85.         m_texV->setMinMagFilters(QOpenGLTexture::LinearMipMapLinear,QOpenGLTexture::Linear);
    87.         // 设置图像格式
    88.         m_texY->setFormat(QOpenGLTexture::R8_UNorm);
    89.         m_texU->setFormat(QOpenGLTexture::R8_UNorm);
    90.         m_texV->setFormat(QOpenGLTexture::R8_UNorm);
    92.         // 分配内存
    93.         m_texY->allocateStorage();
    94.         m_texU->allocateStorage();
    95.         m_texV->allocateStorage();
    97.         // 记录图像分辨率
    98.         m_size.setWidth(frame->width);
    99.         m_size.setHeight(frame->height);
    100.         resizeGL(this->width(), this->height());
    101.     }
    102.     m_options.setImageHeight(frame->height);
    103.     m_options.setRowLength(frame->linesize[0]);
    104.     m_texY->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[0]), &m_options);   // 设置图像数据 Y
    105.     m_options.setRowLength(frame->linesize[1]);
    106.     m_texU->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[1]), &m_options);   // 设置图像数据 U
    107.     m_options.setRowLength(frame->linesize[2]);
    108.     m_texV->setData(QOpenGLTexture::Red, QOpenGLTexture::UInt8, static_cast<const void *>(frame->data[2]), &m_options);   // 设置图像数据 V
    110.     av_frame_unref(frame);  //  取消引用帧引用的所有缓冲区并重置帧字段。
    112.     this->update();
    113. }
    115. // 三个顶点坐标XYZ，VAO、VBO数据播放，范围时[-1 ~ 1]直接
    116. static GLfloat vertices[] = {  // 前三列点坐标，后两列为纹理坐标
    117.      1.0f,  1.0f, 0.0f, 1.0f, 1.0f,      // 右上角
    118.      1.0f, -1.0f, 0.0f, 1.0f, 0.0f,      // 右下
    119.     -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,      // 左下
    120.     -1.0f,  1.0f, 0.0f, 0.0f, 1.0f      // 左上
    121. };
    122. static GLuint indices[] = {
    123.     0, 1, 3,
    124.     1, 2, 3
    125. };
    126. void PlayImage::initializeGL()
    127. {
    128.     initializeOpenGLFunctions();
    130.     // 加载shader脚本程序
    131.     m_program = new QOpenGLShaderProgram(this);
    132.     m_program->addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vertex.vsh");
    133.     m_program->addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fragment.fsh");
    134.     m_program->link();
    136.     // 绑定YUV 变量值
    137.     m_program->bind();
    138.     m_program->setUniformValue("tex_y", 0);
    139.     m_program->setUniformValue("tex_u", 1);
    140.     m_program->setUniformValue("tex_v", 2);
    142.     // 返回属性名称在此着色器程序的参数列表中的位置。如果名称不是此着色器程序的有效属性，则返回-1。
    143.     GLuint posAttr = GLuint(m_program->attributeLocation("aPos"));
    144.     GLuint texCord = GLuint(m_program->attributeLocation("aTexCord"));
    146.     glGenVertexArrays(1, &VAO);
    147.     glBindVertexArray(VAO);
    149.     glGenBuffers(1, &VBO);
    150.     glBindBuffer(GL_ARRAY_BUFFER, VBO);
    151.     glGenBuffers(1, &EBO);    // 创建一个EBO
    152.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    154.     // 为当前绑定到的缓冲区对象创建一个新的数据存储target。任何预先存在的数据存储都将被删除。
    155.     glBufferData(GL_ARRAY_BUFFER,        // 为VBO缓冲绑定顶点数据
    156.                        sizeof (vertices),      // 数组字节大小
    157.                        vertices,               // 需要绑定的数组
    158.                        GL_STATIC_DRAW);        // 指定数据存储的预期使用模式,GL_STATIC_DRAW： 数据几乎不会改变
    159.     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);  // 将顶点索引数组传入EBO缓存
    160.     // 设置顶点坐标数据
    161.     glVertexAttribPointer(posAttr,                     // 指定要修改的通用顶点属性的索引
    162.                           3,                     // 指定每个通用顶点属性的组件数（如vec3：3，vec4：4）
    163.                           GL_FLOAT,              // 指定数组中每个组件的数据类型(数组中一行有几个数)
    164.                           GL_FALSE,              // 指定在访问定点数据值时是否应规范化 ( GL_TRUE) 或直接转换为定点值 ( GL_FALSE)，如果vertices里面单个数超过-1或者1可以选择GL_TRUE
    165.                           5 * sizeof(GLfloat),   // 指定连续通用顶点属性之间的字节偏移量。
    166.                           nullptr);              // 指定当前绑定到目标的缓冲区的数据存储中数组中第一个通用顶点属性的第一个组件的偏移量。初始值为0 (一个数组从第几个字节开始读)
    167.     // 启用通用顶点属性数组
    168.     glEnableVertexAttribArray(posAttr);                // 属性索引是从调用glGetAttribLocation接收的，或者传递给glBindAttribLocation。
    170.     // 设置纹理坐标数据
    171.     glVertexAttribPointer(texCord, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), reinterpret_cast<const GLvoid *>(3 * sizeof (GLfloat)));              // 指定当前绑定到目标的缓冲区的数据存储中数组中第一个通用顶点属性的第一个组件的偏移量。初始值为0 (一个数组从第几个字节开始读)
    172.     // 启用通用顶点属性数组
    173.     glEnableVertexAttribArray(texCord);                // 属性索引是从调用glGetAttribLocation接收的，或者传递给glBindAttribLocation。
    175.     // 释放
    176.     glBindBuffer(GL_ARRAY_BUFFER, 0);
    177.     glBindVertexArray(0);                        // 设置为零以破坏现有的顶点数组对象绑定
    179.     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);        // 指定颜色缓冲区的清除值(背景色)
    181. }
    183. void PlayImage::resizeGL(int w, int h)
    184. {
    185.     if(m_size.width()  < 0 || m_size.height() < 0) return;
    187.     // 计算需要显示图片的窗口大小，用于实现长宽等比自适应显示
    188.     if((double(w) / h) < (double(m_size.width()) / m_size.height()))
    189.     {
    190.         m_zoomSize.setWidth(w);
    191.         m_zoomSize.setHeight(((double(w) / m_size.width()) * m_size.height()));   // 这里不使用QRect，使用QRect第一次设置时有误差bug
    192.     }
    193.     else
    194.     {
    195.         m_zoomSize.setHeight(h);
    196.         m_zoomSize.setWidth((double(h) / m_size.height()) * m_size.width());
    197.     }
    198.     m_pos.setX(double(w - m_zoomSize.width()) / 2);
    199.     m_pos.setY(double(h - m_zoomSize.height()) / 2);
    200.     this->update(QRect(0, 0, w, h));
    201. }
    203. void PlayImage::paintGL()
    204. {
    205.     glClear(GL_COLOR_BUFFER_BIT);     // 将窗口的位平面区域（背景）设置为先前由glClearColor、glClearDepth和选择的值
    206.     glViewport(m_pos.x(), m_pos.y(), m_zoomSize.width(), m_zoomSize.height());  // 设置视图大小实现图片自适应
    208.     m_program->bind();               // 绑定着色器
    209.     // 绑定纹理
    210.     if(m_texY && m_texU && m_texV)
    211.     {
    212.         m_texY->bind(0);
    213.         m_texU->bind(1);
    214.         m_texV->bind(2);
    215.     }
    217.     glBindVertexArray(VAO);           // 绑定VAO
    219.     glDrawElements(GL_TRIANGLES,      // 绘制的图元类型
    220.                    6,                 // 指定要渲染的元素数(点数)
    221.                    GL_UNSIGNED_INT,   // 指定索引中值的类型(indices)
    222.                    nullptr);          // 指定当前绑定到GL_ELEMENT_array_buffer目标的缓冲区的数据存储中数组中第一个索引的偏移量。
    223.     glBindVertexArray(0);
    224.     // 释放纹理
    225.     if(m_texY && m_texU && m_texV)
    226.     {
    227.         m_texY->release();
    228.         m_texU->release();
    229.         m_texV->release();
    230.     }
    231.     m_program->release();
    232. }

5、完整源代码

Qt-FFmpeg开发-视频播放（4）的更多相关文章

  1. QT+FFMPEG实现视频播放

    开发环境:MinGW+QT5.9+FFMPEG20190212 一.开发环境搭建 FFMPEG的开发环境部署比如容易,在官网下载库文件,然后在QT里面指定路径,把相关dll文件放到exe目录下就可以了 ...

  2. Qt+FFmpeg 简单实现视频播放

    这里使用 Qt + FFmpeg 实现了一个简单播放视频的例子.先看下按下按钮播放视频时的效果图: 完整工程下载链接:Github-FFmpeg_demo 注意:一定要将 bin 目录下的 dll 文 ...

  3. Qt-FFmpeg开发-视频播放【软解码】（1）

    Qt-FFmpeg开发-视频播放[软解码] 目录 Qt-FFmpeg开发-视频播放[软解码] 1.概述 2.实现效果 3.FFmpeg软解码流程 4.主要代码 6.完整源代码 更多精彩内容 个人内容分 ...

  4. Qt-FFmpeg开发-视频播放【软解码 + OpenGL显示RGB图像】（3）

    Qt-FFmpeg开发-视频播放[软解码 + OpenGL显示RGB图像] 目录 Qt-FFmpeg开发-视频播放[软解码 + OpenGL显示RGB图像] 1.概述 2.实现效果 3.FFmpeg软 ...

  5. 项目实战：Qt+Ffmpeg+OpenCV相机程序(打开摄像头、支持多种摄像头、分辨率调整、翻转、旋转、亮度调整、拍照、录像、回放图片、回放录像)

    若该文为原创文章,未经允许不得转载原博主博客地址:https://blog.csdn.net/qq21497936原博主博客导航:https://blog.csdn.net/qq21497936/ar ...

  6. 音视频处理之FFmpeg+SDL视频播放器20180409

    一.FFmpeg视频解码器 1.视频解码知识 1).纯净的视频解码流程 压缩编码数据->像素数据. 例如解码H.264,就是“H.264码流->YUV”. 2).一般的视频解码流程 视频码 ...

  7. FFmpeg开发笔记（四）：ffmpeg解码的基本流程详解

    若该文为原创文章,未经允许不得转载原博主博客地址:https://blog.csdn.net/qq21497936原博主博客导航:https://blog.csdn.net/qq21497936/ar ...

  8. FFmpeg开发笔记（五）：ffmpeg解码的基本流程详解（ffmpeg3新解码api）

    若该文为原创文章,未经允许不得转载原博主博客地址:https://blog.csdn.net/qq21497936原博主博客导航:https://blog.csdn.net/qq21497936/ar ...

  9. FFmpeg开发笔记（十）：ffmpeg在ubuntu上的交叉编译移植到海思HI35xx平台

    FFmpeg和SDL开发专栏(点击传送门) 上一篇:<FFmpeg开发笔记(九):ffmpeg解码rtsp流并使用SDL同步播放>下一篇:敬请期待   前言   将ffmpeg移植到海思H ...

  10. windows环境下搭建ffmpeg开发环境

           ffmpeg是一个开源.跨平台的程序库,能够使用在windows.linux等平台下,本文将简单解说windows环境下ffmpeg开发环境搭建过程,本人使用的操作系统为windows ...

随机推荐

  1. 重新点亮linux 命令树————grub配置文件[二十]

    前言 简单介绍一下grub 配置文件. 正文 grub 是什么呢? 引导配置. grub 配置文件: /etc/default/grub 默认grub配置文件 /etc/grub.d/ /boot/g ...

  2. jenkins 持续集成和交付——安装与账户安全还有凭证(二)

    前言 jenkins 整理完毕,共二十四章,逐步放出,互相交流学习.学会jenkins 只是第一步,真正的还是多写脚本,然后遇到构建过程的坑,然后解决. 正文 安装jenkins 首先是如何安装jen ...

  3. 使用GitHub Actions和GitHub pages实现前端项目的自动打包部署

    1. 引言 As we all know,前端部署项目是比较简单的,通常情况下只需要将打包的产物(index.html..js文件..css文件等)放在Web服务器下就,这种叫静态资源托管,成本是比较 ...

  4. 暑期集训 Day11 —— 模拟赛复盘

    ${\color{Green} \mathrm{Problem\ 1 :Subarray }} $ 签到失败... 直接二进制分组,找出所有二进制位=0 的方法. 死因: 二进制分组没想出来... $ ...

  5. 一文详解用eBPF观测HTTP

    简介: 随着eBPF推出,由于具有高性能.高扩展.安全性等优势,目前已经在网络.安全.可观察等领域广泛应用,同时也诞生了许多优秀的开源项目,如Cilium.Pixie等,而iLogtail 作为阿里内 ...

  6. 针对数据库连接池到DRDS连接探活的优化

    简介: 针对数据库连接池到DRDS连接探活的优化 1. 问题背景 近期在给某专有云客户进⾏云产品应⽤性能优化分析时,发现了⼀个有趣的关于DRDS使⽤层⾯的问题,这⾥给⼤家分享⼀下.使⽤过DRDS产品的 ...

  7. KubeDL HostNetwork：加速分布式训练通信效率

    ​简介:ubeDL 为分布式训练作业带来了 HostNetwork 网络模式,支持计算节点之间通过宿主机网络相互通信以提升网络性能,同时适应 RDMA/SCC 等新型高性能数据中心架构的网络环境,此外 ...

  8. 作业帮基于 DeltaLake 的数据湖建设最佳实践

    ​简介:作业帮是一家以科技为载体的在线教育公司,其大数据中台作为基础系统中台,主要负责建设公司级数仓,向各个产品线提供面向业务主题的数据信息.本文主要分享了作业帮基于 DeltaLake 的数据湖建设 ...

  9. 01 elasticsearch学习笔记-环境安装

    docker-compose安装EFK git clone https://github.com/haimait/docker_compose_efk docker-compose up -d Flu ...

  10. Golang 爬虫01

    目录 学习地址: 目录站: 爬虫概念: 工作流程: 百度贴吧爬虫实现: go实战代码 单进程 实现过程: 并发爬取 实现过程: 学习地址: https://www.bilibili.com/video ...