Ubuntu18使用FFMPEG实现QSV硬解






前言

由于项目需要,需要在一块I7-8850H上进行H264解码成YUV并显示的功能。由于系统是Ubuntu18,故打算使用QT+FFMPEG来实现。先前的一路软解发现CPU占用率去到了20%以上,我们需要同时进行四路解码,这个占用率是无法接受的,故打算使用FFMPEG进行硬解。由于只有I7的集显,所以只能使用QSV。前面已经完成了环境的安装(具体教程在Ubuntu18上安装QSV+FFMPEG环境  ) ,此文章将展示如何在QT中实现ffmpeg的硬解,使用的库的路径全部基于安装教程里面的路径和版本。此教程假设观看者有一定的C++和QT开发经验。

使用的Qt Creator版本信息如下图

Ubuntu18使用FFMPEG实现QSV硬解_第1张图片
 






一、.pro文件的配置

在.pro文件添加includpath跟lib,之所以添加这么多,是因为有各自库之间有相互引用,添加少了虽然不报错,但是解不了码。

INCLUDEPATH += /opt/intel/mediasdk/include
INCLUDEPATH += /usr/local/include
INCLUDEPATH += /opt/intel/mediasdk/include/mfx
INCLUDEPATH +=/usr/include/x86_64-linux-gnu/

LIBS +=  -Llibavcodec -Llibavdevice -Llibavfilter -Llibavformat -Llibavutil -Llibpostproc -Llibswscale -Llibswresample  -lavdevice
LIBS += -lavfilter -lavformat -lavcodec -lswresample -lswscale -lavutil  -lm -lxcb -lxcb-shm -lxcb-shape -lxcb-xfixes -pthread -lm
LIBS += -L/usr/local/lib -lva -L/opt/intel/mediasdk/lib -lmfx -lstdc++ -ldl -lm -lbz2 -lz -pthread -lm -lz -L/usr/local/lib -lva
LIBS += -L/opt/intel/mediasdk/lib -lmfx -lstdc++ -ldl -lm -lm -pthread -L/usr/local/lib -lva-drm -lva -L/usr/local/lib -lva-x11 -lva -lm
LIBS += -L/opt/intel/mediasdk/lib -lmfx -lstdc++ -ldl -L/usr/local/lib -lva -lX11





二、具体代码实现

1、创建一个HW_H264Decoder

2、在.h文件里添加ffmpeg的头文件引用

#include 
#include 
#include 
extern "C" {
#include "libavformat/avformat.h"
#include "libavformat/avio.h"
#include "libavcodec/avcodec.h"
#include "libavutil/buffer.h"
#include "libavutil/error.h"
#include "libavutil/hwcontext.h"
#include "libavutil/hwcontext_qsv.h"
#include "libavutil/mem.h"
#include "libavutil/imgutils.h"
#include 
#include 
}

ffmpeg都是用C写的,连官方demo都是C,所以导致在C++中,include的时候需要用extern "C" 把ffmpeg的头文件引用给包起来,不然编译的时候会报错。

3、在.h文件里定义几个需要用到方法

    /**
     *  初始化
     *
     * @param width : 视频的宽度
     * @param height : 视频的高度
     *
     * @return 错误代码  0:成功
     *
     **/
    int init(int width,int height);
      /**
     *  传入H264数据,并获取解码后的NV12数据  (QSV好像只能解成NV12)
     *
     * @param h264Data : H264数据
     * @param size : H264数据的长度
     * @param nv12Data:存放NV12数据的缓冲
     *
     * @return NV12数据的长度
     *
     **/
    int decodeToNV12(uint8_t *h264Data,int size,unsigned char *nv12Data);
     /**
     *  释放资源
     *
     **/
    void relese();

