dxva2硬件加速解码avc码流

于 2024-02-27 11:49:51 发布
阅读量849 收藏 12
点赞数 9
文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50711528/article/details/136318587
版权

dxva加速AVC硬件解码

注：本人为新手小白，网上关于dxva解码的资料实在是太少了，只能靠自己慢慢摸索，因此可能有误，希望有大佬帮忙解答一下，本贴仅用于个人成长记录

0、dxva参考资料

  1. 官网教程
    https://learn.microsoft.com/zh-cn/windows/win32/medfound/about-dxva-2-0?redirectedfrom=MSDN
  2. ffmpeg源码

1、dxva解码步骤

  1. 创建D3D设备和设备管理器
  2. 打开设备句柄获取解码服务
  3. 使用解码服务创建surface池
  4. 使用对应的surface和guid创建解码器
  5. 测试device是否正常
  6. LockDevice锁定设备
  7. BeginFrame开始解码
  8. 获取各个buffer的内存地址并填充数据
  9. Execute执行解码
  10. EndFrame结束解码
  11. UnlockDevice解除锁定

2、解码步骤解析以及参数设置

dxva加速解码需要额外对avc码流的sps，pps和slice进行解析，提取关键信息后才能填入数据进行加速解码

typedef struct
{
    IDirect3D9Ex* d3d9ex;					//d3d接口
    IDirect3DDeviceManager9* d3dmanager;	//设备管理器
    IDirect3DDevice9Ex* d3ddevice;			//d3d设备
    IDirectXVideoDecoderService* d3ddecode_service;// 解码服务
    HANDLE d3ddevice_handle;				// 设备句柄
}Dxva2ConfigContext;

首先需要创建设备管理器，并且获取解码服务

DxvaResult Dxva2DecodeManager::dxva2Create9()
{
    HRESULT hr = S_OK;
    UINT pResetToken = 0;

    if (m_isinit)
    {
        return DXVA_OK;
    }
    hr = Direct3DCreate9Ex(D3D_SDK_VERSION, &m_dxva_conf_ctx.d3d9ex);
    if (FAILED(hr))	return DXVA_FAIL;

    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = TRUE;
    d3dpp.BackBufferWidth = 640;
    d3dpp.BackBufferHeight = 480;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferCount = 0;
    d3dpp.Flags = D3DPRESENTFLAG_VIDEO;

    m_dxva_conf_ctx.d3d9ex->CreateDeviceEx(
        D3DADAPTER_DEFAULT,
        D3DDEVTYPE_HAL,
        nullptr,
        D3DCREATE_FLAGS,
        &d3dpp,
        NULL,
        &m_dxva_conf_ctx.d3ddevice
    );
    if (FAILED(hr))
    {
        m_dxva_conf_ctx.d3d9ex->Release();
        return DXVA_FAIL;
    }

    hr = DXVA2CreateDirect3DDeviceManager9(&pResetToken, &m_dxva_conf_ctx.d3dmanager);
    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }
    hr = m_dxva_conf_ctx.d3dmanager->ResetDevice(m_dxva_conf_ctx.d3ddevice, pResetToken);

    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }

    hr = m_dxva_conf_ctx.d3dmanager->OpenDeviceHandle(&m_dxva_conf_ctx.d3ddevice_handle);
    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }

    hr = m_dxva_conf_ctx.d3dmanager->GetVideoService(m_dxva_conf_ctx.d3ddevice_handle, IID_PPV_ARGS(&m_dxva_conf_ctx.d3ddecode_service));
    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }

    hr = m_dxva_conf_ctx.d3dmanager->CloseDeviceHandle(m_dxva_conf_ctx.d3ddevice_handle);
    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }
    m_dxva_conf_ctx.d3ddevice_handle = NULL;

    m_isinit = true;
    return DXVA_OK;
}

然后创建surface池用来存储解码帧，解码出来的帧数据以IDirect3DSurface9的形式存储在gpu中

DxvaResult Dxva2DecodeManager::dxva2CreateSurfacePool(Dxva2SurfaceParam* desc, SurfaceType_t*& surface_pool, UINT count)
{
    HRESULT hr = S_OK;
    surface_pool = new SurfaceType_t[count];
    hr = m_dxva_conf_ctx.d3ddecode_service->CreateSurface(
    desc->Width,
    desc->Height,
    count - 1,
    desc->Format,
    D3DPOOL_DEFAULT,
    0,
    DXVA2_VideoDecoderRenderTarget,
    surface_pool,
    NULL
    );
    if (FAILED(hr))
    {
    return DXVA_FAIL;
    }
    return DXVA_OK;
}

