Criando um processador de vídeo DXVA-HD

Artigo
06/13/2023

A DXVA-HD (Alta Definição de Aceleração de Vídeo) do Microsoft DirectX usa duas interfaces principais:

IDXVAHD_Device. Representa o dispositivo DXVA-HD. Use essa interface para consultar os recursos do dispositivo e criar o processador de vídeo.
IDXVAHD_VideoProcessor. Representa um conjunto de recursos de processamento de vídeo. Use essa interface para executar o blit de processamento de vídeo.

No código a seguir, as seguintes variáveis globais são assumidas:

IDirect3D9Ex            *g_pD3D = NULL;     
IDirect3DDevice9Ex      *g_pD3DDevice = NULL;   // Direct3D device.
IDXVAHD_Device          *g_pDXVAHD = NULL;      // DXVA-HD device.
IDXVAHD_VideoProcessor  *g_pDXVAVP = NULL;      // DXVA-HD video processor.
IDirect3DSurface9       *g_pSurface = NULL;     // Video surface.
        
const D3DFORMAT     RENDER_TARGET_FORMAT = D3DFMT_X8R8G8B8;
const D3DFORMAT     VIDEO_FORMAT         = D3DFMT_X8R8G8B8; 
const UINT          VIDEO_FPS            = 60;
const UINT          VIDEO_WIDTH          = 640;
const UINT          VIDEO_HEIGHT         = 480;

Para criar um processador de vídeo DXVA-HD:

Preencha uma estrutura DXVAHD_CONTENT_DESC com uma descrição do conteúdo do vídeo. O driver usa essas informações como uma dica para otimizar os recursos do processador de vídeo. A estrutura não contém uma descrição de formato completa.

    DXVAHD_RATIONAL fps = { VIDEO_FPS, 1 }; 

    DXVAHD_CONTENT_DESC desc;

    desc.InputFrameFormat = DXVAHD_FRAME_FORMAT_PROGRESSIVE;
    desc.InputFrameRate = fps;
    desc.InputWidth = VIDEO_WIDTH;
    desc.InputHeight = VIDEO_HEIGHT;
    desc.OutputFrameRate = fps;
    desc.OutputWidth = VIDEO_WIDTH;
    desc.OutputHeight = VIDEO_HEIGHT;

Chame DXVAHD_CreateDevice para criar o dispositivo DXVA-HD. Essa função retorna um ponteiro para a interface IDXVAHD_Device .
```
    hr = DXVAHD_CreateDevice(g_pD3DDevice, &desc, DXVAHD_DEVICE_USAGE_PLAYBACK_NORMAL,
        NULL, &pDXVAHD);
```
Chame IDXVAHD_Device::GetVideoProcessorDeviceCaps. Esse método preenche uma estrutura DXVAHD_VPDEVCAPS com os recursos do dispositivo. Se você precisar de recursos específicos de processamento de vídeo, como chave luma ou filtragem de imagens, marcar sua disponibilidade usando essa estrutura.
```
    DXVAHD_VPDEVCAPS caps;

    hr = pDXVAHD->GetVideoProcessorDeviceCaps(&caps);
```
Verifique se o dispositivo DXVA-HD dá suporte aos formatos de vídeo de entrada necessários. O tópico Verificando formatos DXVA-HD com suporte descreve esta etapa com mais detalhes.
Verifique se o dispositivo DXVA-HD dá suporte ao formato de saída necessário. A seção Verificando formatos DXVA-HD com suporte descreve esta etapa com mais detalhes.

Alocar uma matriz de estruturas de DXVAHD_VPCAPS . O número de elementos de matriz que devem ser alocados é fornecido pelo membro VideoProcessorCount da estrutura DXVAHD_VPDEVCAPS , obtido na etapa 3.

    // Create the array of video processor caps. 

    DXVAHD_VPCAPS *pVPCaps = 
        new (std::nothrow) DXVAHD_VPCAPS[ caps.VideoProcessorCount ];

    if (pVPCaps == NULL)
    {
        return E_OUTOFMEMORY;
    }

Cada estrutura DXVAHD_VPCAPS representa um processador de vídeo distinto. Você pode executar um loop por essa matriz para descobrir os recursos de cada processador de vídeo. A estrutura inclui informações sobre os recursos de interação, telecine e conversão de taxa de quadros do processador de vídeo.
Selecione um processador de vídeo para criar. O membro VPGuid da estrutura DXVAHD_VPCAPS contém um GUID que identifica exclusivamente o processador de vídeo. Passe esse GUID para o método IDXVAHD_Device::CreateVideoProcessor . O método retorna um ponteiro IDXVAHD_VideoProcessor .
```
    HRESULT hr = pDXVAHD->GetVideoProcessorCaps(
        caps.VideoProcessorCount, pVPCaps);
```
Opcionalmente, chame IDXVAHD_Device::CreateVideoSurface para criar uma matriz de superfícies de vídeo de entrada.

O exemplo de código a seguir mostra a sequência completa de etapas:

// Initializes the DXVA-HD video processor.