4、在.h文件里面定义需要用到的类变量(个人习惯,可不在.h里定义)

  //解码需要用到的上下文 
  AVCodecContext *decoder_ctx = NULL;
  //解码器对象
  const AVCodec *decoder;
  //放H264数据包的对象
  AVPacket *pkt;
  //指向GPU内存的帧对象
  AVFrame *frame = NULL;
  //指向CPU内存的帧对象
  AVFrame *sw_frame = NULL;
  //解码使用的buffer指针
  AVBufferRef *device_ref = NULL; 
  //存放sps的数组
  char sps[50] = {0x00,0x00,0x00,0x01,0x67,0x4d,0x00,0x1f,(char)0xe9,(char)0x80,(char)0xa0,0x0b,0x74,(char)0xa4,0x14,0x18,0x18,0x1b,0x42,(char)0x84,(char)0xa7};
  //存放PPS的数组
  char pps[50] = {0x00,0x00,0x00,0x01,0x68,(char)0xee,0x06,(char)0xe2};
  //sps的长度
  int spsLen=0;
  //pps的长度
  int ppsLen=0;

5、在.cpp文件中实现 init方法,实现对ffmpeg解码相关操作的初始化

static AVPixelFormat get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
{
    while (*pix_fmts != AV_PIX_FMT_NONE) {
        if (*pix_fmts == AV_PIX_FMT_QSV) {
            return AV_PIX_FMT_QSV;
        }

        pix_fmts++;
    }

    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");

    return AV_PIX_FMT_NONE;
}

int HW_H264Decoder::init(int width,int height){
    int ret;
    /* 打开QSV设备 */
    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV,"auto", NULL, 0);
    /* 检查下是否打开成功,失败则直接跳出去 */
    if (ret < 0) {
        fprintf(stderr, "Cannot open the hardware device\n");
        return -1;
    }
    /* 打开解码器,这里是使用qsv对H264进行硬解,故使用h264_qsv */
    decoder = avcodec_find_decoder_by_name("h264_qsv");
    /* 检查下是否打开成功,失败则直接跳出去 */
    if (!decoder) {
        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
       return -1;
    }
    /* 根据解码器初始化解码器的上下文 */
    decoder_ctx = avcodec_alloc_context3(decoder);
    /* 检查下是否初始化打开成功,失败则直接跳出去 */
    if (!decoder_ctx) {
         return -1;
    }
    /* 设置下解码类型 */
    decoder_ctx->codec_id = AV_CODEC_ID_H264;
    /* 开辟解码器使用的缓冲 */
    decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);
    /* 设置下QSV格式  之所以这么写,是为了确定是否有QSV */
    decoder_ctx->get_format  = get_format;
    /* 把解码器的上下文跟解码器绑定并初始化 */
    ret = avcodec_open2(decoder_ctx, decoder, NULL);
    /* 检查下是否初始化成功,失败则直接跳出去 */
    if (ret < 0) {
        fprintf(stderr, "Error opening the decoder: ");
        return -1;
    }
    /* 初始化用到的帧对象 */
    frame    = av_frame_alloc();
    sw_frame = av_frame_alloc();
    /* 初始化存放H264包的对象 */
    pkt = av_packet_alloc();
    /* 检查下是否初始化成功,失败则直接跳出去 */
    if (!frame || !sw_frame || !pkt) {
        ret = AVERROR(ENOMEM);
       return -1;
    }
    return 0;
}

5、在.cpp文件中实现decode方法,实现对传入H264数据后解码成NV12数据出来