接着需要创建解码器，其中guid采用的DXVA2_ModeH264_E，反正ffmpeg上好像也用这个

DxvaResult Dxva2DecodeManager::dxva2CreateDecoder(Dxva2SurfaceParam* desc, SurfaceType_t* surface_pool, UINT count, DXVADecoder_t& decoder)
{
    HRESULT hr = S_OK;
    DXVA2_VideoDesc decode_desc;
    decode_desc.SampleWidth = desc->Width;
    decode_desc.SampleHeight = desc->Height;
    decode_desc.Format = desc->Format;

    UINT config_count = 0;
    DXVA2_ConfigPictureDecode* configs = NULL;
    hr = m_dxva_conf_ctx.d3ddecode_service->GetDecoderConfigurations(m_decoder_guid, &decode_desc, nullptr, &config_count, &configs);
    if (FAILED(hr))
    {
        return DXVA_FAIL;
    }

    UINT index = 0;
    for (; index < config_count; index++)
    {
        if (configs[index].ConfigBitstreamRaw == 2)	// surport short
        {
            hr = m_dxva_conf_ctx.d3ddecode_service->CreateVideoDecoder(
                m_decoder_guid,
                &decode_desc,
                &configs[index],
                surface_pool,
                count,
                &decoder
            );
            if (FAILED(hr))
            {
                return DXVA_FAIL;
            }
            break;
        }
    }
    if (index >= config_count)
    {
        return DXVA_FAIL;
    }
    else
    {
        return DXVA_OK;
    }
}

创建完解码器之后就需要开始解码了，解码需要用到自己解析的avc码流的sps，pps和slice数据信息，这个应该需要自己写，下面是填写dxvabuffer需要用到的数据，把这几个结构体的数据填好基本上就大功告成

typedef struct DxvaDecodeParam
{
    DXVA2_DecodeExecuteParams	executeParams;
    DXVA2_DecodeBufferDesc		bufferDesc[4];
    DXVA_PicParams_H264			h264PictureParams;
    DXVA_Qmatrix_H264			h264QuantaMatrix;
    DXVA_Slice_H264_Short		h264SliceShort[MAX_SUB_SLICE];

    DxvaDecodeParam()
    {
        memset(&executeParams, 0, sizeof(DXVA2_DecodeExecuteParams));
        memset(bufferDesc, 0, 4 * sizeof(DXVA2_DecodeBufferDesc));
        memset(&h264PictureParams, 0, sizeof(DXVA_PicParams_H264));
        memset(h264SliceShort, 0, MAX_SUB_SLICE * sizeof(DXVA_Slice_H264_Short));
        memset(&h264QuantaMatrix, 16, sizeof(DXVA_Qmatrix_H264));

        bufferDesc[0].CompressedBufferType = DXVA2_PictureParametersBufferType;
        bufferDesc[0].DataSize = sizeof(DXVA_PicParams_H264);

        bufferDesc[1].CompressedBufferType = DXVA2_InverseQuantizationMatrixBufferType;
        bufferDesc[1].DataSize = sizeof(DXVA_Qmatrix_H264);

        bufferDesc[2].CompressedBufferType = DXVA2_BitStreamDateBufferType;

        bufferDesc[3].CompressedBufferType = DXVA2_SliceControlBufferType;

        executeParams.NumCompBuffers = 4;
        executeParams.pCompressedBuffers = bufferDesc;
    }
}DxvaDecodeParam;

解析sps和pps以及slice的部分有点多，而且我还没搞清楚，暂时不弄了，下面是解码一帧的数据的代码

