Qt-FFmpeg开发-打开摄像头直接显示YUYV422图像📀

---

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

---

1、概述📸

• 最近研究了一下FFmpeg开发，功能实在是太强大了，网上ffmpeg3、4的文章还是很多的，但是学习嘛，最新的还是不能放过，就选了一个最新的ffmpeg n5.1.2版本（更新太快了，都已经到7了😅），和3、4版本api变化还是挺大的；
• 在这个示例程序中主要使用Qt + FFmpeg开发一个相机，使用FFmpeg打开摄像头，并且【不需要解码】，直接显示获取到的【YUYV422】格式的AVPacket图像；
• 摄像头打开默认解码器是【rawvideo】（也有一些是mjpeg）,如果解码器是【rawvideo】，可直接获取到AV_PIX_FMT_YUYV422像素格式的AVPacket图像，可以不需要解码，直接就进行显示；
• 这里为了方便opengl显示，直接将YUYV422格式的AVPacket图像转为YUV420P格式的AVFrame进行显示。

开发环境说明

• 系统：Windows11、Ubuntu20.04
• Qt版本：V5.14.2
• 编译器：MSVC2017-64、GCC/G++64
• FFmpeg版本：n5.1.2
  • 注意：如果使用了较低版本的库，程序中部分功能可能会存在问题，不会兼容。
  • 官方下载
  • 我使用的库

2、实现效果💽

1. 使用ffmpeg音视频库打开本地摄像头；
2. 采用【OpenGL显示YUV】图像，支持自适应窗口缩放，支持使用QOpenGLWidget、QOpenGLWindow显示；
3. 打开摄像头后一般情况默认解码器为【rawvideo】，获取的图像像素格式为【YUYV422】，可以【不需要解码】，直接将YUYV422转为YUV420P进行显示；
4. 支持Windows、Linux打开本地摄像头；
5. 视频解码、线程控制、显示各部分功能分离，低耦合度。
6. 采用5.1.2版本ffmpeg库进行开发，超详细注释信息，将所有踩过的坑、解决办法、注意事项都得很写清楚;
7. 【注意：】如果打开摄像头失败，需要检测是不是摄像头分辨率设置不正确，解码器如果不是rawvideo则这个程序不执行;
8. 由于不同电脑摄像头打开时解码器不同，获取的图像格式不同，所以为了便于显示，在获取图像后统一转换为YUV420P格式进行显示。

3、主要代码🔍

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

• videodecode.h文件

  /******************************************************************************
   * @文件名     videodecode.h
   * @功能       视频解码类，在这个类中调用ffmpeg打开摄像头获取图像数据
   *
   * @开发者     mhf
   * @邮箱       1603291350@qq.com
   * @时间       2022/09/15
   * @备注
   *****************************************************************************/
  #ifndef VIDEODECODE_H
  #define VIDEODECODE_H
  
  #include <QSize>
  #include <QString>
  
  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();                                // 关闭
  
  private:
      void initFFmpeg();                              // 初始化ffmpeg库（整个程序中只需加载一次）
      void showError(int err);                        // 显示ffmpeg执行错误时的错误信息
      qreal rationalToDouble(AVRational* rational);   // 将AVRational转换为double
      bool toYUV420P();                               // 将视频帧格式由原始格式转换为YUV420P格式，便于显示
      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;                   // 解码后的视频帧（转换为YUV420P格式）
      int m_videoIndex = 0;                         // 视频流索引
      qint64 m_totalFrames = 0;                     // 视频总帧数
      qreal m_frameRate = 0;                        // 视频帧率
      char* m_error = nullptr;                      // 保存异常信息
      QSize m_size;
  };
  
  #endif   // VIDEODECODE_H
  
  