int HW_H264Decoder::decodeToNV12(uint8_t *h264Data, int size, unsigned char *nv12Data){
         int ret = 0;
         /* 由于I帧需要在前面家SPSPPS 不然会出现无法解码的情况,故开辟个临时缓冲区 */
         uint8_t *h264DataTemp = NULL;
          /* 如果是SPS 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x67){
             memcpy(sps,h264Data,size);
             spsLen = size;
             return 0;
         }
         /* 如果是pps 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x68){
             memcpy(pps,h264Data,size);
             ppsLen = size;
             return 0;
         }
         /* 判断下是否是I帧  是I帧的话需要在前面加上spspps,不然会导致解不出东西 */
         if(h264Data[4] == 0x65){
              /* 现在是I帧,需要加上SPSPPS,故计算下加上spspps之后的长度是多少 */
             int spsppsIframeLen = size+spsLen+ppsLen;
             /* 开辟出需要的内存 */
             h264DataTemp = new uint8_t[spsppsIframeLen];
             /* 先复制SPS进去 */
             memcpy(h264DataTemp,sps,spsLen);
             /* 再复制PPS进去 */
             memcpy(h264DataTemp+spsLen,pps,ppsLen);
             /* 最后再把I帧复制进去 */
             memcpy(h264DataTemp+spsLen+ppsLen,h264Data,size);
             /* 把pkt对象的数据指针直接指向整理好的加上了spspps的数据 */
             pkt->data = h264DataTemp;
             pkt->size = spsppsIframeLen;

         }else{
             /* 不是I帧  直接开辟出传进来的H264数据大小的内存就行了 */
             h264DataTemp = new uint8_t[size];
             /* 把H264数据复制进去 */
             memcpy(h264DataTemp,h264Data,size);
             /* 把pkt对象的数据指针直接指向H264数据 */
             pkt->data = h264DataTemp;
             pkt->size = size;
         }
     /* 定义解码后的数据的长度 */
     int outputSize = 0;
     /* 把H264数据喂给解码器 */
    ret = avcodec_send_packet(decoder_ctx, pkt);
    /* 判断下是否喂成功了,失败则直接退出 */
    if (ret < 0) {
        fprintf(stderr, "Error during decoding   str:%s  \n",strerror(errno));
        return ret;
    }
    /* 循环去读是否有已经解完码的数据 */
    while (ret >= 0) {
        int i, j;
        /* 读取已经解完码的数据 */
        ret = avcodec_receive_frame(decoder_ctx, frame);
        /* 如果是没有数据或者需要新的输入才能解码 则直接退出循环 */
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            /* 还在解码中 直接退出等下次喂完再看看 */
            fprintf(stderr, "Error during decoding\n");
             return ret;
        }
        /* 拿到解完码的数据对象frame了,但是这份数据不在CPU里,需要av_hwframe_transfer_data转到CPU里,然后赋值给sw_frame    */
        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
        /* 看看是否转成功了,失败则退出 */
        if (ret < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
             return ret;
        }

       /* 把NV12数据复制到给定的内存空间,NV12数据在AVFrame中的存储存储方式为->data[0]里面存着Y分量  ->data[1]厘米存着UV分量 */
         for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++){
            /* 把数据全部读出来 */
            for (j = 0; j < (sw_frame->height >> (i > 0)); j++){
               memcpy(nv12Data+writeLen,sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
                 /* 复制出来的长度需要累计,最后返回给调用者,才知道解码出来的数据大小 */
               writeLen+=sw_frame->width;
            }
        }

    }
    outputSize =  writeLen;
    /* 释放一下内存 */
    av_packet_unref(pkt);
    delete []h264DataTemp;

    return outputSize;
}

6、在.cpp文件中实现relese方法,销毁释放内存

void HW_H264Decoder::relese(){
    av_frame_free(&frame);
    av_frame_free(&sw_frame);
    avcodec_free_context(&decoder_ctx);
    av_packet_free(&pkt);
    av_buffer_unref(&device_ref);;
}

至此,通过FFMPEG实现QSV硬解的相关代码就写完了。

下面是完整的.h跟.cpp文件

hw_h264decoder.h

#ifndef HW_H264DECODER_H
#define HW_H264DECODER_H

#include 
#include 
#include 
extern "C" {
#include "libavformat/avformat.h"
#include "libavformat/avio.h"
#include "libavcodec/avcodec.h"

#include "libavutil/buffer.h"
#include "libavutil/error.h"
#include "libavutil/hwcontext.h"
#include "libavutil/hwcontext_qsv.h"
#include "libavutil/mem.h"
#include "libavutil/imgutils.h"
#include 
#include 

}


