/* * Direct3D 12 HW acceleration video decoder * * copyright (c) 2022-2023 Wu Jianhua <toqsxw@outlook.com> * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include <string.h>#include <initguid.h> #include "libavutil/common.h"#include "libavutil/log.h"#include "libavutil/mem.h"#include "libavutil/time.h"#include "libavutil/imgutils.h"#include "libavutil/hwcontext_d3d12va_internal.h"#include "libavutil/hwcontext_d3d12va.h"#include "avcodec.h"#include "decode.h"#include "d3d12va_decode.h"#include "dxva2_internal.h" typedef struct HelperObjects {    ID3D12CommandAllocator *command_allocator;    ID3D12Resource *buffer;    uint64_t fence_value;} HelperObjects; int ff_d3d12va_get_suitable_max_bitstream_size(AVCodecContext *avctx){    AVHWFramesContext *frames_ctx = D3D12VA_FRAMES_CONTEXT(avctx);    return av_image_get_buffer_size(frames_ctx->sw_format, avctx->coded_width, avctx->coded_height, 1);} unsigned ff_d3d12va_get_surface_index(const AVCodecContext *avctx,                                      D3D12VADecodeContext *ctx, const AVFrame *frame,                                      int curr){    AVD3D12VAFrame *f;    ID3D12Resource *res;    unsigned i;     f = (AVD3D12VAFrame *)frame->data[0];    if (!f)        goto fail;     res = f->texture;    if (!res)        goto fail;     for (i = 0; i < ctx->max_num_ref; i++) {        if (ctx->ref_resources[i] && res == ctx->ref_resources[i]) {            ctx->used_mask |= 1 << i;            return i;        }    }     if (curr) {        for (i = 0; i < ctx->max_num_ref; i++) {            if (!((ctx->used_mask >> i) & 0x1)) {                ctx->ref_resources[i] = res;                return i;            }        }    } fail:    av_log((AVCodecContext *)avctx, AV_LOG_WARNING, "Could not get surface index. Using 0 instead.\n");    return 0;} static int d3d12va_get_valid_helper_objects(AVCodecContext *avctx, ID3D12CommandAllocator **ppAllocator,                                            ID3D12Resource **ppBuffer){    HRESULT hr;    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);    HelperObjects obj = { 0 };    D3D12_HEAP_PROPERTIES heap_props = { .Type = D3D12_HEAP_TYPE_UPLOAD };     D3D12_RESOURCE_DESC desc = {        .Dimension        = D3D12_RESOURCE_DIMENSION_BUFFER,        .Alignment        = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,        .Width            = ctx->bitstream_size,        .Height           = 1,        .DepthOrArraySize = 1,        .MipLevels        = 1,        .Format           = DXGI_FORMAT_UNKNOWN,        .SampleDesc       = { .Count = 1, .Quality = 0 },        .Layout           = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,        .Flags            = D3D12_RESOURCE_FLAG_NONE,    };     if (av_fifo_peek(ctx->objects_queue, &obj, 1, 0) >= 0) {        uint64_t completion = ID3D12Fence_GetCompletedValue(ctx->sync_ctx.fence);        if (completion >= obj.fence_value) {            *ppAllocator = obj.command_allocator;            *ppBuffer    = obj.buffer;            av_fifo_read(ctx->objects_queue, &obj, 1);            return 0;        }    }     hr = ID3D12Device_CreateCommandAllocator(ctx->device_ctx->device, D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE,                                             &IID_ID3D12CommandAllocator, (void **)ppAllocator);    if (FAILED(hr)) {        av_log(avctx, AV_LOG_ERROR, "Failed to create a new command allocator!\n");        return AVERROR(EINVAL);    }     hr = ID3D12Device_CreateCommittedResource(ctx->device_ctx->device, &heap_props, D3D12_HEAP_FLAG_NONE,                                              &desc, D3D12_RESOURCE_STATE_GENERIC_READ, NULL,                                              &IID_ID3D12Resource, (void **)ppBuffer);     if (FAILED(hr)) {        av_log(avctx, AV_LOG_ERROR, "Failed to create a new d3d12 buffer!\n");        return AVERROR(EINVAL);    }     return 0;} static int d3d12va_discard_helper_objects(AVCodecContext *avctx, ID3D12CommandAllocator *pAllocator,                                          ID3D12Resource *pBuffer, uint64_t fence_value){    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);     HelperObjects obj = {        .command_allocator = pAllocator,        .buffer            = pBuffer,        .fence_value       = fence_value,    };     if (av_fifo_write(ctx->objects_queue, &obj, 1) < 0) {        D3D12_OBJECT_RELEASE(pAllocator);        D3D12_OBJECT_RELEASE(pBuffer);        return AVERROR(ENOMEM);    }     return 0;} static int d3d12va_fence_completion(AVD3D12VASyncContext *psync_ctx){    uint64_t completion = ID3D12Fence_GetCompletedValue(psync_ctx->fence);    if (completion < psync_ctx->fence_value) {        if (FAILED(ID3D12Fence_SetEventOnCompletion(psync_ctx->fence, psync_ctx->fence_value, psync_ctx->event)))            return AVERROR(EINVAL);         WaitForSingleObjectEx(psync_ctx->event, INFINITE, FALSE);    }     return 0;} static void bufref_free_interface(void *opaque, uint8_t *data){    D3D12_OBJECT_RELEASE(opaque);} static AVBufferRef *bufref_wrap_interface(IUnknown *iface){    return av_buffer_create((uint8_t*)iface, 1, bufref_free_interface, iface, 0);} static int d3d12va_sync_with_gpu(AVCodecContext *avctx){    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);     DX_CHECK(ID3D12CommandQueue_Signal(ctx->command_queue, ctx->sync_ctx.fence, ++ctx->sync_ctx.fence_value));    return d3d12va_fence_completion(&ctx->sync_ctx); fail:    return AVERROR(EINVAL);} static int d3d12va_create_decoder_heap(AVCodecContext *avctx){    D3D12VADecodeContext   *ctx          = D3D12VA_DECODE_CONTEXT(avctx);    AVHWFramesContext      *frames_ctx   = D3D12VA_FRAMES_CONTEXT(avctx);    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx;    AVD3D12VAFramesContext *frames_hwctx = frames_ctx->hwctx;     D3D12_VIDEO_DECODER_HEAP_DESC desc = {        .NodeMask      = 0,        .Configuration = ctx->cfg,        .DecodeWidth   = frames_ctx->width,        .DecodeHeight  = frames_ctx->height,        .Format        = frames_hwctx->format,        .FrameRate     = { avctx->framerate.num, avctx->framerate.den },        .BitRate       = avctx->bit_rate,        .MaxDecodePictureBufferCount = ctx->max_num_ref,    };     DX_CHECK(ID3D12VideoDevice_CreateVideoDecoderHeap(device_hwctx->video_device, &desc,             &IID_ID3D12VideoDecoderHeap, (void **)&ctx->decoder_heap));     return 0; fail:    if (ctx->decoder) {        av_log(avctx, AV_LOG_ERROR, "D3D12 doesn't support decoding frames with an extent "            "[width(%d), height(%d)], on your device!\n", frames_ctx->width, frames_ctx->height);    }     return AVERROR(EINVAL);} static int d3d12va_create_decoder(AVCodecContext *avctx){    D3D12_VIDEO_DECODER_DESC desc;    D3D12VADecodeContext   *ctx          = D3D12VA_DECODE_CONTEXT(avctx);    AVHWFramesContext      *frames_ctx   = D3D12VA_FRAMES_CONTEXT(avctx);    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx;    AVD3D12VAFramesContext *frames_hwctx = frames_ctx->hwctx;     D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT feature = {        .NodeIndex     = 0,        .Configuration = ctx->cfg,        .Width         = frames_ctx->width,        .Height        = frames_ctx->height,        .DecodeFormat  = frames_hwctx->format,        .FrameRate     = { avctx->framerate.num, avctx->framerate.den },        .BitRate       = avctx->bit_rate,    };     DX_CHECK(ID3D12VideoDevice_CheckFeatureSupport(device_hwctx->video_device, D3D12_FEATURE_VIDEO_DECODE_SUPPORT,                                                   &feature, sizeof(feature)));    if (!(feature.SupportFlags & D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED)) {        av_log(avctx, AV_LOG_ERROR, "D3D12 video decode is not supported on this device.\n");        return AVERROR(ENOSYS);    }    if (!(feature.DecodeTier >= D3D12_VIDEO_DECODE_TIER_2)) {        av_log(avctx, AV_LOG_ERROR, "D3D12 video decode on this device requires tier %d support, "               "but it is not implemented.\n", feature.DecodeTier);        return AVERROR_PATCHWELCOME;    }     desc = (D3D12_VIDEO_DECODER_DESC) {        .NodeMask = 0,        .Configuration = ctx->cfg,    };     DX_CHECK(ID3D12VideoDevice_CreateVideoDecoder(device_hwctx->video_device, &desc, &IID_ID3D12VideoDecoder,                                                  (void **)&ctx->decoder));     ctx->decoder_ref = bufref_wrap_interface((IUnknown *)ctx->decoder);    if (!ctx->decoder_ref)        return AVERROR(ENOMEM);     return 0; fail:    return AVERROR(EINVAL);} int ff_d3d12va_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx){    AVHWFramesContext *frames_ctx = (AVHWFramesContext *)hw_frames_ctx->data;     frames_ctx->format    = AV_PIX_FMT_D3D12;    frames_ctx->sw_format = avctx->sw_pix_fmt == AV_PIX_FMT_YUV420P10 ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12;    frames_ctx->width     = avctx->width;    frames_ctx->height    = avctx->height;     return 0;} int ff_d3d12va_decode_init(AVCodecContext *avctx){    int ret;    AVHWFramesContext *frames_ctx;    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);    ID3D12Resource *buffer = NULL;    ID3D12CommandAllocator *command_allocator = NULL;    D3D12_COMMAND_QUEUE_DESC queue_desc = {        .Type     = D3D12_COMMAND_LIST_TYPE_VIDEO_DECODE,        .Priority = 0,        .Flags    = D3D12_COMMAND_QUEUE_FLAG_NONE,        .NodeMask = 0,    };     ctx->pix_fmt = avctx->hwaccel->pix_fmt;     ret = ff_decode_get_hw_frames_ctx(avctx, AV_HWDEVICE_TYPE_D3D12VA);    if (ret < 0)        return ret;     frames_ctx = D3D12VA_FRAMES_CONTEXT(avctx);    ctx->device_ctx = (AVD3D12VADeviceContext *)frames_ctx->device_ctx->hwctx;     if (frames_ctx->format != ctx->pix_fmt) {        av_log(avctx, AV_LOG_ERROR, "Invalid pixfmt for hwaccel!\n");        goto fail;    }     ret = d3d12va_create_decoder(avctx);    if (ret < 0)        goto fail;     ret = d3d12va_create_decoder_heap(avctx);    if (ret < 0)        goto fail;     ctx->bitstream_size = ff_d3d12va_get_suitable_max_bitstream_size(avctx);     ctx->ref_resources = av_calloc(ctx->max_num_ref, sizeof(*ctx->ref_resources));    if (!ctx->ref_resources)        return AVERROR(ENOMEM);     ctx->ref_subresources = av_calloc(ctx->max_num_ref, sizeof(*ctx->ref_subresources));    if (!ctx->ref_subresources)        return AVERROR(ENOMEM);     ctx->objects_queue = av_fifo_alloc2(D3D12VA_VIDEO_DEC_ASYNC_DEPTH,                                        sizeof(HelperObjects), AV_FIFO_FLAG_AUTO_GROW);    if (!ctx->objects_queue)        return AVERROR(ENOMEM);     DX_CHECK(ID3D12Device_CreateFence(ctx->device_ctx->device, 0, D3D12_FENCE_FLAG_NONE,                                      &IID_ID3D12Fence, (void **)&ctx->sync_ctx.fence));     ctx->sync_ctx.event = CreateEvent(NULL, FALSE, FALSE, NULL);    if (!ctx->sync_ctx.event)        goto fail;     ret = d3d12va_get_valid_helper_objects(avctx, &command_allocator, &buffer);    if (ret < 0)        goto fail;     DX_CHECK(ID3D12Device_CreateCommandQueue(ctx->device_ctx->device, &queue_desc,             &IID_ID3D12CommandQueue, (void **)&ctx->command_queue));     DX_CHECK(ID3D12Device_CreateCommandList(ctx->device_ctx->device, 0, queue_desc.Type,             command_allocator, NULL, &IID_ID3D12CommandList, (void **)&ctx->command_list));     DX_CHECK(ID3D12VideoDecodeCommandList_Close(ctx->command_list));     ID3D12CommandQueue_ExecuteCommandLists(ctx->command_queue, 1, (ID3D12CommandList **)&ctx->command_list);     ret = d3d12va_sync_with_gpu(avctx);    if (ret < 0)        goto fail;     d3d12va_discard_helper_objects(avctx, command_allocator, buffer, ctx->sync_ctx.fence_value);    if (ret < 0)        goto fail;     return 0; fail:    D3D12_OBJECT_RELEASE(command_allocator);    D3D12_OBJECT_RELEASE(buffer);    ff_d3d12va_decode_uninit(avctx);     return AVERROR(EINVAL);} int ff_d3d12va_decode_uninit(AVCodecContext *avctx){    int num_allocator = 0;    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);    HelperObjects obj;     if (ctx->sync_ctx.fence)        d3d12va_sync_with_gpu(avctx);     av_freep(&ctx->ref_resources);    av_freep(&ctx->ref_subresources);     D3D12_OBJECT_RELEASE(ctx->command_list);    D3D12_OBJECT_RELEASE(ctx->command_queue);     if (ctx->objects_queue) {        while (av_fifo_read(ctx->objects_queue, &obj, 1) >= 0) {            num_allocator++;            D3D12_OBJECT_RELEASE(obj.buffer);            D3D12_OBJECT_RELEASE(obj.command_allocator);        }         av_log(avctx, AV_LOG_VERBOSE, "Total number of command allocators reused: %d\n", num_allocator);    }     av_fifo_freep2(&ctx->objects_queue);     D3D12_OBJECT_RELEASE(ctx->sync_ctx.fence);    if (ctx->sync_ctx.event)        CloseHandle(ctx->sync_ctx.event);     D3D12_OBJECT_RELEASE(ctx->decoder_heap);     av_buffer_unref(&ctx->decoder_ref);     return 0;} static inline int d3d12va_update_reference_frames_state(AVCodecContext *avctx, D3D12_RESOURCE_BARRIER *barriers,                                                        ID3D12Resource *current_resource, int state_before, int state_end){    D3D12VADecodeContext *ctx = D3D12VA_DECODE_CONTEXT(avctx);     int num_barrier = 0;    for (int i = 0; i < ctx->max_num_ref; i++) {        if (((ctx->used_mask >> i) & 0x1) && ctx->ref_resources[i] && ctx->ref_resources[i] != current_resource) {            barriers[num_barrier].Type  = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;            barriers[num_barrier].Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;            barriers[num_barrier].Transition = (D3D12_RESOURCE_TRANSITION_BARRIER){                .pResource   = ctx->ref_resources[i],                .Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,                .StateBefore = state_before,                .StateAfter  = state_end,            };            num_barrier++;        }    }     return num_barrier;} int ff_d3d12va_common_end_frame(AVCodecContext *avctx, AVFrame *frame,                              const void *pp, unsigned pp_size,                              const void *qm, unsigned qm_size,                              int(*update_input_arguments)(AVCodecContext *, D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *, ID3D12Resource *)){    int ret;    D3D12VADecodeContext   *ctx               = D3D12VA_DECODE_CONTEXT(avctx);    ID3D12Resource         *buffer            = NULL;    ID3D12CommandAllocator *command_allocator = NULL;    AVD3D12VAFrame         *f                 = (AVD3D12VAFrame *)frame->data[0];    ID3D12Resource         *resource          = (ID3D12Resource *)f->texture;     ID3D12VideoDecodeCommandList *cmd_list = ctx->command_list;    D3D12_RESOURCE_BARRIER barriers[32] = { 0 };     D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS input_args = {        .NumFrameArguments = 2,        .FrameArguments = {            [0] = {                .Type  = D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS,                .Size  = pp_size,                .pData = (void *)pp,            },            [1] = {                .Type  = D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX,                .Size  = qm_size,                .pData = (void *)qm,            },        },        .pHeap = ctx->decoder_heap,    };     D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS output_args = {        .ConversionArguments = { 0 },        .OutputSubresource   = 0,        .pOutputTexture2D    = resource,    };     UINT num_barrier = 1;    barriers[0] = (D3D12_RESOURCE_BARRIER) {        .Type  = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,        .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,        .Transition = {            .pResource   = resource,            .Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,            .StateBefore = D3D12_RESOURCE_STATE_COMMON,            .StateAfter  = D3D12_RESOURCE_STATE_VIDEO_DECODE_WRITE,        },    };     memset(ctx->ref_subresources, 0, sizeof(UINT) * ctx->max_num_ref);    input_args.ReferenceFrames.NumTexture2Ds = ctx->max_num_ref;    input_args.ReferenceFrames.ppTexture2Ds  = ctx->ref_resources;    input_args.ReferenceFrames.pSubresources = ctx->ref_subresources;     ret = d3d12va_fence_completion(&f->sync_ctx);    if (ret < 0)        goto fail;     if (!qm)        input_args.NumFrameArguments = 1;     ret = d3d12va_get_valid_helper_objects(avctx, &command_allocator, &buffer);    if (ret < 0)        goto fail;     ret = update_input_arguments(avctx, &input_args, buffer);

Lines 1–500 of 537. Load more