DxvaResult Dxva2Decoder::decodeFrame(SPS_DATA* sps, PPS_DATA* pps, SLICE_DATA* slice, uint8_t** nalu_data, uint32_t* nalu_len, uint32_t* sf_id)
{
    HRESULT hr = S_OK;
    IDirect3DDevice9* pDevice = NULL;
    const unsigned char startcode[3] = { 0,0,1 };
    uint32_t surface_id;


    getFreeSurface(&surface_id);
    *sf_id = surface_id;

    m_used_count[surface_id].decoder_used = TRUE;
    m_used_count[surface_id].render_used = TRUE;

    Dxva2DecodeManager::instance().dxva2OpenDeviceHandle();
    Dxva2DecodeManager::instance().dxva2TestDevice();
    Dxva2DecodeManager::instance().dxva2LockDevice();

    do {
        hr = m_decoder->BeginFrame(m_surfaces[surface_id], NULL);
        Sleep(1);
    } while (hr == E_PENDING);

    FRAME_INFO info;
    info.sps = sps;
    info.pps = pps;
    info.slice = slice;
    info.btNalRefIdc = nalu_data[0][0] >> 5;
    info.NalUnitType = (NAL_UNIT_TYPE)(nalu_data[0][0] & 0x1f);

    transFrameDataToDecodeParam(surface_id, sps, pps, slice, m_decode_param);
    handlePOC(surface_id, info);

    void* pBuffer = NULL;
    UINT uiSize = 0;

    /*-----------------------------------     Picture      ---------------------------------------*/
    hr = DXVA2_GET_BUFFER(m_decoder, DXVA2_PictureParametersBufferType, pBuffer, uiSize);
    if (FAILED(hr) || sizeof(DXVA_PicParams_H264) > uiSize)
    {
        return DXVA_FAIL;
    }
    memcpy(pBuffer, &m_decode_param.h264PictureParams, sizeof(DXVA_PicParams_H264));
    if (FAILED(DXVA2_FREE_BUFFER(m_decoder, DXVA2_PictureParametersBufferType)))
    {
        return DXVA_FAIL;
    }
    /*----------------------------------------------------------------------------------------------*/
    /*-----------------------------------     QuantaMatrix   ---------------------------------------*/
    hr = DXVA2_GET_BUFFER(m_decoder, DXVA2_InverseQuantizationMatrixBufferType, pBuffer, uiSize);
    if (FAILED(hr) || sizeof(DXVA_Qmatrix_H264) > uiSize)
    {
        return DXVA_FAIL;
    }
    memcpy(pBuffer, &m_decode_param.h264QuantaMatrix, sizeof(DXVA_Qmatrix_H264));
    if (FAILED(DXVA2_FREE_BUFFER(m_decoder, DXVA2_InverseQuantizationMatrixBufferType)))
    {
        return DXVA_FAIL;
    }

    /*----------------------------------------------------------------------------------------------*/
    /*-----------------------------------     BitStream   ------------------------------------------*/

    hr = DXVA2_GET_BUFFER(m_decoder, DXVA2_BitStreamDateBufferType, pBuffer, uiSize);
    UINT data_count = 0;
    for (UINT i = 0; i < nalu_len[0]; i++)
    {
        if (uiSize < data_count + nalu_len[i + 1] + sizeof(startcode))
        {
            return DXVA_FAIL;
        }
        m_decode_param.h264SliceShort[i].SliceBytesInBuffer = nalu_len[i + 1] + sizeof(startcode);
        m_decode_param.h264SliceShort[i].BSNALunitDataLocation = data_count;
        m_decode_param.h264SliceShort[i].wBadSliceChopping = 0;

        memcpy((unsigned char*)pBuffer, startcode, sizeof(startcode));
        memcpy((unsigned char*)pBuffer + sizeof(startcode), nalu_data[i], nalu_len[i + 1]);
        pBuffer = (unsigned char*)pBuffer + sizeof(startcode) + nalu_len[i + 1];
        data_count += sizeof(startcode) + nalu_len[i + 1];
    }
    UINT pd = MIN(128 - (data_count & 127), uiSize - data_count);
    memset(pBuffer, 0, pd);
    if (FAILED(DXVA2_FREE_BUFFER(m_decoder, DXVA2_BitStreamDateBufferType)))
    {
        return DXVA_FAIL;
    }

    /*----------------------------------------------------------------------------------------------*/
    /*-----------------------------------     Slices   ---------------------------------------------*/

    int slice_count = nalu_len[0];
    hr = DXVA2_GET_BUFFER(m_decoder, DXVA2_SliceControlBufferType, pBuffer, uiSize);
    if (slice_count * sizeof(DXVA_Slice_H264_Short) > uiSize)
    {
        return DXVA_FAIL;
    }
    memcpy(pBuffer, &m_decode_param.h264SliceShort, slice_count * sizeof(DXVA_Slice_H264_Short));
    if (FAILED(DXVA2_FREE_BUFFER(m_decoder, DXVA2_SliceControlBufferType)))
    {
        return DXVA_FAIL;
    }

    /*----------------------------------------------------------------------------------------------*/

    m_decode_param.bufferDesc[2].DataSize = data_count + pd;
    m_decode_param.bufferDesc[2].NumMBsInBuffer = (sps->pic_width_in_mbs_minus1 + 1) * (sps->pic_height_in_map_units_minus1 + 1);
    m_decode_param.bufferDesc[3].DataSize = slice_count * sizeof(DXVA_Slice_H264_Short);
    m_decode_param.bufferDesc[3].NumMBsInBuffer = m_decode_param.bufferDesc[2].NumMBsInBuffer;

    if (FAILED(DXVA2_EXCUTE(m_decoder, m_decode_param.executeParams)))
    {
        return DXVA_FAIL;
    }

    if (FAILED(DXVA2_END_FRAME(m_decoder)))
    {
        return DXVA_FAIL;
    }

    m_decoded.push(surface_id);

    return Dxva2DecodeManager::instance().dxva2UnlockDevice();
}
杭电羊皮卷
关注
使用FFMPEG的DXVA2解码显示H264和H265媒体流
05-13
在本主题中，我们将深入探讨如何利用FFmpeg的DXVA2（DirectX Video Acceleration 2）功能来解码并显示H264和H265媒体流。DXVA2是微软开发的一种技术，旨在利用现代图形处理单元（GPU）进行视频解码，以减轻CPU的负担...
Windows C++ 实现FFmpeg+dxva2/d3d11va解码+QT显示（减少GPU-＞CPU的拷贝）
最新发布
2403_83063732的博客
02-20 3015
实现FFmpeg+dxva2解码并直接通过GPU渲染，减少拷贝cpu带来的耗时。对一些业务当视频帧达到2K+120FPS建议采用这种渲染方式
【GPU编解码】GPU硬解码---DXVA
iteye_7202的博客
07-22 995
前面介绍利用NVIDIA公司提供的CUVID库进行视频硬解码，下面将介绍利用DXVA进行硬解码。 一、DXVA介绍 DXVA是微软公司专门定制的视频加速规范，是一种接口规范。DXVA规范制定硬件加速解码可分四级：VLD，控制BitStream；IDCT，反余弦变换；Mocomp，运动补偿，Pixel Prediction；PostProc，显示后处理。其中，VLD加速等级最高，所以...
dxva 解码视频
萧戈的专栏
09-30 7535
最近由于项目的需要，花时间研究了一下dxva。下面对dxva 的解码API 做一个简单介绍。 dxva的大致解码过程如下： 调用DXVA2CreateDirect3DDeviceManager9函数获取到IDirect3DDeviceManager9接口的一个对象。 调用 IDirect3DDeviceManager9::OpenDeviceHandle 函数获取到一个Direct3D 设备...
FFMPEG 之 DXVA2 硬解
dbyoung的Delphi专栏
01-31 2456
FFMPEG DXVA2 硬解
C++ ffmpeg+dxva2实现硬解码
van的博客
05-25 4577
0.前言 参考博客：ffmpeg实现dxva2硬件加速 下载源码：GitHub：https://github.com/Yacov-lu/ffmpeg-DXVA-decode 百度网盘：https://pan.baidu.com/s/1fFm4Ra5ka2bPJeIRig14wA?pwd=qwer 提取码：qwer 该源码下载后，将播放的视频路径（filename）修改为你自己的，便可直接运行。 1...
我们如何方便判断我们当前电脑显卡是否支持GPU硬件加速（硬解码），图解DXVA Checker详细使用方法介绍
热门推荐
学无止尽，谨言慎行！
07-02 2万+
这里推荐一个小工具——DXVA Checker（官网下载地址） 这个免费的小软件可以检测GPU支持的DXVA硬解标准，其中SD代表DVD级别的标准清晰度，HD代表1280x720级别的高清晰度，FHD就是1080p全高清了，QFHD则是4K级别的超高清晰度了。 先上两张图，分别对应的是我电脑两张显卡intel显卡和AMD显卡： intel显卡： AMD显卡： 下面我们来看看这个软件： 功能 该程序是一个检查 DirectX 视频加速 (DXVA) 的工具，它具有以下功能。 检查 GPU 支持的解码器设备
基于ffmpeg的dxva h264硬件解码
05-10
在"dxva2_test12_CPU"这个测试文件中，很可能是为了演示如何在FFmpeg中启用DXVA2硬件加速来解码H.264视频。测试可能包括以下几个关键步骤： 1. 初始化：首先，FFmpeg需要检测系统中是否存在支持DXVA2的设备，并获取...
高清视频相关知识和 KMPlayer 硬解码(DXVA)设置.docx
02-03
3. DXVA（DirectX Video Acceleration）是微软推出的一个视频硬件加速技术，允许播放器调用计算机的硬件来解码视频。 4. 为了正确地播放高清媒体，需要设置 KMPlayer 的硬解码选项，选择正确的解码器和解码模式。 ...
H.264解码 DXVA 实现
11-22
图形图像开发 H.264硬件解码 本规范定义了DirectX® Video Acceleration (DXVA) 的扩展，以支持H.264/AVC视频的解码。
终极解码(最后一次更新版本).rar
03-31
终极解码(最后一次更新版本) FinalCodecs MD5: FinalCodecs2018sp.exe 7a1950b2377...- PotPlayer 内置解码器HEVC/H265与AVC1/H264同步切换，包括默认软解、DXVA、CUDA、QS。 3. 解码器 - 更新LAVFilters 0.70.2
高清视频相关知识和、KMPlayer 硬解码（DXVA）设置、Z520+US15W+GMA500硬解码测试
tkp2014的专栏
12-31 7096
“高清”，就是高清晰度，是相对于“标清”（即标准清晰度）而言的，主要是指高清晰度的视频媒体，高清技术的发展，越来越多的人接触到高清，现在网络上是铺天盖地的高清视频资源，高清电视、高清电影、高清 MTV 等等。 　　高源媒体的解码过程是怎么样的？如何才能在电脑上正确地播放高清媒体？什么是硬解，硬解有什么要求？如何设置才能调用硬解？以下文字将用最简单的语言，和较少的转业术语作出说明。
使用DXVA + EVR 硬解播放高清视频
hunterzy38的专栏
03-13 5778
最近给Intel做D2700的NVR方案，要求在该CPU上实现DXVA的硬解码，指标是硬解2路1080P30实时H264视频。这是第一次使用DSHOW，有一些心得，记录下来，与大家共享。 中间过程省略，直接写结果。最终方案为 1080p高清相机的实时souce filter + flv splitter + ffdshow  dxva video decoder + evr. 下面是我写的一个
dxva2+ffmpeg硬件解码（Windows）终结发布
xjb2006的专栏
11-20 1117
这个其实不算什么特点，单独列出来，只是有些初学开发者不知道avformat_open_input的URL路径的字符编码，很多人以为是ansi码，在中文系统下的中文字符没问题，但是你遇到日语，韩语，越南语等其他小语种路径时，却打开失败！由于avformat_open_input是同步方式打开URL的模式，所以打开前只能死等，由于没找到异步打开的方式，只能自己实现，其实原理不难，就是创建一个打开URL的线程，每隔1秒判断是否在打开状态，如果不是就尝试打开，一个死循环即可。m_bOpened)//没打开就打开。
dxva2+ffmpeg硬件解码（Windows）重要笔记2
xjb2006的专栏
07-18 9256
参考了csdn上Win32Project1_ffmpeg_dxva2这个例子，很不错，直接就可以运行。 但是，有几个问题： 1、窗口无法正常缩放，缩放后，图像大小并没有一起缩放 2、H265的编码格式，显示下面有一块绿色。 3、无法从显卡获取YUV420P数据或者NV12数据 3、找了很久网上也没有相关代码实现从显卡获取数据到内存（有些方法相当慢，基本无法使用！） 第2个问题，看...
【硬件解码系列】之DXVA2
walkingMa的专栏
02-10 6522
参考网址：https://blog.csdn.net/xiaoyafang123/article/details/82905452
DXVA(DirectX 视频加速)
尚钦
08-10 3438
DXVA是DirectX Video Acceleration的简称，中文译为视频硬件加速。DXVA是微软公司专门定制的视频加速规范，它共有两个版本，分别是DXVA 1.0和DXVA 2.0。DXVA规范不仅仅是在视频播放过程中的解码计算规范，其还有与视频后期处理息息相关，例如反
Qt之dxva2硬解码
草上爬的博客
04-22 6466
先来看看硬件加速API在各系统和硬解环境的支持情况，如下表所示： 从表中可以看出，虽然DXVA2硬件加速仅适用于Windows，但它支持所有主流的GPU硬件厂商，因此在Windows上实现DXVA2硬解很有必要。 ffmpeg原生支持DXVA2硬解，但是解码后数据必须先从现存拷贝到内存，才能做渲染，这里实现DXVA2解码后，显存数据直接用D3D9渲染。 一.效果 下图是DXVA2解码后，显存数据直接用D3D9渲染后的效果和CPU占用情况。 测试视频：盛世中华（封装格式webm，分辨率4K） CPU：In
打开DXVA(显卡硬解码H.264与VC-1)已如此简单
CYWATER2000'S BLOG
10-12 9748
  打开DXVA(显卡硬解码H.264与VC-1)已如此简单 作者：cywater2000日期：2008-10-12 很久以前，我曾经研究过如何打开显卡的硬解码功能(H.264,VC-1)。找来的资料一堆一堆，试装的软件诸如CyberLink，PowerDVD，NVIDIA PureVideo Decoder等等，设置来设置去，浪费不少时间。而且最后感觉显示效果没有软解的好
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值