class HW_H264Decoder
{
public:
    HW_H264Decoder();
    ~HW_H264Decoder();
    /**
     *  初始化
     *
     * @param width : 视频的宽度
     * @param height : 视频的高度
     *
     * @return 错误代码  0:成功
     *
     **/
    int init(int width,int height);
    /*************************************************
        Function:decode   转成NV12再转成RGB32的数据
        Description:初始化
        Input:h264Data-H264图像数据
        Return:错误代码
        Others:无
      *************************************************/
    int decodeToRGB32(uint8_t *h264Data,int size,unsigned char *buf);
    /**
     *  传入H264数据,并获取解码后的NV12数据  (QSV好像只能解成NV12)
     *
     * @param h264Data : H264数据
     * @param size : H264数据的长度
     * @param nv12Data:存放NV12数据的缓冲
     *
     * @return NV12数据的长度
     *
     **/
    int decodeToNV12(uint8_t *h264Data,int size,unsigned char *nv12Data);
    /**
     *  释放资源
     *
     **/
    void relese();

private:
    //解码需要用到的上下文
    AVCodecContext *decoder_ctx = NULL;
    //解码器对象
    const AVCodec *decoder;
    //放H264数据包的对象
    AVPacket *pkt;
    //指向GPU内存的帧对象    指向CPU内存的帧对象  存储RGB32数据的帧对象
    AVFrame *frame = NULL, *sw_frame = NULL,*frameRGB = NULL;
    //解码使用的buffer指针
    AVBufferRef *device_ref = NULL;
    //输出的图像数据的大小
    int outImgSize;
    //转换格式使用的内存
    unsigned char *out_buffer;
    //用于视频图像转换的对象
    struct SwsContext *img_convert_ctx;
    //sps  这里先设置测试用的数据的SPS
    char sps[50] = {0x00,0x00,0x00,0x01,0x67,0x4d,0x00,0x1f,(char)0xe9,(char)0x80,(char)0xa0,0x0b,0x74,(char)0xa4,0x14,0x18,0x18,0x1b,0x42,(char)0x84,(char)0xa7};
    //pps  这里先设置测试用的数据的pps
    char pps[50] = {0x00,0x00,0x00,0x01,0x68,(char)0xee,0x06,(char)0xe2};
    //拿到的sps的长度
    int spsLen=0;
    //拿到的pps的长度
    int ppsLen=0;

};

#endif // HW_H264DECODER_H

hw_h264decoder.cpp

#include "hw_h264decoder.h"



static AVPixelFormat get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
{
    while (*pix_fmts != AV_PIX_FMT_NONE) {
        if (*pix_fmts == AV_PIX_FMT_QSV) {
            return AV_PIX_FMT_QSV;
        }

        pix_fmts++;
    }

    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");

    return AV_PIX_FMT_NONE;
}

HW_H264Decoder::HW_H264Decoder()
{

}
HW_H264Decoder::~HW_H264Decoder()
{

}


int HW_H264Decoder::init(int width,int height){
    int ret;
    /* 打开QSV设备 */
    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV,"auto", NULL, 0);
    /* 检查下是否打开成功,失败则直接跳出去 */
    if (ret < 0) {
        fprintf(stderr, "Cannot open the hardware device\n");
        return -1;

    }
    /* 打开解码器,这里是使用qsv对H264进行硬解,故使用h264_qsv */
    decoder = avcodec_find_decoder_by_name("h264_qsv");
    /* 检查下是否打开成功,失败则直接跳出去 */
    if (!decoder) {
        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
       return -1;
    }
    /* 根据解码器初始化解码器的上下文 */
    decoder_ctx = avcodec_alloc_context3(decoder);
    /* 检查下是否初始化打开成功,失败则直接跳出去 */
    if (!decoder_ctx) {
         return -1;
    }
    /* 设置下解码类型 */
    decoder_ctx->codec_id = AV_CODEC_ID_H264;
    /* 开辟解码器使用的缓冲 */
    decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);
    /* 设置下QSV格式  之所以这么写,是为了确定是否有QSV */
    decoder_ctx->get_format  = get_format;
    /* 虽然说QSV只有解出NV12  但是这里设置一下好了 */
    decoder_ctx->pix_fmt = AV_PIX_FMT_NV12;
    /* 把解码器的上下文跟解码器绑定并初始化 */
    ret = avcodec_open2(decoder_ctx, decoder, NULL);
    /* 检查下是否初始化成功,失败则直接跳出去 */
    if (ret < 0) {
        fprintf(stderr, "Error opening the decoder: ");
        return -1;
    }
    /* 初始化用到的帧对象 */
    frame    = av_frame_alloc();
    sw_frame = av_frame_alloc();
    frameRGB = av_frame_alloc();
    /* 初始化存放H264包的对象 */
    pkt = av_packet_alloc();
    /* 检查下是否初始化成功,失败则直接跳出去 */
    if (!frame || !sw_frame || !frameRGB || !pkt) {
        ret = AVERROR(ENOMEM);
       return -1;
    }

    // 创建动态内存,创建存储RGB32图像数据的空间(av_image_get_buffer_size获取一帧图像需要的大小)
    outImgSize = av_image_get_buffer_size(AV_PIX_FMT_RGB32, width, height, 1);
    out_buffer = (unsigned char *)av_malloc(outImgSize);
    // 存储一帧像素数据缓冲区
    av_image_fill_arrays(frameRGB->data, frameRGB->linesize, out_buffer,AV_PIX_FMT_RGB32, width,height, SWS_FAST_BILINEAR );
    // 初始化img_convert_ctx结构  配置转换成RGB32
    img_convert_ctx = sws_getContext(width,height, decoder_ctx->pix_fmt,width, height, AV_PIX_FMT_RGB32, SWS_BICUBIC, nullptr, nullptr, nullptr);


    return 0;
}