• videodecode.cpp文件

  #include "videodecode.h"
  #include <qdatetime.h>
  #include <QDebug>
  #include <QMutex>
  
  extern "C"   // 用C规则编译指定的代码
  {
  #include "libavcodec/avcodec.h"
  #include "libavdevice/avdevice.h"   // 调用输入设备需要的头文件
  #include "libavformat/avformat.h"
  #include "libavutil/avutil.h"
  #include "libavutil/imgutils.h"
  #include "libswscale/swscale.h"
  }
  
  #define ERROR_LEN 1024   // 异常信息数组长度
  
  VideoDecode::VideoDecode()
  {
      initFFmpeg();
  
      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库的支持，此函数将被弃用，并且此函数不再有任何用途。
           * 5.1.2版本不需要调用了
           */
          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.exe -list_devices true -f dshow -i dummy】命令查看所有可用设备
       *     可使用【.\ffmpeg.exe -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】命令查看摄像头支持的支持的像素格式、编解码器和帧大小
       */
      // 有些本地摄像头默认为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", "yuv420p", 0);   // 设置像素格式
      av_dict_set(&dict, "video_size", "1280x720", 0);   // 设置视频分辨率（如果该分辨率摄像头不支持则会报错）
  
      // 打开输入流并返回解封装上下文
      int ret = avformat_open_input(&m_formatContext,           // 返回解封装上下文
                                    url.toStdString().data(),   // 打开视频地址
                                    m_inputFormat,              // 如果非null，此参数强制使用特定的输入格式。自动选择解封装器（文件格式）
                                    nullptr);                   // 参数设置
  
      // 释放参数字典
      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;
      }
  
      // 通过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];   // 通过查询到的索引获取视频流
  
      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);
      if (AV_CODEC_ID_RAWVIDEO != codec->id)
      {
          qWarning() << "打开摄像头的编码器不是AV_CODEC_ID_RAWVIDEO";
          free();
          return false;
      }
      m_totalFrames = videoStream->nb_frames;
  
      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);
  
      // 分配AVCodecContext并将其字段设置为默认值。
      m_codecContext = avcodec_alloc_context3(codec);
      if (!m_codecContext)
      {
          qWarning() << "创建视频解码器上下文失败！";
          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)
      {
          free();
          return false;
      }
  
      // 获取缓存的图像转换上下文。首先校验参数是否一致，如果校验不通过就释放资源；然后判断上下文是否存在，如果存在直接复用，如不存在进行分配、初始化操作
      m_swsContext = sws_getCachedContext(m_swsContext,
                                          m_size.width(),       // 输入图像的宽度
                                          m_size.height(),      // 输入图像的高度
                                          AV_PIX_FMT_YUYV422,   // 输入图像的像素格式
                                          m_size.width(),       // 输出图像的宽度
                                          m_size.height(),      // 输出图像的高度
                                          AV_PIX_FMT_YUV420P,   // 输出图像的像素格式
                                          SWS_BILINEAR,         // 选择缩放算法(只有当输入输出图像大小不同时有效),一般选择SWS_FAST_BILINEAR
                                          nullptr,              // 输入图像的滤波器信息, 若不需要传NULL
                                          nullptr,              // 输出图像的滤波器信息, 若不需要传NULL
                                          nullptr);             // 特定缩放算法需要的参数(?)，默认为NULL
      if (!m_swsContext)
      {
          qWarning() << "sws_getCachedContext() Error！";
          free();
          return 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)
      {
          return nullptr;
      }
  
      if (m_packet->stream_index != m_videoIndex)   // 如果是图像数据则进行解码
      {
          av_packet_unref(m_packet);   // 释放数据包，引用计数-1，为0时释放空间
          return nullptr;
      }
  
      if (!toYUV420P())   // 转换图像格式
      {
          return nullptr;
      }
  
      return m_frame;
  }
  
  /**
   * @brief  将读取到的YUYV422原始数据直接转换为YUV420P格式的m_frame
   * @return
   */
  bool VideoDecode::toYUV420P()
  {
      m_frame->width = m_size.width();
      m_frame->height = m_size.height();
      m_frame->format = AV_PIX_FMT_YUV420P;
  
      if (!m_frame->data[0])
      {
          av_image_alloc(m_frame->data, m_frame->linesize, m_frame->width, m_frame->height, AV_PIX_FMT_YUV420P, 1);
      }
      int lineSize[4];
      av_image_fill_linesizes(lineSize, AV_PIX_FMT_YUYV422, m_size.width());
  
      uint8_t* srcSlice[1];
      srcSlice[0] = m_packet->data;
      int ret = sws_scale(m_swsContext,         // 缩放上下文
                          srcSlice,             // 原图像数组
                          lineSize,             // 包含源图像每个平面步幅的数组
                          0,                    // 开始位置
                          m_frame->height,      // 行数
                          m_frame->data,        // 目标图像数组
                          m_frame->linesize);   // 包含目标图像每个平面的步幅的数组
  
      av_packet_unref(m_packet);   // 释放数据包，引用计数-1，为0时释放空间
      if (ret < 0)
      {
          showError(ret);
          return false;
      }
  
      return true;
  }
  
  /**
   * @brief 关闭视频播放并释放内存
   */
  void VideoDecode::close()
  {
      clear();
      free();
  
      m_videoIndex = 0;
      m_totalFrames = 0;
      m_frameRate = 0;
  }
  
  /**
   * @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_freep(m_frame->data);
          av_frame_free(&m_frame);
      }
  }
  
  

4、完整源代码📑

• github
• gitee

🎈🎈  ☁️
　        🎈🎈🎈
☁️     🎈🎈🎈🎈
　      🎈🎈🎈🎈
　 ☁️    ⁣🎈🎈🎈
　          |/
　          🏠   ☁️
　 ☁️         ☁️

🌳🌻🏫🌳🏘🏢_🏘🏢🌲🌳