// NOTE: The following example makes some simplifying assumptions:
//
// 1. There is a single input stream.
// 2. The input frame rate matches the output frame rate.
// 3. No advanced DXVA-HD features are needed, such as luma keying or IVTC.
// 4. The application uses a single input video surface.

HRESULT InitializeDXVAHD()
{
    if (g_pD3DDevice == NULL)
    {
        return E_FAIL;
    }

    HRESULT hr = S_OK;

    IDXVAHD_Device          *pDXVAHD = NULL;
    IDXVAHD_VideoProcessor  *pDXVAVP = NULL;
    IDirect3DSurface9       *pSurf = NULL;

    DXVAHD_RATIONAL fps = { VIDEO_FPS, 1 }; 

    DXVAHD_CONTENT_DESC desc;

    desc.InputFrameFormat = DXVAHD_FRAME_FORMAT_PROGRESSIVE;
    desc.InputFrameRate = fps;
    desc.InputWidth = VIDEO_WIDTH;
    desc.InputHeight = VIDEO_HEIGHT;
    desc.OutputFrameRate = fps;
    desc.OutputWidth = VIDEO_WIDTH;
    desc.OutputHeight = VIDEO_HEIGHT;

#ifdef USE_SOFTWARE_PLUGIN    
    HMODULE hSWPlugin = LoadLibrary(L"C:\\dxvahdsw.dll");

    PDXVAHDSW_Plugin pSWPlugin = (PDXVAHDSW_Plugin)GetProcAddress(hSWPlugin, "DXVAHDSW_Plugin");

    hr = DXVAHD_CreateDevice(g_pD3DDevice, &desc,DXVAHD_DEVICE_USAGE_PLAYBACK_NORMAL,
        pSWPlugin, &pDXVAHD);
#else
    hr = DXVAHD_CreateDevice(g_pD3DDevice, &desc, DXVAHD_DEVICE_USAGE_PLAYBACK_NORMAL,
        NULL, &pDXVAHD);
#endif
    if (FAILED(hr))
    {
        goto done;
    }

    DXVAHD_VPDEVCAPS caps;

    hr = pDXVAHD->GetVideoProcessorDeviceCaps(&caps);
    if (FAILED(hr))
    {
        goto done;
    }

    // Check whether the device supports the input and output formats.

    hr = CheckInputFormatSupport(pDXVAHD, caps, VIDEO_FORMAT);
    if (FAILED(hr))
    {
        goto done;
    }

    hr = CheckOutputFormatSupport(pDXVAHD, caps, RENDER_TARGET_FORMAT);
    if (FAILED(hr))
    {
        goto done;
    }

    // Create the VP device.
    hr = CreateVPDevice(pDXVAHD, caps, &pDXVAVP);
    if (FAILED(hr))
    {
        goto done;
    }

    // Create the video surface for the primary video stream.
    hr = pDXVAHD->CreateVideoSurface(
        VIDEO_WIDTH,
        VIDEO_HEIGHT,
        VIDEO_FORMAT,
        caps.InputPool,
        0,  // Usage
        DXVAHD_SURFACE_TYPE_VIDEO_INPUT,
        1,      // Number of surfaces to create
        &pSurf, // Array of surface pointers
        NULL
        );

    if (FAILED(hr))
    {
        goto done;
    }


    g_pDXVAHD = pDXVAHD;
    g_pDXVAHD->AddRef();

    g_pDXVAVP = pDXVAVP;
    g_pDXVAVP->AddRef();

    g_pSurface = pSurf;
    g_pSurface->AddRef();

done:
    SafeRelease(&pDXVAHD);
    SafeRelease(&pDXVAVP);
    SafeRelease(&pSurf);
    return hr;
}

A função CreateVPDevice mostrada neste exemplo cria o processador de vídeo (etapas 5 a 7):

// Creates a DXVA-HD video processor.

HRESULT CreateVPDevice(
    IDXVAHD_Device          *pDXVAHD,
    const DXVAHD_VPDEVCAPS& caps,
    IDXVAHD_VideoProcessor  **ppDXVAVP
    )
{
    // Create the array of video processor caps. 
    
    DXVAHD_VPCAPS *pVPCaps = 
        new (std::nothrow) DXVAHD_VPCAPS[ caps.VideoProcessorCount ];

    if (pVPCaps == NULL)
    {
        return E_OUTOFMEMORY;
    }

    HRESULT hr = pDXVAHD->GetVideoProcessorCaps(
        caps.VideoProcessorCount, pVPCaps);

    // At this point, an application could loop through the array and examine
    // the capabilities. For purposes of this example, however, we simply
    // create the first video processor in the list.

    if (SUCCEEDED(hr))
    {
        // The VPGuid member contains the GUID that identifies the video 
        // processor.

        hr = pDXVAHD->CreateVideoProcessor(&pVPCaps[0].VPGuid, ppDXVAVP);
    }

    delete [] pVPCaps;
    return hr;
}

DXVA-HD

Partilhar via

Criando um processador de vídeo DXVA-HD

Comentários

Recursos adicionais

Partilhar via

Criando um processador de vídeo DXVA-HD

Tópicos relacionados

Comentários

Recursos adicionais