void HW_H264Decoder::relese(){
    av_frame_free(&frame);
    av_frame_free(&sw_frame);
    av_frame_free(&frameRGB);
    avcodec_free_context(&decoder_ctx);
    av_packet_free(&pkt);
    av_buffer_unref(&device_ref);
    sws_freeContext(img_convert_ctx);
}

int HW_H264Decoder::decodeToRGB32(uint8_t *h264Data,int size,unsigned char *buf){
         int ret = 0;
          /* 由于I帧需要在前面家SPSPPS 不然会出现无法解码的情况,故开辟个临时缓冲区 */
         uint8_t *h264DataTemp = NULL;
         /* 如果是SPS 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x67){
             memcpy(sps,h264Data,size);
             spsLen = size;
             return 0;
         }
         /* 如果是pps 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x68){
             memcpy(pps,h264Data,size);
             ppsLen = size;
             return 0;
         }
         /* 判断下是否是I帧  是I帧的话需要在前面加上spspps,不然会导致解不出东西 */
         if(h264Data[4] == 0x65){
             /* 现在是I帧,需要加上SPSPPS,故计算下加上spspps之后的长度是多少 */
             int spsppsIframeLen = size+spsLen+ppsLen;
             /* 开辟出需要的内存 */
             h264DataTemp = new uint8_t[spsppsIframeLen];
             /* 先复制SPS进去 */
             memcpy(h264DataTemp,sps,spsLen);
             /* 再复制PPS进去 */
             memcpy(h264DataTemp+spsLen,pps,ppsLen);
             /* 最后再把I帧复制进去 */
             memcpy(h264DataTemp+spsLen+ppsLen,h264Data,size);
             /* 把pkt对象的数据指针直接指向整理好的加上了spspps的数据 */
             pkt->data = h264DataTemp;
             pkt->size = spsppsIframeLen;

         }else{
             /* 不是I帧  直接开辟出传进来的H264数据大小的内存就行了 */
             h264DataTemp = new uint8_t[size];
             /* 把H264数据复制进去 */
             memcpy(h264DataTemp,h264Data,size);
             /* 把pkt对象的数据指针直接指向H264数据 */
             pkt->data = h264DataTemp;
             pkt->size = size;
         }
     /* 定义解码后的数据的长度 */
     int outputSize = 0;
     /* 把H264数据喂给解码器 */
    ret = avcodec_send_packet(decoder_ctx, pkt);
    /* 判断下是否喂成功了,失败则直接退出 */
    if (ret < 0) {
        fprintf(stderr, "Error during decoding   str:%s  \n",strerror(errno));
        return ret;
    }
   /* 循环去读是否有已经解完码的数据 */
    while (ret >= 0) {
        int i, j;
        /* 读取已经解完码的数据 */
        ret = avcodec_receive_frame(decoder_ctx, frame);
        /* 如果是没有数据或者需要新的输入才能解码 则直接退出循环 */
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            /* 还在解码中 直接退出等下次喂完再看看 */
            fprintf(stderr, "Error during decoding\n");
             return ret;
        }
        /* 拿到解完码的数据对象frame了,但是这份数据不在CPU里,需要av_hwframe_transfer_data转到CPU里,然后赋值给sw_frame    */
        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
        /* 看看是否转成功了,失败则退出 */
        if (ret < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
             return ret;
        }
        /* 把拿出来的NV12转成RGB32 */
         ret = sws_scale(img_convert_ctx,sw_frame->data, sw_frame->linesize, 0, sw_frame->height,frameRGB->data, frameRGB->linesize);
         /* 把RGB32复制到输出的缓冲 */
         memcpy(buf,frameRGB->data[0],outImgSize);
         /* 输出的RGB32的大小 */
         outputSize = outImgSize;


    }/* 释放一下内存 */
    av_packet_unref(pkt);
    delete []h264DataTemp;

    return outputSize;
}


int HW_H264Decoder::decodeToNV12(uint8_t *h264Data, int size, unsigned char *nv12Data){
         int ret = 0;
         /* 由于I帧需要在前面家SPSPPS 不然会出现无法解码的情况,故开辟个临时缓冲区 */
         uint8_t *h264DataTemp = NULL;
          /* 如果是SPS 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x67){
             memcpy(sps,h264Data,size);
             spsLen = size;
             return 0;
         }
         /* 如果是pps 则存起来,不喂给解码器,不然会导致解不出东西 */
         if(h264Data[4] == 0x68){
             memcpy(pps,h264Data,size);
             ppsLen = size;
             return 0;
         }
         /* 判断下是否是I帧  是I帧的话需要在前面加上spspps,不然会导致解不出东西 */
         if(h264Data[4] == 0x65){
              /* 现在是I帧,需要加上SPSPPS,故计算下加上spspps之后的长度是多少 */
             int spsppsIframeLen = size+spsLen+ppsLen;
             /* 开辟出需要的内存 */
             h264DataTemp = new uint8_t[spsppsIframeLen];
             /* 先复制SPS进去 */
             memcpy(h264DataTemp,sps,spsLen);
             /* 再复制PPS进去 */
             memcpy(h264DataTemp+spsLen,pps,ppsLen);
             /* 最后再把I帧复制进去 */
             memcpy(h264DataTemp+spsLen+ppsLen,h264Data,size);
             /* 把pkt对象的数据指针直接指向整理好的加上了spspps的数据 */
             pkt->data = h264DataTemp;
             pkt->size = spsppsIframeLen;

         }else{
             /* 不是I帧  直接开辟出传进来的H264数据大小的内存就行了 */
             h264DataTemp = new uint8_t[size];
             /* 把H264数据复制进去 */
             memcpy(h264DataTemp,h264Data,size);
             /* 把pkt对象的数据指针直接指向H264数据 */
             pkt->data = h264DataTemp;
             pkt->size = size;
         }
     /* 定义解码后的数据的长度 */
     int outputSize = 0;
     /* 把H264数据喂给解码器 */
    ret = avcodec_send_packet(decoder_ctx, pkt);
    /* 判断下是否喂成功了,失败则直接退出 */
    if (ret < 0) {
        fprintf(stderr, "Error during decoding   str:%s  \n",strerror(errno));
        return ret;
    }
    /* 循环去读是否有已经解完码的数据 */
    while (ret >= 0) {
        int i, j;
        /* 读取已经解完码的数据 */
        ret = avcodec_receive_frame(decoder_ctx, frame);
        /* 如果是没有数据或者需要新的输入才能解码 则直接退出循环 */
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            /* 还在解码中 直接退出等下次喂完再看看 */
            fprintf(stderr, "Error during decoding\n");
             return ret;
        }
        /* 拿到解完码的数据对象frame了,但是这份数据不在CPU里,需要av_hwframe_transfer_data转到CPU里,然后赋值给sw_frame    */
        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
        /* 看看是否转成功了,失败则退出 */
        if (ret < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
             return ret;
        }

       /* 把NV12数据复制到给定的内存空间,NV12数据在AVFrame中的存储存储方式为->data[0]里面存着Y分量  ->data[1]厘米存着UV分量 */
         for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++){
            /* 把数据全部读出来 */
            for (j = 0; j < (sw_frame->height >> (i > 0)); j++){
               memcpy(nv12Data+outputSize ,sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
                 /* 复制出来的长度需要累计,最后返回给调用者,才知道解码出来的数据大小 */
               outputSize +=sw_frame->width;
            }
        }

    }
    /* 释放一下内存 */
    av_packet_unref(pkt);
    delete []h264DataTemp;

    return outputSize;
}




调用的时候直接先init初始化一下,然后就调用decode把H264数据传进去就可以实现解码了(前三包必须是sps->ssp->I帧),程序结束的时候调用relese就销毁就行了

/* 从文件中读取H264数据并进行解码 解码成功后发到UI线程显示 */
void ShowCH1Thread::run(){

      int ret;
      /* 实例化解码类的对象 */
     HW_H264Decoder mHWh264Decodec;
     /* 初始化解码类 */
     ret =  mHWh264Decodec.init(1920,1080);
    if(ret != 0){
        printf("init h264 decodec fialed!   %s\n",strerror(errno));

    }
    /* 开辟需要用到的内存空间 */
    char h264Data[4096] = {0x00};
    uint8_t *grbData = (uint8_t *)malloc(1024*1024*10);
    uint8_t *H264Cache = (uint8_t*)malloc(1024*1024*1);
    int cacheindex = 0;
    /* 打开一个h264文件用来读H264数据进行解码 */
    int h264File = open("/home/vis/qsvLIb/H264Player/test.h264",O_RDWR);
   if(!h264Data){
      printf("open h264 file failed!   %s\n",strerror(errno));
    }
        int len = -1;
           while(true){
             /* 先读一个直接出来  看看是不是01  主要用来判断NAL标识头 00000001 */
               len = read(h264File,h264Data,1);
               if(len > 0){
                    /* 读到01了  长度也大于等于3  那么可能是一个NAL标识头 */
                   if(h264Data[0] == 0x01 && cacheindex >= 3){
                     /* 判断下是不是一个NAL头 */
                       if(H264Cache[cacheindex-1] == 0x00 && H264Cache[cacheindex-2] == 0x00 && H264Cache[cacheindex-3] == 0x00){
                              /* 是NAL头   那么把这帧数据拿去解码 */
                              int h264len = cacheindex-3;
                              if(h264len > 5){
                                 ret = mHWh264Decodec.decodeToRGB32(H264Cache,h264len,grbData);
                                 /* ret大于0则说明解码成功  ret就是解码出来的数据的长度  发到UI线程进行显示 */
                               if(ret > 0){
                                  emit sigShowCH1ToUI(grbData);
                                   usleep(40*1000);
                               }
                              }
                              memset(H264Cache,0x00,cacheindex);
                              cacheindex = 3;
                              H264Cache[cacheindex] = h264Data[0];
                              cacheindex++;


                       }else{
                          /* 还没找到头  继续读 */
                           H264Cache[cacheindex] = h264Data[0];
                           cacheindex++;
                       }

                   }else{
                       /* 还没找到头  继续读 */
                       H264Cache[cacheindex] = h264Data[0];
                       cacheindex++;
                   }
               }else{
                    printf("read h264 file failed!  len=%d %s\n",len,strerror(errno));
                    break;
               }

           }

           /* 释放一下 */
           mHWh264Decodec.relese();
           close(h264File);
           free(h264Data);
           free(grbData);
           free(H264Cache);
}

这个实现过程主要是参考了ffmpeg/doc/examples/qsvdec.c文件,实现得比较粗糙,需要的话可以去看看这个文件的内容,可以加深对QSV硬解的理解

你可能感兴趣的:(Linux,笔记,qt,linux,ffmpeg,qsv,硬解)