[FFmpeg-devel,v5,1/9] libavutil: add hwcontext_d3d12va and AV_PIX_FMT_D3D12

From: Wu Jianhua <toqsxw@outlook.com>

Signed-off-by: Wu Jianhua <toqsxw@outlook.com>
Signed-off-by: Tong Wu <tong1.wu@intel.com>
---
 configure                              |   5 +
 doc/APIchanges                         |   7 +
 libavutil/Makefile                     |   3 +
 libavutil/hwcontext.c                  |   4 +
 libavutil/hwcontext.h                  |   1 +
 libavutil/hwcontext_d3d12va.c          | 703 +++++++++++++++++++++++++
 libavutil/hwcontext_d3d12va.h          | 169 ++++++
 libavutil/hwcontext_d3d12va_internal.h |  59 +++
 libavutil/hwcontext_internal.h         |   1 +
 libavutil/pixdesc.c                    |   4 +
 libavutil/pixfmt.h                     |   9 +
 libavutil/tests/hwdevice.c             |   2 +
 libavutil/version.h                    |   2 +-
 13 files changed, 968 insertions(+), 1 deletion(-)
 create mode 100644 libavutil/hwcontext_d3d12va.c
 create mode 100644 libavutil/hwcontext_d3d12va.h
 create mode 100644 libavutil/hwcontext_d3d12va_internal.h

Aug 4, 2023, 15:50 by tong1.wu-at-intel.com@ffmpeg.org:

> From: Wu Jianhua <toqsxw@outlook.com>
>
> Signed-off-by: Wu Jianhua <toqsxw@outlook.com>
> Signed-off-by: Tong Wu <tong1.wu@intel.com>
> ---
>  configure                              |   5 +
>  doc/APIchanges                         |   7 +
>  libavutil/Makefile                     |   3 +
>  libavutil/hwcontext.c                  |   4 +
>  libavutil/hwcontext.h                  |   1 +
>  libavutil/hwcontext_d3d12va.c          | 703 +++++++++++++++++++++++++
>  libavutil/hwcontext_d3d12va.h          | 169 ++++++
>  libavutil/hwcontext_d3d12va_internal.h |  59 +++
>  libavutil/hwcontext_internal.h         |   1 +
>  libavutil/pixdesc.c                    |   4 +
>  libavutil/pixfmt.h                     |   9 +
>  libavutil/tests/hwdevice.c             |   2 +
>  libavutil/version.h                    |   2 +-
>  13 files changed, 968 insertions(+), 1 deletion(-)
>  create mode 100644 libavutil/hwcontext_d3d12va.c
>  create mode 100644 libavutil/hwcontext_d3d12va.h
>  create mode 100644 libavutil/hwcontext_d3d12va_internal.h
>
> diff --git a/configure b/configure
> index 99388e7664..9919551ad0 100755
> --- a/configure
> +++ b/configure
> @@ -338,6 +338,7 @@ External library support:
>  --disable-cuda-llvm      disable CUDA compilation using clang [autodetect]
>  --disable-cuvid          disable Nvidia CUVID support [autodetect]
>  --disable-d3d11va        disable Microsoft Direct3D 11 video acceleration code [autodetect]
> +  --disable-d3d12va        disable Microsoft Direct3D 12 video acceleration code [autodetect]
>  --disable-dxva2          disable Microsoft DirectX 9 video acceleration code [autodetect]
>  --disable-ffnvcodec      disable dynamically linked Nvidia code [autodetect]
>  --enable-libdrm          enable DRM code (Linux) [no]
> @@ -1926,6 +1927,7 @@ HWACCEL_AUTODETECT_LIBRARY_LIST="
>  cuda_llvm
>  cuvid
>  d3d11va
> +    d3d12va
>  dxva2
>  ffnvcodec
>  nvdec
> @@ -3053,6 +3055,7 @@ crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
>  cuda_deps="ffnvcodec"
>  cuvid_deps="ffnvcodec"
>  d3d11va_deps="dxva_h ID3D11VideoDecoder ID3D11VideoContext"
> +d3d12va_deps="dxva_h ID3D12Device ID3D12VideoDecoder"
>  dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32 user32"
>  ffnvcodec_deps_any="libdl LoadLibrary"
>  mediacodec_deps="android"
> @@ -6543,6 +6546,8 @@ check_type "windows.h dxgi1_2.h" "IDXGIOutput1"
>  check_type "windows.h dxgi1_5.h" "IDXGIOutput5"
>  check_type "windows.h d3d11.h" "ID3D11VideoDecoder"
>  check_type "windows.h d3d11.h" "ID3D11VideoContext"
> +check_type "windows.h d3d12.h" "ID3D12Device"
> +check_type "windows.h d3d12video.h" "ID3D12VideoDecoder"
>  check_type "windows.h" "DPI_AWARENESS_CONTEXT" -D_WIN32_WINNT=0x0A00
>  check_type "d3d9.h dxva2api.h" DXVA2_ConfigPictureDecode -D_WIN32_WINNT=0x0602
>  check_func_headers mfapi.h MFCreateAlignedMemoryBuffer -lmfplat
> diff --git a/doc/APIchanges b/doc/APIchanges
> index 5afe8bcb75..c14ab0b394 100644
> --- a/doc/APIchanges
> +++ b/doc/APIchanges
> @@ -2,6 +2,13 @@ The last version increases of all libraries were on 2023-02-09
>  
>  API changes, most recent first:
>  
> +2023-07-xx - xxxxxxxxxx - lavu 58.15.100 - pixfmt.h hwcontext.h hwcontext_d3d12va.h
> +  Add AV_HWDEVICE_TYPE_D3D12VA and AV_PIX_FMT_D3D12.
> +  Add AVD3D12VADeviceContext, AVD3D12VASyncContext, AVD3D12FrameDescriptor,
> +  and AVD3D12VAFramesContext.
> +  Add av_d3d12va_map_sw_to_hw_format, av_d3d12va_create_sync_context,
> +  av_d3d12va_release_sync_context, av_d3d12va_wait_idle, and av_d3d12va_wait_queue_idle.
> +
>  2023-07-xx - xxxxxxxxxx - lavc 60 - avcodec.h
>  Deprecate AV_CODEC_FLAG_DROPCHANGED without replacement.
>  
> diff --git a/libavutil/Makefile b/libavutil/Makefile
> index bd9c6f9e32..40d49d76dd 100644
> --- a/libavutil/Makefile
> +++ b/libavutil/Makefile
> @@ -41,6 +41,7 @@ HEADERS = adler32.h                                                     \
>  hwcontext.h                                                   \
>  hwcontext_cuda.h                                              \
>  hwcontext_d3d11va.h                                           \
> +          hwcontext_d3d12va.h                                           \
>  hwcontext_drm.h                                               \
>  hwcontext_dxva2.h                                             \
>  hwcontext_qsv.h                                               \
> @@ -186,6 +187,7 @@ OBJS = adler32.o                                                        \
>  
>  OBJS-$(CONFIG_CUDA)                     += hwcontext_cuda.o
>  OBJS-$(CONFIG_D3D11VA)                  += hwcontext_d3d11va.o
> +OBJS-$(CONFIG_D3D12VA)                  += hwcontext_d3d12va.o
>  OBJS-$(CONFIG_DXVA2)                    += hwcontext_dxva2.o
>  OBJS-$(CONFIG_LIBDRM)                   += hwcontext_drm.o
>  OBJS-$(CONFIG_MACOS_KPERF)              += macos_kperf.o
> @@ -209,6 +211,7 @@ SKIPHEADERS-$(HAVE_CUDA_H)             += hwcontext_cuda.h
>  SKIPHEADERS-$(CONFIG_CUDA)             += hwcontext_cuda_internal.h     \
>  cuda_check.h
>  SKIPHEADERS-$(CONFIG_D3D11VA)          += hwcontext_d3d11va.h
> +SKIPHEADERS-$(CONFIG_D3D12VA)          += hwcontext_d3d12va.h
>  SKIPHEADERS-$(CONFIG_DXVA2)            += hwcontext_dxva2.h
>  SKIPHEADERS-$(CONFIG_QSV)              += hwcontext_qsv.h
>  SKIPHEADERS-$(CONFIG_OPENCL)           += hwcontext_opencl.h
> diff --git a/libavutil/hwcontext.c b/libavutil/hwcontext.c
> index 3396598269..04070bc3c3 100644
> --- a/libavutil/hwcontext.c
> +++ b/libavutil/hwcontext.c
> @@ -36,6 +36,9 @@ static const HWContextType * const hw_table[] = {
>  #if CONFIG_D3D11VA
>  &ff_hwcontext_type_d3d11va,
>  #endif
> +#if CONFIG_D3D12VA
> +    &ff_hwcontext_type_d3d12va,
> +#endif
>  #if CONFIG_LIBDRM
>  &ff_hwcontext_type_drm,
>  #endif
> @@ -71,6 +74,7 @@ static const char *const hw_type_names[] = {
>  [AV_HWDEVICE_TYPE_DRM]    = "drm",
>  [AV_HWDEVICE_TYPE_DXVA2]  = "dxva2",
>  [AV_HWDEVICE_TYPE_D3D11VA] = "d3d11va",
> +    [AV_HWDEVICE_TYPE_D3D12VA] = "d3d12va",
>  [AV_HWDEVICE_TYPE_OPENCL] = "opencl",
>  [AV_HWDEVICE_TYPE_QSV]    = "qsv",
>  [AV_HWDEVICE_TYPE_VAAPI]  = "vaapi",
> diff --git a/libavutil/hwcontext.h b/libavutil/hwcontext.h
> index 7ff08c8608..2b33721a97 100644
> --- a/libavutil/hwcontext.h
> +++ b/libavutil/hwcontext.h
> @@ -37,6 +37,7 @@ enum AVHWDeviceType {
>  AV_HWDEVICE_TYPE_OPENCL,
>  AV_HWDEVICE_TYPE_MEDIACODEC,
>  AV_HWDEVICE_TYPE_VULKAN,
> +    AV_HWDEVICE_TYPE_D3D12VA,
>  };
>  
>  typedef struct AVHWDeviceInternal AVHWDeviceInternal;
> diff --git a/libavutil/hwcontext_d3d12va.c b/libavutil/hwcontext_d3d12va.c
> new file mode 100644
> index 0000000000..907b8a3f0b
> --- /dev/null
> +++ b/libavutil/hwcontext_d3d12va.c
> @@ -0,0 +1,703 @@
> +/*
> + * Direct3D 12 HW acceleration.
> + *
> + * 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 "config.h"
> +#include "common.h"
> +#include "hwcontext.h"
> +#include "hwcontext_internal.h"
> +#include "hwcontext_d3d12va_internal.h"
> +#include "hwcontext_d3d12va.h"
> +#include "imgutils.h"
> +#include "pixdesc.h"
> +#include "pixfmt.h"
> +#include "thread.h"
> +#include "compat/w32dlfcn.h"
> +#include <dxgi1_3.h>
> +
> +typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY2)(UINT Flags, REFIID riid, void **ppFactory);
> +
> +static AVOnce functions_loaded = AV_ONCE_INIT;
>

These shouldn't be global state. Take a look at how vulkan does it, by
having a main loader function exposed in the device context.


> +
> +static PFN_CREATE_DXGI_FACTORY2 d3d12va_create_dxgi_factory2;
> +static PFN_D3D12_CREATE_DEVICE d3d12va_create_device;
> +static PFN_D3D12_GET_DEBUG_INTERFACE d3d12va_get_debug_interface;
> +
> +static av_cold void load_functions(void)
> +{
> +#if !HAVE_UWP
> +    // We let these "leak" - this is fine, as unloading has no great benefit, and
> +    // Windows will mark a DLL as loaded forever if its internal refcount overflows
> +    // from too many LoadLibrary calls.
> +    HANDLE d3dlib, dxgilib;
> +
> +    d3dlib  = dlopen("d3d12.dll", 0);
> +    dxgilib = dlopen("dxgi.dll", 0);
> +    if (!d3dlib || !dxgilib)
> +        return;
> +
> +    d3d12va_create_device = (PFN_D3D12_CREATE_DEVICE)GetProcAddress(d3dlib, "D3D12CreateDevice");
> +    d3d12va_create_dxgi_factory2 = (PFN_CREATE_DXGI_FACTORY2)GetProcAddress(dxgilib, "CreateDXGIFactory2");
> +    d3d12va_get_debug_interface = (PFN_D3D12_GET_DEBUG_INTERFACE)GetProcAddress(d3dlib, "D3D12GetDebugInterface");
> +#else
> +    d3d12va_create_device = (PFN_D3D12_CREATE_DEVICE) D3D12CreateDevice;
> +    d3d12va_create_dxgi_factory2 = (PFN_CREATE_DXGI_FACTORY2) CreateDXGIFactory2;
> +    d3d12va_get_debug_interface = (PFN_D3D12_GET_DEBUG_INTERFACE) D3D12GetDebugInterface;
> +#endif
>

We already have dlopen code, you should use it. It prevents leaks too.
Leaks are never fine.


> +}
> +
> +typedef struct D3D12VAFramesContext {
> +    ID3D12Resource            *staging_buffer;
> +    ID3D12CommandQueue        *command_queue;
> +    ID3D12CommandAllocator    *command_allocator;
> +    ID3D12GraphicsCommandList *command_list;
> +    AVD3D12VASyncContext      *sync_ctx;
> +    int                        nb_surfaces;
> +    int                        nb_surfaces_used;
> +    DXGI_FORMAT                format;
> +    UINT                       luma_component_size;
> +} D3D12VAFramesContext;
> +
> +static const struct {
> +    DXGI_FORMAT d3d_format;
> +    enum AVPixelFormat pix_fmt;
> +} supported_formats[] = {
> +    { DXGI_FORMAT_NV12, AV_PIX_FMT_NV12 },
> +    { DXGI_FORMAT_P010, AV_PIX_FMT_P010 },
> +};
> +
> +DXGI_FORMAT av_d3d12va_map_sw_to_hw_format(enum AVPixelFormat pix_fmt)
> +{
> +    switch (pix_fmt) {
> +    case AV_PIX_FMT_NV12:return DXGI_FORMAT_NV12;
> +    case AV_PIX_FMT_P010:return DXGI_FORMAT_P010;
> +    default:             return DXGI_FORMAT_UNKNOWN;
> +    }
> +}
> +
> +int av_d3d12va_sync_context_alloc(AVD3D12VADeviceContext *ctx, AVD3D12VASyncContext **psync_ctx)
> +{
> +    AVD3D12VASyncContext *sync_ctx;
> +
> +    sync_ctx = av_mallocz(sizeof(AVD3D12VASyncContext));
> +    if (!sync_ctx)
> +        return AVERROR(ENOMEM);
> +
> +    DX_CHECK(ID3D12Device_CreateFence(ctx->device, sync_ctx->fence_value, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, &sync_ctx->fence));
> +
> +    sync_ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL);
> +    if (!sync_ctx->event)
> +        goto fail;
> +
> +    *psync_ctx = sync_ctx;
> +
> +    return 0;
> +
> +fail:
> +    D3D12_OBJECT_RELEASE(sync_ctx->fence);
> +    av_freep(&sync_ctx);
> +    return AVERROR(EINVAL);
> +}
> +
> +void av_d3d12va_sync_context_free(AVD3D12VASyncContext **psync_ctx)
> +{
> +    AVD3D12VASyncContext *sync_ctx;
> +
> +    if (!psync_ctx || !*psync_ctx)
> +        return;
> +
> +    sync_ctx = *psync_ctx;
> +
> +    av_d3d12va_wait_idle(sync_ctx);
> +
> +    D3D12_OBJECT_RELEASE(sync_ctx->fence);
> +
> +    if (sync_ctx->event)
> +        CloseHandle(sync_ctx->event);
> +
> +    av_freep(psync_ctx);
> +}
> +
> +static int av_d3d12va_wait_for_fence_value(AVD3D12VASyncContext *sync_ctx, uint64_t fence_value)
> +{
> +    uint64_t completion = ID3D12Fence_GetCompletedValue(sync_ctx->fence);
> +    if (completion < fence_value) {
> +        if (FAILED(ID3D12Fence_SetEventOnCompletion(sync_ctx->fence, fence_value, sync_ctx->event)))
> +            return AVERROR(EINVAL);
> +
> +        WaitForSingleObjectEx(sync_ctx->event, INFINITE, FALSE);
> +    }
> +
> +    return 0;
> +}
> +
> +int av_d3d12va_wait_idle(AVD3D12VASyncContext *ctx)
> +{
> +    return av_d3d12va_wait_for_fence_value(ctx, ctx->fence_value);
> +}
>

It's a one-line function. No need to have it exposed publicly.


> +
> +int av_d3d12va_wait_queue_idle(AVD3D12VASyncContext *sync_ctx, ID3D12CommandQueue *command_queue)
>

Same here. This is more utility, rather than something which absolutely
must be public API.


> +{
> +    DX_CHECK(ID3D12CommandQueue_Signal(command_queue, sync_ctx->fence, ++sync_ctx->fence_value));
> +    return av_d3d12va_wait_idle(sync_ctx);
> +
> +fail:
> +    return AVERROR(EINVAL);
> +}
> +
> +static inline int create_resource(ID3D12Device *device, const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES states, ID3D12Resource **ppResource, int is_read_back)
> +{
> +    D3D12_HEAP_PROPERTIES props = {
> +        .Type                 = is_read_back ? D3D12_HEAP_TYPE_READBACK : D3D12_HEAP_TYPE_DEFAULT,
> +        .CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
> +        .MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN,
> +        .CreationNodeMask     = 0,
> +        .VisibleNodeMask      = 0,
> +    };
> +
> +    if (FAILED(ID3D12Device_CreateCommittedResource(device, &props, D3D12_HEAP_FLAG_NONE, desc,
> +        states, NULL, &IID_ID3D12Resource, ppResource)))
> +        return AVERROR(EINVAL);
> +
> +    return 0;
> +}
> +
> +static int d3d12va_create_staging_buffer_resource(AVHWFramesContext *ctx)
> +{
> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +
> +    D3D12_RESOURCE_DESC desc = {
> +        .Dimension          = D3D12_RESOURCE_DIMENSION_BUFFER,
> +        .Alignment          = 0,
> +        .Width              = 0,
> +        .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,
> +    };
> +
> +    s->luma_component_size = FFALIGN(ctx->width * (s->format == DXGI_FORMAT_P010 ? 2 : 1), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * ctx->height;
> +    desc.Width = s->luma_component_size + (s->luma_component_size >> 1);
> +
> +    return create_resource(device_hwctx->device, &desc, D3D12_RESOURCE_STATE_COPY_DEST, &s->staging_buffer, 1);
> +}
> +
> +static int d3d12va_create_helper_objects(AVHWFramesContext *ctx)
> +{
> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +
> +    D3D12_COMMAND_QUEUE_DESC queue_desc = {
> +        .Type     = D3D12_COMMAND_LIST_TYPE_COPY,
> +        .Priority = 0,
> +        .NodeMask = 0,
> +    };
> +
> +    int ret = d3d12va_create_staging_buffer_resource(ctx);
> +    if (ret < 0)
> +        return ret;
> +
> +    ret = av_d3d12va_sync_context_alloc(device_hwctx, &s->sync_ctx);
> +    if (ret < 0)
> +        return ret;
> +
> +    DX_CHECK(ID3D12Device_CreateCommandQueue(device_hwctx->device, &queue_desc,
> +        &IID_ID3D12CommandQueue, &s->command_queue));
> +
> +    DX_CHECK(ID3D12Device_CreateCommandAllocator(device_hwctx->device, queue_desc.Type,
> +        &IID_ID3D12CommandAllocator, &s->command_allocator));
> +
> +    DX_CHECK(ID3D12Device_CreateCommandList(device_hwctx->device, 0, queue_desc.Type,
> +        s->command_allocator, NULL, &IID_ID3D12GraphicsCommandList, &s->command_list));
> +
> +    DX_CHECK(ID3D12GraphicsCommandList_Close(s->command_list));
> +
> +    ID3D12CommandQueue_ExecuteCommandLists(s->command_queue, 1, (ID3D12CommandList **)&s->command_list);
> +
> +    return av_d3d12va_wait_queue_idle(s->sync_ctx, s->command_queue);
> +
> +fail:
> +    return AVERROR(EINVAL);
> +}
> +
> +static void d3d12va_frames_uninit(AVHWFramesContext *ctx)
> +{
> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +
> +    av_d3d12va_sync_context_free(&s->sync_ctx);
> +
> +    D3D12_OBJECT_RELEASE(s->staging_buffer);
> +    D3D12_OBJECT_RELEASE(s->command_allocator);
> +    D3D12_OBJECT_RELEASE(s->command_list);
> +    D3D12_OBJECT_RELEASE(s->command_queue);
> +
> +    av_freep(&frames_hwctx->texture_infos);
> +}
> +
> +static int d3d12va_frames_get_constraints(AVHWDeviceContext *ctx, const void *hwconfig, AVHWFramesConstraints *constraints)
> +{
> +    HRESULT hr;
> +    int nb_sw_formats = 0;
> +    AVD3D12VADeviceContext *device_hwctx = ctx->hwctx;
> +
> +    constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,
> +                                                    sizeof(*constraints->valid_sw_formats));
> +    if (!constraints->valid_sw_formats)
> +        return AVERROR(ENOMEM);
> +
> +    for (int i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
> +        D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support = { supported_formats[i].d3d_format };
> +        hr = ID3D12Device_CheckFeatureSupport(device_hwctx->device, D3D12_FEATURE_FORMAT_SUPPORT, &format_support, sizeof(format_support));
> +        if (SUCCEEDED(hr) && (format_support.Support1 & D3D12_FORMAT_SUPPORT1_TEXTURE2D))
> +            constraints->valid_sw_formats[nb_sw_formats++] = supported_formats[i].pix_fmt;
> +    }
> +    constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
> +
> +    constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
> +    if (!constraints->valid_hw_formats)
> +        return AVERROR(ENOMEM);
> +
> +    constraints->valid_hw_formats[0] = AV_PIX_FMT_D3D12;
> +    constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
> +
> +    return 0;
> +}
> +
> +static void free_texture(void *opaque, uint8_t *data)
> +{
> +    AVD3D12FrameDescriptor *desc = (AVD3D12FrameDescriptor *)data;
> +
> +    if (desc->sync_ctx)
> +        av_d3d12va_sync_context_free(&desc->sync_ctx);
> +
> +    D3D12_OBJECT_RELEASE(desc->texture);
> +    av_freep(&data);
> +}
> +
> +static AVBufferRef *wrap_texture_buf(AVHWFramesContext *ctx, ID3D12Resource *texture, AVD3D12VASyncContext *sync_ctx)
> +{
> +    AVBufferRef *buf;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
> +
> +    AVD3D12FrameDescriptor *desc = av_mallocz(sizeof(*desc));
> +    if (!desc)
> +        goto fail;
> +
> +    if (s->nb_surfaces <= s->nb_surfaces_used) {
> +        frames_hwctx->texture_infos = av_realloc_f(frames_hwctx->texture_infos,
> +                                                   s->nb_surfaces_used + 1,
> +                                                   sizeof(*frames_hwctx->texture_infos));
> +        if (!frames_hwctx->texture_infos)
> +            goto fail;
> +        s->nb_surfaces = s->nb_surfaces_used + 1;
> +    }
>

Why do you need to store texture information inside
the hardware frames priv context at all?


> +
> +    desc->texture  = texture;
> +    desc->index    = s->nb_surfaces_used;
> +    desc->sync_ctx = sync_ctx;
> +
> +    frames_hwctx->texture_infos[s->nb_surfaces_used].texture  = texture;
> +    frames_hwctx->texture_infos[s->nb_surfaces_used].index    = desc->index;
> +    frames_hwctx->texture_infos[s->nb_surfaces_used].sync_ctx = sync_ctx;
> +    s->nb_surfaces_used++;
> +
> +    buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, texture, 0);
> +    if (!buf)
> +        goto fail;
> +
> +    return buf;
> +
> +fail:
> +    D3D12_OBJECT_RELEASE(texture);
> +    av_d3d12va_sync_context_free(&sync_ctx);
> +    av_freep(&desc);
> +    return NULL;
> +}
> +
> +static AVBufferRef *d3d12va_pool_alloc(void *opaque, size_t size)
> +{
> +    AVHWFramesContext      *ctx          = (AVHWFramesContext *)opaque;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +    AVD3D12VAFramesContext *hwctx        = ctx->hwctx;
> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
> +
> +    int ret;
> +    ID3D12Resource *texture;
> +    AVD3D12VASyncContext *sync_ctx;
> +
> +    D3D12_RESOURCE_DESC desc = {
> +        .Dimension        = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
> +        .Alignment        = 0,
> +        .Width            = ctx->width,
> +        .Height           = ctx->height,
> +        .DepthOrArraySize = 1,
> +        .MipLevels        = 1,
> +        .Format           = s->format,
> +        .SampleDesc       = {.Count = 1, .Quality = 0 },
> +        .Layout           = D3D12_TEXTURE_LAYOUT_UNKNOWN,
> +        .Flags            = D3D12_RESOURCE_FLAG_NONE,
> +    };
> +
> +    if (s->nb_surfaces_used >= ctx->initial_pool_size) {
> +        av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
> +        return NULL;
> +    }
> +
> +    ret = create_resource(device_hwctx->device, &desc, D3D12_RESOURCE_STATE_COMMON, &texture, 0);
> +    if (ret < 0)
> +        return NULL;
> +
> +    ret = av_d3d12va_sync_context_alloc(device_hwctx, &sync_ctx);
> +    if (ret < 0) {
> +        D3D12_OBJECT_RELEASE(texture);
> +        return NULL;
> +    }
> +
> +    return wrap_texture_buf(ctx, texture, sync_ctx);
> +}
> +
> +static int d3d12va_frames_init(AVHWFramesContext *ctx)
> +{
> +    AVD3D12VAFramesContext *hwctx        = ctx->hwctx;
> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +
> +    int i;
> +
> +    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
> +        if (ctx->sw_format == supported_formats[i].pix_fmt) {
> +            s->format = supported_formats[i].d3d_format;
> +            break;
> +        }
> +    }
> +    if (i == FF_ARRAY_ELEMS(supported_formats)) {
> +        av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
> +               av_get_pix_fmt_name(ctx->sw_format));
> +        return AVERROR(EINVAL);
> +    }
> +
> +    hwctx->texture_infos = av_realloc_f(NULL, ctx->initial_pool_size, sizeof(*hwctx->texture_infos));
> +    if (!hwctx->texture_infos)
> +        return AVERROR(ENOMEM);
> +
> +    memset(hwctx->texture_infos, 0, ctx->initial_pool_size * sizeof(*hwctx->texture_infos));
> +    s->nb_surfaces = ctx->initial_pool_size;
> +
> +    ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D12FrameDescriptor),
> +        ctx, d3d12va_pool_alloc, NULL);
> +
> +    if (!ctx->internal->pool_internal)
> +        return AVERROR(ENOMEM);
> +
> +    return 0;
> +}
> +
> +static int d3d12va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
> +{
> +    int ret;
> +    AVD3D12FrameDescriptor *desc;
> +
> +    frame->buf[0] = av_buffer_pool_get(ctx->pool);
> +    if (!frame->buf[0])
> +        return AVERROR(ENOMEM);
> +
> +    ret = av_image_fill_arrays(frame->data, frame->linesize, frame->buf[0]->data,
> +        ctx->sw_format, ctx->width, ctx->height, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
> +    if (ret < 0)
> +        return ret;
> +
> +    desc = (AVD3D12FrameDescriptor *)frame->buf[0]->data;
> +    frame->data[0] = (uint8_t *)desc->texture;
> +    frame->data[1] = (uint8_t *)desc->index;
> +    frame->data[2] = (uint8_t *)desc->sync_ctx;
> +
> +    frame->format  = AV_PIX_FMT_D3D12;
> +    frame->width   = ctx->width;
> +    frame->height  = ctx->height;
> +
> +    return 0;
> +}
> +
> +static int d3d12va_transfer_get_formats(AVHWFramesContext *ctx,
> +                                        enum AVHWFrameTransferDirection dir,
> +                                        enum AVPixelFormat **formats)
> +{
> +    D3D12VAFramesContext *s = ctx->internal->priv;
> +    enum AVPixelFormat *fmts;
> +
> +    fmts = av_malloc_array(2, sizeof(*fmts));
> +    if (!fmts)
> +        return AVERROR(ENOMEM);
> +
> +    fmts[0] = ctx->sw_format;
> +    fmts[1] = AV_PIX_FMT_NONE;
> +
> +    *formats = fmts;
> +
> +    return 0;
> +}
> +
> +static int d3d12va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
> +                                 const AVFrame *src)
> +{
> +    AVD3D12VADeviceContext *hwctx        = ctx->device_ctx->hwctx;
> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
> +
> +    int ret;
> +    int download = src->format == AV_PIX_FMT_D3D12;
> +    const AVFrame *frame = download ? src : dst;
> +    const AVFrame *other = download ? dst : src;
> +
> +    ID3D12Resource       *texture  = (ID3D12Resource *)      frame->data[0];
> +    int                   index    = (intptr_t)              frame->data[1];
> +    AVD3D12VASyncContext *sync_ctx = (AVD3D12VASyncContext *)frame->data[2];
> +
> +    uint8_t *mapped_data;
> +    uint8_t *data[4];
> +    int linesizes[4];
> +
> +    D3D12_TEXTURE_COPY_LOCATION staging_y_location;
> +    D3D12_TEXTURE_COPY_LOCATION staging_uv_location;
> +
> +    D3D12_TEXTURE_COPY_LOCATION texture_y_location = {
> +        .pResource        = texture,
> +        .Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
> +        .SubresourceIndex = 0,
> +    };
> +
> +    D3D12_TEXTURE_COPY_LOCATION texture_uv_location = {
> +        .pResource        = texture,
> +        .Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
> +        .SubresourceIndex = 1,
> +    };
> +
> +    D3D12_RESOURCE_BARRIER barrier = {
> +        .Type  = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
> +        .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,
> +        .Transition = {
> +            .pResource   = texture,
> +            .StateBefore = D3D12_RESOURCE_STATE_COMMON,
> +            .StateAfter  = D3D12_RESOURCE_STATE_COPY_SOURCE,
> +            .Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
> +        }
> +    };
> +
> +    s->format = av_d3d12va_map_sw_to_hw_format(ctx->sw_format);
> +
> +    if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
> +        return AVERROR(EINVAL);
> +
> +    if (!s->command_queue) {
> +        ret = d3d12va_create_helper_objects(ctx);
> +        if (ret < 0)
> +            return ret;
> +    }
> +
> +    for (int i = 0; i < 4; i++)
> +        linesizes[i] = FFALIGN(frame->width * (s->format == DXGI_FORMAT_P010 ? 2 : 1), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
> +
> +    staging_y_location = (D3D12_TEXTURE_COPY_LOCATION) {
> +        .pResource = s->staging_buffer,
> +        .Type      = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
> +        .PlacedFootprint = {
> +            .Offset = 0,
> +            .Footprint = {
> +                .Format   = s->format == DXGI_FORMAT_P010 ? DXGI_FORMAT_R16_UNORM : DXGI_FORMAT_R8_UNORM,
> +                .Width    = ctx->width,
> +                .Height   = ctx->height,
> +                .Depth    = 1,
> +                .RowPitch = linesizes[0],
> +            },
> +        },
> +    };
> +
> +    staging_uv_location = (D3D12_TEXTURE_COPY_LOCATION) {
> +        .pResource = s->staging_buffer,
> +        .Type      = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
> +        .PlacedFootprint = {
> +            .Offset = s->luma_component_size,
> +            .Footprint = {
> +                .Format   = s->format == DXGI_FORMAT_P010 ? DXGI_FORMAT_R16G16_UNORM : DXGI_FORMAT_R8G8_UNORM,
> +                .Width    = ctx->width  >> 1,
> +                .Height   = ctx->height >> 1,
> +                .Depth    = 1,
> +                .RowPitch = linesizes[0],
> +            },
> +        },
> +    };
> +
> +    DX_CHECK(ID3D12CommandAllocator_Reset(s->command_allocator));
> +
> +    DX_CHECK(ID3D12GraphicsCommandList_Reset(s->command_list, s->command_allocator, NULL));
> +
> +    if (download) {
> +        ID3D12GraphicsCommandList_ResourceBarrier(s->command_list, 1, &barrier);
> +
> +        ID3D12GraphicsCommandList_CopyTextureRegion(s->command_list,
> +            &staging_y_location, 0, 0, 0, &texture_y_location, NULL);
> +
> +        ID3D12GraphicsCommandList_CopyTextureRegion(s->command_list,
> +            &staging_uv_location, 0, 0, 0, &texture_uv_location, NULL);
> +
> +        barrier.Transition.StateBefore = barrier.Transition.StateAfter;
> +        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
> +        ID3D12GraphicsCommandList_ResourceBarrier(s->command_list, 1, &barrier);
> +
> +        DX_CHECK(ID3D12GraphicsCommandList_Close(s->command_list));
> +
> +        if (!hwctx->sync)
> +            DX_CHECK(ID3D12CommandQueue_Wait(s->command_queue, sync_ctx->fence, sync_ctx->fence_value));
> +
> +        ID3D12CommandQueue_ExecuteCommandLists(s->command_queue, 1, (ID3D12CommandList **)&s->command_list);
> +
> +        ret = av_d3d12va_wait_queue_idle(s->sync_ctx, s->command_queue);
> +        if (ret)
> +            return ret;
> +
> +        DX_CHECK(ID3D12Resource_Map(s->staging_buffer, 0, NULL, &mapped_data));
> +        av_image_fill_pointers(data, ctx->sw_format, ctx->height, mapped_data, linesizes);
> +
> +        av_image_copy(dst->data, dst->linesize, data, linesizes,
> +            ctx->sw_format, ctx->width, ctx->height);
> +
> +        ID3D12Resource_Unmap(s->staging_buffer, 0, NULL);
> +    } else {
> +        av_log(ctx, AV_LOG_ERROR, "Transfer data to AV_PIX_FMT_D3D12 is not supported yet!\n");
> +        return AVERROR(EINVAL);
>

You should implement this, if only for debugging. Many vendors don't
handle all pixel formats correctly, especially for video so being able to
upload would help in debugging.


> +    }
> +
> +    return 0;
> +
> +fail:
> +    return AVERROR(EINVAL);
> +}
> +
> +static int d3d12va_device_init(AVHWDeviceContext *hwdev)
> +{
> +    AVD3D12VADeviceContext *ctx = hwdev->hwctx;
> +
> +    if (!ctx->video_device)
> +        DX_CHECK(ID3D12Device_QueryInterface(ctx->device, &IID_ID3D12VideoDevice, (void **)&ctx->video_device));
> +
> +    return 0;
> +
> +fail:
> +    return AVERROR(EINVAL);
> +}
> +
> +static void d3d12va_device_uninit(AVHWDeviceContext *hwdev)
> +{
> +    AVD3D12VADeviceContext *device_hwctx = hwdev->hwctx;
> +
> +    D3D12_OBJECT_RELEASE(device_hwctx->video_device);
> +    D3D12_OBJECT_RELEASE(device_hwctx->device);
> +}
> +
> +static int d3d12va_device_create(AVHWDeviceContext *ctx, const char *device,
> +                                 AVDictionary *opts, int flags)
> +{
> +    AVD3D12VADeviceContext *device_hwctx = ctx->hwctx;
> +
> +    HRESULT hr;
> +    UINT create_flags = 0;
> +    IDXGIAdapter *pAdapter = NULL;
> +
> +    int ret;
> +    int is_debug       = !!av_dict_get(opts, "debug", NULL, 0);
> +    device_hwctx->sync = !!av_dict_get(opts, "sync",  NULL, 0);
> +
> +    if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
> +        return AVERROR_UNKNOWN;
> +
> +    if (is_debug) {
> +        ID3D12Debug *pDebug;
> +        if (d3d12va_get_debug_interface && SUCCEEDED(d3d12va_get_debug_interface(&IID_ID3D12Debug, &pDebug))) {
> +            create_flags |= DXGI_CREATE_FACTORY_DEBUG;
> +            ID3D12Debug_EnableDebugLayer(pDebug);
> +            D3D12_OBJECT_RELEASE(pDebug);
> +            av_log(ctx, AV_LOG_INFO, "D3D12 debug layer is enabled!\n");
> +        }
> +    }
> +
> +    if (!device_hwctx->device) {
> +        IDXGIFactory2 *pDXGIFactory = NULL;
> +
> +        if (!d3d12va_create_device || !d3d12va_create_dxgi_factory2) {
> +            av_log(ctx, AV_LOG_ERROR, "Failed to load D3D12 library or its functions\n");
> +            return AVERROR_UNKNOWN;
> +        }
> +
> +        hr = d3d12va_create_dxgi_factory2(create_flags, &IID_IDXGIFactory2, (void **)&pDXGIFactory);
> +        if (SUCCEEDED(hr)) {
> +            int adapter = device ? atoi(device) : 0;
> +            if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
> +                pAdapter = NULL;
> +            IDXGIFactory2_Release(pDXGIFactory);
> +        }
> +
> +        if (pAdapter) {
> +            DXGI_ADAPTER_DESC desc;
> +            hr = IDXGIAdapter2_GetDesc(pAdapter, &desc);
> +            if (!FAILED(hr)) {
> +                av_log(ctx, AV_LOG_INFO, "Using device %04x:%04x (%ls).\n",
> +                       desc.VendorId, desc.DeviceId, desc.Description);
> +            }
> +        }
> +
> +        hr = d3d12va_create_device((IUnknown *)pAdapter, D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, &device_hwctx->device);
> +        D3D12_OBJECT_RELEASE(pAdapter);
> +        if (FAILED(hr)) {
> +            av_log(ctx, AV_LOG_ERROR, "Failed to create DirectX3D 12 device (%lx)\n", (long)hr);
> +            return AVERROR_UNKNOWN;
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +const HWContextType ff_hwcontext_type_d3d12va = {
> +    .type                   = AV_HWDEVICE_TYPE_D3D12VA,
> +    .name                   = "D3D12VA",
> +
> +    .device_hwctx_size      = sizeof(AVD3D12VADeviceContext),
> +    .frames_hwctx_size      = sizeof(AVD3D12VAFramesContext),
> +    .frames_priv_size       = sizeof(D3D12VAFramesContext),
> +
> +    .device_create          = d3d12va_device_create,
> +    .device_init            = d3d12va_device_init,
> +    .device_uninit          = d3d12va_device_uninit,
> +    .frames_get_constraints = d3d12va_frames_get_constraints,
> +    .frames_init            = d3d12va_frames_init,
> +    .frames_uninit          = d3d12va_frames_uninit,
> +    .frames_get_buffer      = d3d12va_get_buffer,
> +    .transfer_get_formats   = d3d12va_transfer_get_formats,
> +    .transfer_data_to       = d3d12va_transfer_data,
> +    .transfer_data_from     = d3d12va_transfer_data,
> +
> +    .pix_fmts               = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D12, AV_PIX_FMT_NONE },
> +};
> diff --git a/libavutil/hwcontext_d3d12va.h b/libavutil/hwcontext_d3d12va.h
> new file mode 100644
> index 0000000000..740e460453
> --- /dev/null
> +++ b/libavutil/hwcontext_d3d12va.h
> @@ -0,0 +1,169 @@
> +/*
> + * Direct3D 12 HW acceleration.
> + *
> + * 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
> + */
> +
> +#ifndef AVUTIL_HWCONTEXT_D3D12VA_H
> +#define AVUTIL_HWCONTEXT_D3D12VA_H
> +
> +/**
> + * @file
> + * An API-specific header for AV_HWDEVICE_TYPE_D3D12VA.
> + *
> + * This API does not support dynamic frame pools. AVHWFramesContext.pool must
> + * contain AVBufferRefs whose data pointer points to an AVD3D12FrameDescriptor struct.
> + */
> +#include <stdint.h>
> +#include <initguid.h>
> +#include <d3d12.h>
> +#include <d3d12video.h>
> +
> +/**
> + * @brief This struct is allocated as AVHWDeviceContext.hwctx
> + *
> + */
> +typedef struct AVD3D12VADeviceContext {
> +    /**
> +     * Device used for objects creation and access. This can also be
> +     * used to set the libavcodec decoding device.
> +     *
> +     * Can be set by the user. This is the only mandatory field - the other
> +     * device context fields are set from this and are available for convenience.
> +     *
> +     * Deallocating the AVHWDeviceContext will always release this interface,
> +     * and it does not matter whether it was user-allocated.
> +     */
> +    ID3D12Device *device;
> +
> +    /**
> +     * If unset, this will be set from the device field on init.
> +     *
> +     * Deallocating the AVHWDeviceContext will always release this interface,
> +     * and it does not matter whether it was user-allocated.
> +     */
> +    ID3D12VideoDevice *video_device;
> +
> +    /**
> +     * Specifed by sync=1 when init d3d12va
> +     *
> +     * Execute commands as sync mode
> +     */
> +    int sync;
> +} AVD3D12VADeviceContext;
> +
> +/**
> + * @brief This struct is used to sync d3d12 execution
> + *
> + */
> +typedef struct AVD3D12VASyncContext {
> +    /**
> +     * D3D12 fence object
> +     */
> +    ID3D12Fence *fence;
> +
> +    /**
> +     * A handle to the event object
> +     */
> +    HANDLE event;
> +
> +    /**
> +     * The fence value used for sync
> +     */
> +    uint64_t fence_value;
> +} AVD3D12VASyncContext;
> +
> +/**
> + * @brief D3D12 frame descriptor for pool allocation.
> + *
> + */
> +typedef struct AVD3D12FrameDescriptor {
> +    /**
> +     * The texture in which the frame is located. The reference count is
> +     * managed by the AVBufferRef, and destroying the reference will release
> +     * the interface.
> +     *
> +     * Normally stored in AVFrame.data[0].
> +     */
> +    ID3D12Resource *texture;
> +
> +    /**
> +     * The index into the array texture element representing the frame
> +     *
> +     * Normally stored in AVFrame.data[1] (cast from intptr_t).
> +     */
> +    intptr_t index;
> +
> +    /**
> +     * The sync context for the texture
> +     *
> +     * Use av_d3d12va_wait_idle(sync_ctx) to ensure the decoding or encoding have been finised
> +     * @see: https://learn.microsoft.com/en-us/windows/win32/medfound/direct3d-12-video-overview#directx-12-fences
> +     *
> +     * Normally stored in AVFrame.data[2].
> +     */
> +    AVD3D12VASyncContext *sync_ctx;
> +} AVD3D12FrameDescriptor;
> +
> +/**
> + * @brief This struct is allocated as AVHWFramesContext.hwctx
> + *
> + */
> +typedef struct AVD3D12VAFramesContext {
> +    /**
> +     * The same implementation as d3d11va
> +     * This field is not able to be user-allocated at the present.
> +     */
> +    AVD3D12FrameDescriptor *texture_infos;
> +} AVD3D12VAFramesContext;
> +
> +/**
> + * @brief Map sw pixel format to d3d12 format
> + *
> + * @return d3d12 specified format
> + */
> +DXGI_FORMAT av_d3d12va_map_sw_to_hw_format(enum AVPixelFormat pix_fmt);
> +
> +/**
> + * @brief Allocate an AVD3D12VASyncContext
> + *
> + * @return Error code (ret < 0 if failed)
> + */
> +int av_d3d12va_sync_context_alloc(AVD3D12VADeviceContext *ctx, AVD3D12VASyncContext **sync_ctx);
> +
> +/**
> + * @brief Free an AVD3D12VASyncContext
> + */
> +void av_d3d12va_sync_context_free(AVD3D12VASyncContext **sync_ctx);
>

Any reason why this should be allocated dynamically?
We can always add new fields without bumping the ABI.


> +
> +/**
> + * @brief Wait for the sync context to the idle state
> + *
> + * @return Error code (ret < 0 if failed)
> + */
> +int av_d3d12va_wait_idle(AVD3D12VASyncContext *sync_ctx);
> +
> +/**
> + * @brief Wait for a specified command queue to the idle state
> + *
> + * @return Error code (ret < 0 if failed)
> + */
> +int av_d3d12va_wait_queue_idle(AVD3D12VASyncContext *sync_ctx, ID3D12CommandQueue *command_queue);
> +
> +#endif /* AVUTIL_HWCONTEXT_D3D12VA_H */
> diff --git a/libavutil/hwcontext_d3d12va_internal.h b/libavutil/hwcontext_d3d12va_internal.h
> new file mode 100644
> index 0000000000..bfd89b3545
> --- /dev/null
> +++ b/libavutil/hwcontext_d3d12va_internal.h
> @@ -0,0 +1,59 @@
> +/*
> + * Direct3D 12 HW acceleration.
> + *
> + * 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
> + */
> +
> +#ifndef AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H
> +#define AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H
> +
> +/**
> + * @def COBJMACROS
> + *
> + * @brief Enable C style interface for D3D12
> + */
> +#ifndef COBJMACROS
> +#define COBJMACROS
> +#endif
> +
> +/**
> + * @def DX_CHECK
> + *
> + * @brief A check macro used by D3D12 functions highly frequently
> + */
> +#define DX_CHECK(hr)                              \
> +    do {                                          \
> +        if (FAILED(hr))                           \
> +            goto fail;                            \
> +    } while (0)
> +
> +/**
> + * @def D3D12_OBJECT_RELEASE
> + *
> + * @brief A release macro used by D3D12 objects highly frequently
> + */
> +#define D3D12_OBJECT_RELEASE(pInterface)              \
> +    do {                                              \
> +        if (pInterface) {                             \
> +            IUnknown_Release((IUnknown *)pInterface); \
> +            pInterface = NULL;                        \
> +        }                                             \
> +    } while (0)
> +
> +#endif /* AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H */
> \ No newline at end of file
> diff --git a/libavutil/hwcontext_internal.h b/libavutil/hwcontext_internal.h
> index e6266494ac..4df516ee6a 100644
> --- a/libavutil/hwcontext_internal.h
> +++ b/libavutil/hwcontext_internal.h
> @@ -165,6 +165,7 @@ int ff_hwframe_map_replace(AVFrame *dst, const AVFrame *src);
>  
>  extern const HWContextType ff_hwcontext_type_cuda;
>  extern const HWContextType ff_hwcontext_type_d3d11va;
> +extern const HWContextType ff_hwcontext_type_d3d12va;
>  extern const HWContextType ff_hwcontext_type_drm;
>  extern const HWContextType ff_hwcontext_type_dxva2;
>  extern const HWContextType ff_hwcontext_type_opencl;
> diff --git a/libavutil/pixdesc.c b/libavutil/pixdesc.c
> index e1e0dd2a9e..09fca5ef19 100644
> --- a/libavutil/pixdesc.c
> +++ b/libavutil/pixdesc.c
> @@ -2283,6 +2283,10 @@ static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
>  .name = "d3d11",
>  .flags = AV_PIX_FMT_FLAG_HWACCEL,
>  },
> +    [AV_PIX_FMT_D3D12] = {
> +        .name = "d3d12",
> +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
> +    },
>  [AV_PIX_FMT_GBRPF32BE] = {
>  .name = "gbrpf32be",
>  .nb_components = 3,
> diff --git a/libavutil/pixfmt.h b/libavutil/pixfmt.h
> index 63e07ba64f..1f0ab2a23c 100644
> --- a/libavutil/pixfmt.h
> +++ b/libavutil/pixfmt.h
> @@ -426,6 +426,15 @@ enum AVPixelFormat {
>  AV_PIX_FMT_P412BE,      ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, big-endian
>  AV_PIX_FMT_P412LE,      ///< interleaved chroma YUV 4:4:4, 36bpp, data in the high bits, little-endian
>  
> +    /**
> +     * Hardware surfaces for Direct3D 12.
> +     *
> +     * data[0] contains a ID3D12Resource pointer.
> +     * data[1] contains the resource array index of the frame as intptr_t.
> +     * data[2] contains the sync context for current resource
> +     */
> +    AV_PIX_FMT_D3D12,
>

Folding all three into a single structure would be more flexible
towards API users, who, for example, may want to have different
textures with different sync contexts for each.


> +
>  AV_PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you want to link with shared libav* because the number of formats might differ between versions
>  };
>  
> diff --git a/libavutil/tests/hwdevice.c b/libavutil/tests/hwdevice.c
> index c57586613a..9d7964f9ee 100644
> --- a/libavutil/tests/hwdevice.c
> +++ b/libavutil/tests/hwdevice.c
> @@ -137,6 +137,8 @@ static const struct {
>  { "0", "1", "2" } },
>  { AV_HWDEVICE_TYPE_D3D11VA,
>  { "0", "1", "2" } },
> +    { AV_HWDEVICE_TYPE_D3D12VA,
> +      { "0", "1", "2" } },
>  { AV_HWDEVICE_TYPE_OPENCL,
>  { "0.0", "0.1", "1.0", "1.1" } },
>  { AV_HWDEVICE_TYPE_VAAPI,
> diff --git a/libavutil/version.h b/libavutil/version.h
> index 24af520e08..9e798b0e3f 100644
> --- a/libavutil/version.h
> +++ b/libavutil/version.h
> @@ -79,7 +79,7 @@
>  */
>  
>  #define LIBAVUTIL_VERSION_MAJOR  58
> -#define LIBAVUTIL_VERSION_MINOR  14
> +#define LIBAVUTIL_VERSION_MINOR  15
>  #define LIBAVUTIL_VERSION_MICRO 100 
>

Just a preliminary look. I don't think this should be in 6.1, we're already late,
and no external users of the API exist yet to make sure it's usable.

I still disagree with the lack of a dynamic frame allocation system (using
frame pools). It's not a lot of code, and it improves usability significantly,
as without this, it's not possible to implement anything but simple and
direct display of frames, as quickly as possible. Filtering, for example,
would definitely run up against the limit, as filters in general carry
on using the frames context they receive, if they are able to.

>Aug 4, 2023, 15:50 by tong1.wu-at-intel.com@ffmpeg.org:
>
>> From: Wu Jianhua <toqsxw@outlook.com>
>>
>> Signed-off-by: Wu Jianhua <toqsxw@outlook.com>
>> Signed-off-by: Tong Wu <tong1.wu@intel.com>
>> ---
>>  configure                              |   5 +
>>  doc/APIchanges                         |   7 +
>>  libavutil/Makefile                     |   3 +
>>  libavutil/hwcontext.c                  |   4 +
>>  libavutil/hwcontext.h                  |   1 +
>>  libavutil/hwcontext_d3d12va.c          | 703 +++++++++++++++++++++++++
>>  libavutil/hwcontext_d3d12va.h          | 169 ++++++
>>  libavutil/hwcontext_d3d12va_internal.h |  59 +++
>>  libavutil/hwcontext_internal.h         |   1 +
>>  libavutil/pixdesc.c                    |   4 +
>>  libavutil/pixfmt.h                     |   9 +
>>  libavutil/tests/hwdevice.c             |   2 +
>>  libavutil/version.h                    |   2 +-
>>  13 files changed, 968 insertions(+), 1 deletion(-)
>>  create mode 100644 libavutil/hwcontext_d3d12va.c
>>  create mode 100644 libavutil/hwcontext_d3d12va.h
>>  create mode 100644 libavutil/hwcontext_d3d12va_internal.h
>>
>> diff --git a/configure b/configure
>> index 99388e7664..9919551ad0 100755
>> --- a/configure
>> +++ b/configure
>> @@ -338,6 +338,7 @@ External library support:
>>  --disable-cuda-llvm      disable CUDA compilation using clang [autodetect]
>>  --disable-cuvid          disable Nvidia CUVID support [autodetect]
>>  --disable-d3d11va        disable Microsoft Direct3D 11 video acceleration code
>[autodetect]
>> +  --disable-d3d12va        disable Microsoft Direct3D 12 video acceleration
>code [autodetect]
>>  --disable-dxva2          disable Microsoft DirectX 9 video acceleration code
>[autodetect]
>>  --disable-ffnvcodec      disable dynamically linked Nvidia code [autodetect]
>>  --enable-libdrm          enable DRM code (Linux) [no]
>> @@ -1926,6 +1927,7 @@ HWACCEL_AUTODETECT_LIBRARY_LIST="
>>  cuda_llvm
>>  cuvid
>>  d3d11va
>> +    d3d12va
>>  dxva2
>>  ffnvcodec
>>  nvdec
>> @@ -3053,6 +3055,7 @@ crystalhd_deps="libcrystalhd_libcrystalhd_if_h"
>>  cuda_deps="ffnvcodec"
>>  cuvid_deps="ffnvcodec"
>>  d3d11va_deps="dxva_h ID3D11VideoDecoder ID3D11VideoContext"
>> +d3d12va_deps="dxva_h ID3D12Device ID3D12VideoDecoder"
>>  dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode ole32 user32"
>>  ffnvcodec_deps_any="libdl LoadLibrary"
>>  mediacodec_deps="android"
>> @@ -6543,6 +6546,8 @@ check_type "windows.h dxgi1_2.h"
>"IDXGIOutput1"
>>  check_type "windows.h dxgi1_5.h" "IDXGIOutput5"
>>  check_type "windows.h d3d11.h" "ID3D11VideoDecoder"
>>  check_type "windows.h d3d11.h" "ID3D11VideoContext"
>> +check_type "windows.h d3d12.h" "ID3D12Device"
>> +check_type "windows.h d3d12video.h" "ID3D12VideoDecoder"
>>  check_type "windows.h" "DPI_AWARENESS_CONTEXT" -
>D_WIN32_WINNT=0x0A00
>>  check_type "d3d9.h dxva2api.h" DXVA2_ConfigPictureDecode -
>D_WIN32_WINNT=0x0602
>>  check_func_headers mfapi.h MFCreateAlignedMemoryBuffer -lmfplat
>> diff --git a/doc/APIchanges b/doc/APIchanges
>> index 5afe8bcb75..c14ab0b394 100644
>> --- a/doc/APIchanges
>> +++ b/doc/APIchanges
>> @@ -2,6 +2,13 @@ The last version increases of all libraries were on 2023-
>02-09
>>
>>  API changes, most recent first:
>>
>> +2023-07-xx - xxxxxxxxxx - lavu 58.15.100 - pixfmt.h hwcontext.h
>hwcontext_d3d12va.h
>> +  Add AV_HWDEVICE_TYPE_D3D12VA and AV_PIX_FMT_D3D12.
>> +  Add AVD3D12VADeviceContext, AVD3D12VASyncContext,
>AVD3D12FrameDescriptor,
>> +  and AVD3D12VAFramesContext.
>> +  Add av_d3d12va_map_sw_to_hw_format,
>av_d3d12va_create_sync_context,
>> +  av_d3d12va_release_sync_context, av_d3d12va_wait_idle, and
>av_d3d12va_wait_queue_idle.
>> +
>>  2023-07-xx - xxxxxxxxxx - lavc 60 - avcodec.h
>>  Deprecate AV_CODEC_FLAG_DROPCHANGED without replacement.
>>
>> diff --git a/libavutil/Makefile b/libavutil/Makefile
>> index bd9c6f9e32..40d49d76dd 100644
>> --- a/libavutil/Makefile
>> +++ b/libavutil/Makefile
>> @@ -41,6 +41,7 @@ HEADERS = adler32.h                                                     \
>>  hwcontext.h                                                   \
>>  hwcontext_cuda.h                                              \
>>  hwcontext_d3d11va.h                                           \
>> +          hwcontext_d3d12va.h                                           \
>>  hwcontext_drm.h                                               \
>>  hwcontext_dxva2.h                                             \
>>  hwcontext_qsv.h                                               \
>> @@ -186,6 +187,7 @@ OBJS = adler32.o                                                        \
>>
>>  OBJS-$(CONFIG_CUDA)                     += hwcontext_cuda.o
>>  OBJS-$(CONFIG_D3D11VA)                  += hwcontext_d3d11va.o
>> +OBJS-$(CONFIG_D3D12VA)                  += hwcontext_d3d12va.o
>>  OBJS-$(CONFIG_DXVA2)                    += hwcontext_dxva2.o
>>  OBJS-$(CONFIG_LIBDRM)                   += hwcontext_drm.o
>>  OBJS-$(CONFIG_MACOS_KPERF)              += macos_kperf.o
>> @@ -209,6 +211,7 @@ SKIPHEADERS-$(HAVE_CUDA_H)             +=
>hwcontext_cuda.h
>>  SKIPHEADERS-$(CONFIG_CUDA)             += hwcontext_cuda_internal.h     \
>>  cuda_check.h
>>  SKIPHEADERS-$(CONFIG_D3D11VA)          += hwcontext_d3d11va.h
>> +SKIPHEADERS-$(CONFIG_D3D12VA)          += hwcontext_d3d12va.h
>>  SKIPHEADERS-$(CONFIG_DXVA2)            += hwcontext_dxva2.h
>>  SKIPHEADERS-$(CONFIG_QSV)              += hwcontext_qsv.h
>>  SKIPHEADERS-$(CONFIG_OPENCL)           += hwcontext_opencl.h
>> diff --git a/libavutil/hwcontext.c b/libavutil/hwcontext.c
>> index 3396598269..04070bc3c3 100644
>> --- a/libavutil/hwcontext.c
>> +++ b/libavutil/hwcontext.c
>> @@ -36,6 +36,9 @@ static const HWContextType * const hw_table[] = {
>>  #if CONFIG_D3D11VA
>>  &ff_hwcontext_type_d3d11va,
>>  #endif
>> +#if CONFIG_D3D12VA
>> +    &ff_hwcontext_type_d3d12va,
>> +#endif
>>  #if CONFIG_LIBDRM
>>  &ff_hwcontext_type_drm,
>>  #endif
>> @@ -71,6 +74,7 @@ static const char *const hw_type_names[] = {
>>  [AV_HWDEVICE_TYPE_DRM]    = "drm",
>>  [AV_HWDEVICE_TYPE_DXVA2]  = "dxva2",
>>  [AV_HWDEVICE_TYPE_D3D11VA] = "d3d11va",
>> +    [AV_HWDEVICE_TYPE_D3D12VA] = "d3d12va",
>>  [AV_HWDEVICE_TYPE_OPENCL] = "opencl",
>>  [AV_HWDEVICE_TYPE_QSV]    = "qsv",
>>  [AV_HWDEVICE_TYPE_VAAPI]  = "vaapi",
>> diff --git a/libavutil/hwcontext.h b/libavutil/hwcontext.h
>> index 7ff08c8608..2b33721a97 100644
>> --- a/libavutil/hwcontext.h
>> +++ b/libavutil/hwcontext.h
>> @@ -37,6 +37,7 @@ enum AVHWDeviceType {
>>  AV_HWDEVICE_TYPE_OPENCL,
>>  AV_HWDEVICE_TYPE_MEDIACODEC,
>>  AV_HWDEVICE_TYPE_VULKAN,
>> +    AV_HWDEVICE_TYPE_D3D12VA,
>>  };
>>
>>  typedef struct AVHWDeviceInternal AVHWDeviceInternal;
>> diff --git a/libavutil/hwcontext_d3d12va.c b/libavutil/hwcontext_d3d12va.c
>> new file mode 100644
>> index 0000000000..907b8a3f0b
>> --- /dev/null
>> +++ b/libavutil/hwcontext_d3d12va.c
>> @@ -0,0 +1,703 @@
>> +/*
>> + * Direct3D 12 HW acceleration.
>> + *
>> + * 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 "config.h"
>> +#include "common.h"
>> +#include "hwcontext.h"
>> +#include "hwcontext_internal.h"
>> +#include "hwcontext_d3d12va_internal.h"
>> +#include "hwcontext_d3d12va.h"
>> +#include "imgutils.h"
>> +#include "pixdesc.h"
>> +#include "pixfmt.h"
>> +#include "thread.h"
>> +#include "compat/w32dlfcn.h"
>> +#include <dxgi1_3.h>
>> +
>> +typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY2)(UINT Flags,
>REFIID riid, void **ppFactory);
>> +
>> +static AVOnce functions_loaded = AV_ONCE_INIT;
>>
>
>These shouldn't be global state. Take a look at how vulkan does it, by
>having a main loader function exposed in the device context.

OK, will modify in V6


>
>
>> +
>> +static PFN_CREATE_DXGI_FACTORY2 d3d12va_create_dxgi_factory2;
>> +static PFN_D3D12_CREATE_DEVICE d3d12va_create_device;
>> +static PFN_D3D12_GET_DEBUG_INTERFACE d3d12va_get_debug_interface;
>> +
>> +static av_cold void load_functions(void)
>> +{
>> +#if !HAVE_UWP
>> +    // We let these "leak" - this is fine, as unloading has no great benefit, and
>> +    // Windows will mark a DLL as loaded forever if its internal refcount
>overflows
>> +    // from too many LoadLibrary calls.
>> +    HANDLE d3dlib, dxgilib;
>> +
>> +    d3dlib  = dlopen("d3d12.dll", 0);
>> +    dxgilib = dlopen("dxgi.dll", 0);
>> +    if (!d3dlib || !dxgilib)
>> +        return;
>> +
>> +    d3d12va_create_device =
>(PFN_D3D12_CREATE_DEVICE)GetProcAddress(d3dlib, "D3D12CreateDevice");
>> +    d3d12va_create_dxgi_factory2 =
>(PFN_CREATE_DXGI_FACTORY2)GetProcAddress(dxgilib,
>"CreateDXGIFactory2");
>> +    d3d12va_get_debug_interface =
>(PFN_D3D12_GET_DEBUG_INTERFACE)GetProcAddress(d3dlib,
>"D3D12GetDebugInterface");
>> +#else
>> +    d3d12va_create_device = (PFN_D3D12_CREATE_DEVICE)
>D3D12CreateDevice;
>> +    d3d12va_create_dxgi_factory2 = (PFN_CREATE_DXGI_FACTORY2)
>CreateDXGIFactory2;
>> +    d3d12va_get_debug_interface = (PFN_D3D12_GET_DEBUG_INTERFACE)
>D3D12GetDebugInterface;
>> +#endif
>>
>
>We already have dlopen code, you should use it. It prevents leaks too.
>Leaks are never fine.
>
Will add dlclose in V6

>
>> +}
>> +
>> +typedef struct D3D12VAFramesContext {
>> +    ID3D12Resource            *staging_buffer;
>> +    ID3D12CommandQueue        *command_queue;
>> +    ID3D12CommandAllocator    *command_allocator;
>> +    ID3D12GraphicsCommandList *command_list;
>> +    AVD3D12VASyncContext      *sync_ctx;
>> +    int                        nb_surfaces;
>> +    int                        nb_surfaces_used;
>> +    DXGI_FORMAT                format;
>> +    UINT                       luma_component_size;
>> +} D3D12VAFramesContext;
>> +
>> +static const struct {
>> +    DXGI_FORMAT d3d_format;
>> +    enum AVPixelFormat pix_fmt;
>> +} supported_formats[] = {
>> +    { DXGI_FORMAT_NV12, AV_PIX_FMT_NV12 },
>> +    { DXGI_FORMAT_P010, AV_PIX_FMT_P010 },
>> +};
>> +
>> +DXGI_FORMAT av_d3d12va_map_sw_to_hw_format(enum AVPixelFormat
>pix_fmt)
>> +{
>> +    switch (pix_fmt) {
>> +    case AV_PIX_FMT_NV12:return DXGI_FORMAT_NV12;
>> +    case AV_PIX_FMT_P010:return DXGI_FORMAT_P010;
>> +    default:             return DXGI_FORMAT_UNKNOWN;
>> +    }
>> +}
>> +
>> +int av_d3d12va_sync_context_alloc(AVD3D12VADeviceContext *ctx,
>AVD3D12VASyncContext **psync_ctx)
>> +{
>> +    AVD3D12VASyncContext *sync_ctx;
>> +
>> +    sync_ctx = av_mallocz(sizeof(AVD3D12VASyncContext));
>> +    if (!sync_ctx)
>> +        return AVERROR(ENOMEM);
>> +
>> +    DX_CHECK(ID3D12Device_CreateFence(ctx->device, sync_ctx-
>>fence_value, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, &sync_ctx-
>>fence));
>> +
>> +    sync_ctx->event = CreateEvent(NULL, FALSE, FALSE, NULL);
>> +    if (!sync_ctx->event)
>> +        goto fail;
>> +
>> +    *psync_ctx = sync_ctx;
>> +
>> +    return 0;
>> +
>> +fail:
>> +    D3D12_OBJECT_RELEASE(sync_ctx->fence);
>> +    av_freep(&sync_ctx);
>> +    return AVERROR(EINVAL);
>> +}
>> +
>> +void av_d3d12va_sync_context_free(AVD3D12VASyncContext **psync_ctx)
>> +{
>> +    AVD3D12VASyncContext *sync_ctx;
>> +
>> +    if (!psync_ctx || !*psync_ctx)
>> +        return;
>> +
>> +    sync_ctx = *psync_ctx;
>> +
>> +    av_d3d12va_wait_idle(sync_ctx);
>> +
>> +    D3D12_OBJECT_RELEASE(sync_ctx->fence);
>> +
>> +    if (sync_ctx->event)
>> +        CloseHandle(sync_ctx->event);
>> +
>> +    av_freep(psync_ctx);
>> +}
>> +
>> +static int av_d3d12va_wait_for_fence_value(AVD3D12VASyncContext
>*sync_ctx, uint64_t fence_value)
>> +{
>> +    uint64_t completion = ID3D12Fence_GetCompletedValue(sync_ctx-
>>fence);
>> +    if (completion < fence_value) {
>> +        if (FAILED(ID3D12Fence_SetEventOnCompletion(sync_ctx->fence,
>fence_value, sync_ctx->event)))
>> +            return AVERROR(EINVAL);
>> +
>> +        WaitForSingleObjectEx(sync_ctx->event, INFINITE, FALSE);
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +int av_d3d12va_wait_idle(AVD3D12VASyncContext *ctx)
>> +{
>> +    return av_d3d12va_wait_for_fence_value(ctx, ctx->fence_value);
>> +}
>>
>
>It's a one-line function. No need to have it exposed publicly.
>
>
>> +
>> +int av_d3d12va_wait_queue_idle(AVD3D12VASyncContext *sync_ctx,
>ID3D12CommandQueue *command_queue)
>>
>
>Same here. This is more utility, rather than something which absolutely
>must be public API.
>

Going to simplify the public API by only exposing av_d3d12va_wait_for_fence_value 

>
>> +{
>> +    DX_CHECK(ID3D12CommandQueue_Signal(command_queue, sync_ctx-
>>fence, ++sync_ctx->fence_value));
>> +    return av_d3d12va_wait_idle(sync_ctx);
>> +
>> +fail:
>> +    return AVERROR(EINVAL);
>> +}
>> +
>> +static inline int create_resource(ID3D12Device *device, const
>D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES states,
>ID3D12Resource **ppResource, int is_read_back)
>> +{
>> +    D3D12_HEAP_PROPERTIES props = {
>> +        .Type                 = is_read_back ? D3D12_HEAP_TYPE_READBACK :
>D3D12_HEAP_TYPE_DEFAULT,
>> +        .CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
>> +        .MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN,
>> +        .CreationNodeMask     = 0,
>> +        .VisibleNodeMask      = 0,
>> +    };
>> +
>> +    if (FAILED(ID3D12Device_CreateCommittedResource(device, &props,
>D3D12_HEAP_FLAG_NONE, desc,
>> +        states, NULL, &IID_ID3D12Resource, ppResource)))
>> +        return AVERROR(EINVAL);
>> +
>> +    return 0;
>> +}
>> +
>> +static int d3d12va_create_staging_buffer_resource(AVHWFramesContext
>*ctx)
>> +{
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +
>> +    D3D12_RESOURCE_DESC desc = {
>> +        .Dimension          = D3D12_RESOURCE_DIMENSION_BUFFER,
>> +        .Alignment          = 0,
>> +        .Width              = 0,
>> +        .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,
>> +    };
>> +
>> +    s->luma_component_size = FFALIGN(ctx->width * (s->format ==
>DXGI_FORMAT_P010 ? 2 : 1), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
>ctx->height;
>> +    desc.Width = s->luma_component_size + (s->luma_component_size >>
>1);
>> +
>> +    return create_resource(device_hwctx->device, &desc,
>D3D12_RESOURCE_STATE_COPY_DEST, &s->staging_buffer, 1);
>> +}
>> +
>> +static int d3d12va_create_helper_objects(AVHWFramesContext *ctx)
>> +{
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +
>> +    D3D12_COMMAND_QUEUE_DESC queue_desc = {
>> +        .Type     = D3D12_COMMAND_LIST_TYPE_COPY,
>> +        .Priority = 0,
>> +        .NodeMask = 0,
>> +    };
>> +
>> +    int ret = d3d12va_create_staging_buffer_resource(ctx);
>> +    if (ret < 0)
>> +        return ret;
>> +
>> +    ret = av_d3d12va_sync_context_alloc(device_hwctx, &s->sync_ctx);
>> +    if (ret < 0)
>> +        return ret;
>> +
>> +    DX_CHECK(ID3D12Device_CreateCommandQueue(device_hwctx->device,
>&queue_desc,
>> +        &IID_ID3D12CommandQueue, &s->command_queue));
>> +
>> +    DX_CHECK(ID3D12Device_CreateCommandAllocator(device_hwctx-
>>device, queue_desc.Type,
>> +        &IID_ID3D12CommandAllocator, &s->command_allocator));
>> +
>> +    DX_CHECK(ID3D12Device_CreateCommandList(device_hwctx->device, 0,
>queue_desc.Type,
>> +        s->command_allocator, NULL, &IID_ID3D12GraphicsCommandList, &s-
>>command_list));
>> +
>> +    DX_CHECK(ID3D12GraphicsCommandList_Close(s->command_list));
>> +
>> +    ID3D12CommandQueue_ExecuteCommandLists(s->command_queue, 1,
>(ID3D12CommandList **)&s->command_list);
>> +
>> +    return av_d3d12va_wait_queue_idle(s->sync_ctx, s->command_queue);
>> +
>> +fail:
>> +    return AVERROR(EINVAL);
>> +}
>> +
>> +static void d3d12va_frames_uninit(AVHWFramesContext *ctx)
>> +{
>> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +
>> +    av_d3d12va_sync_context_free(&s->sync_ctx);
>> +
>> +    D3D12_OBJECT_RELEASE(s->staging_buffer);
>> +    D3D12_OBJECT_RELEASE(s->command_allocator);
>> +    D3D12_OBJECT_RELEASE(s->command_list);
>> +    D3D12_OBJECT_RELEASE(s->command_queue);
>> +
>> +    av_freep(&frames_hwctx->texture_infos);
>> +}
>> +
>> +static int d3d12va_frames_get_constraints(AVHWDeviceContext *ctx, const
>void *hwconfig, AVHWFramesConstraints *constraints)
>> +{
>> +    HRESULT hr;
>> +    int nb_sw_formats = 0;
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->hwctx;
>> +
>> +    constraints->valid_sw_formats =
>av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,
>> +                                                    sizeof(*constraints->valid_sw_formats));
>> +    if (!constraints->valid_sw_formats)
>> +        return AVERROR(ENOMEM);
>> +
>> +    for (int i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
>> +        D3D12_FEATURE_DATA_FORMAT_SUPPORT format_support =
>{ supported_formats[i].d3d_format };
>> +        hr = ID3D12Device_CheckFeatureSupport(device_hwctx->device,
>D3D12_FEATURE_FORMAT_SUPPORT, &format_support,
>sizeof(format_support));
>> +        if (SUCCEEDED(hr) && (format_support.Support1 &
>D3D12_FORMAT_SUPPORT1_TEXTURE2D))
>> +            constraints->valid_sw_formats[nb_sw_formats++] =
>supported_formats[i].pix_fmt;
>> +    }
>> +    constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
>> +
>> +    constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints-
>>valid_hw_formats));
>> +    if (!constraints->valid_hw_formats)
>> +        return AVERROR(ENOMEM);
>> +
>> +    constraints->valid_hw_formats[0] = AV_PIX_FMT_D3D12;
>> +    constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
>> +
>> +    return 0;
>> +}
>> +
>> +static void free_texture(void *opaque, uint8_t *data)
>> +{
>> +    AVD3D12FrameDescriptor *desc = (AVD3D12FrameDescriptor *)data;
>> +
>> +    if (desc->sync_ctx)
>> +        av_d3d12va_sync_context_free(&desc->sync_ctx);
>> +
>> +    D3D12_OBJECT_RELEASE(desc->texture);
>> +    av_freep(&data);
>> +}
>> +
>> +static AVBufferRef *wrap_texture_buf(AVHWFramesContext *ctx,
>ID3D12Resource *texture, AVD3D12VASyncContext *sync_ctx)
>> +{
>> +    AVBufferRef *buf;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
>> +
>> +    AVD3D12FrameDescriptor *desc = av_mallocz(sizeof(*desc));
>> +    if (!desc)
>> +        goto fail;
>> +
>> +    if (s->nb_surfaces <= s->nb_surfaces_used) {
>> +        frames_hwctx->texture_infos = av_realloc_f(frames_hwctx-
>>texture_infos,
>> +                                                   s->nb_surfaces_used + 1,
>> +                                                   sizeof(*frames_hwctx->texture_infos));
>> +        if (!frames_hwctx->texture_infos)
>> +            goto fail;
>> +        s->nb_surfaces = s->nb_surfaces_used + 1;
>> +    }
>>
>
>Why do you need to store texture information inside
>the hardware frames priv context at all?

This is used to fill the DPB Reflist. I think we better keep it. It's the same implementation as D3D11VA.

>
>
>> +
>> +    desc->texture  = texture;
>> +    desc->index    = s->nb_surfaces_used;
>> +    desc->sync_ctx = sync_ctx;
>> +
>> +    frames_hwctx->texture_infos[s->nb_surfaces_used].texture  = texture;
>> +    frames_hwctx->texture_infos[s->nb_surfaces_used].index    = desc-
>>index;
>> +    frames_hwctx->texture_infos[s->nb_surfaces_used].sync_ctx = sync_ctx;
>> +    s->nb_surfaces_used++;
>> +
>> +    buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture,
>texture, 0);
>> +    if (!buf)
>> +        goto fail;
>> +
>> +    return buf;
>> +
>> +fail:
>> +    D3D12_OBJECT_RELEASE(texture);
>> +    av_d3d12va_sync_context_free(&sync_ctx);
>> +    av_freep(&desc);
>> +    return NULL;
>> +}
>> +
>> +static AVBufferRef *d3d12va_pool_alloc(void *opaque, size_t size)
>> +{
>> +    AVHWFramesContext      *ctx          = (AVHWFramesContext *)opaque;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +    AVD3D12VAFramesContext *hwctx        = ctx->hwctx;
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>> +
>> +    int ret;
>> +    ID3D12Resource *texture;
>> +    AVD3D12VASyncContext *sync_ctx;
>> +
>> +    D3D12_RESOURCE_DESC desc = {
>> +        .Dimension        = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
>> +        .Alignment        = 0,
>> +        .Width            = ctx->width,
>> +        .Height           = ctx->height,
>> +        .DepthOrArraySize = 1,
>> +        .MipLevels        = 1,
>> +        .Format           = s->format,
>> +        .SampleDesc       = {.Count = 1, .Quality = 0 },
>> +        .Layout           = D3D12_TEXTURE_LAYOUT_UNKNOWN,
>> +        .Flags            = D3D12_RESOURCE_FLAG_NONE,
>> +    };
>> +
>> +    if (s->nb_surfaces_used >= ctx->initial_pool_size) {
>> +        av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
>> +        return NULL;
>> +    }
>> +
>> +    ret = create_resource(device_hwctx->device, &desc,
>D3D12_RESOURCE_STATE_COMMON, &texture, 0);
>> +    if (ret < 0)
>> +        return NULL;
>> +
>> +    ret = av_d3d12va_sync_context_alloc(device_hwctx, &sync_ctx);
>> +    if (ret < 0) {
>> +        D3D12_OBJECT_RELEASE(texture);
>> +        return NULL;
>> +    }
>> +
>> +    return wrap_texture_buf(ctx, texture, sync_ctx);
>> +}
>> +
>> +static int d3d12va_frames_init(AVHWFramesContext *ctx)
>> +{
>> +    AVD3D12VAFramesContext *hwctx        = ctx->hwctx;
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +
>> +    int i;
>> +
>> +    for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
>> +        if (ctx->sw_format == supported_formats[i].pix_fmt) {
>> +            s->format = supported_formats[i].d3d_format;
>> +            break;
>> +        }
>> +    }
>> +    if (i == FF_ARRAY_ELEMS(supported_formats)) {
>> +        av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
>> +               av_get_pix_fmt_name(ctx->sw_format));
>> +        return AVERROR(EINVAL);
>> +    }
>> +
>> +    hwctx->texture_infos = av_realloc_f(NULL, ctx->initial_pool_size,
>sizeof(*hwctx->texture_infos));
>> +    if (!hwctx->texture_infos)
>> +        return AVERROR(ENOMEM);
>> +
>> +    memset(hwctx->texture_infos, 0, ctx->initial_pool_size * sizeof(*hwctx-
>>texture_infos));
>> +    s->nb_surfaces = ctx->initial_pool_size;
>> +
>> +    ctx->internal->pool_internal =
>av_buffer_pool_init2(sizeof(AVD3D12FrameDescriptor),
>> +        ctx, d3d12va_pool_alloc, NULL);
>> +
>> +    if (!ctx->internal->pool_internal)
>> +        return AVERROR(ENOMEM);
>> +
>> +    return 0;
>> +}
>> +
>> +static int d3d12va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
>> +{
>> +    int ret;
>> +    AVD3D12FrameDescriptor *desc;
>> +
>> +    frame->buf[0] = av_buffer_pool_get(ctx->pool);
>> +    if (!frame->buf[0])
>> +        return AVERROR(ENOMEM);
>> +
>> +    ret = av_image_fill_arrays(frame->data, frame->linesize, frame->buf[0]-
>>data,
>> +        ctx->sw_format, ctx->width, ctx->height,
>D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
>> +    if (ret < 0)
>> +        return ret;
>> +
>> +    desc = (AVD3D12FrameDescriptor *)frame->buf[0]->data;
>> +    frame->data[0] = (uint8_t *)desc->texture;
>> +    frame->data[1] = (uint8_t *)desc->index;
>> +    frame->data[2] = (uint8_t *)desc->sync_ctx;
>> +
>> +    frame->format  = AV_PIX_FMT_D3D12;
>> +    frame->width   = ctx->width;
>> +    frame->height  = ctx->height;
>> +
>> +    return 0;
>> +}
>> +
>> +static int d3d12va_transfer_get_formats(AVHWFramesContext *ctx,
>> +                                        enum AVHWFrameTransferDirection dir,
>> +                                        enum AVPixelFormat **formats)
>> +{
>> +    D3D12VAFramesContext *s = ctx->internal->priv;
>> +    enum AVPixelFormat *fmts;
>> +
>> +    fmts = av_malloc_array(2, sizeof(*fmts));
>> +    if (!fmts)
>> +        return AVERROR(ENOMEM);
>> +
>> +    fmts[0] = ctx->sw_format;
>> +    fmts[1] = AV_PIX_FMT_NONE;
>> +
>> +    *formats = fmts;
>> +
>> +    return 0;
>> +}
>> +
>> +static int d3d12va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
>> +                                 const AVFrame *src)
>> +{
>> +    AVD3D12VADeviceContext *hwctx        = ctx->device_ctx->hwctx;
>> +    AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
>> +    D3D12VAFramesContext   *s            = ctx->internal->priv;
>> +
>> +    int ret;
>> +    int download = src->format == AV_PIX_FMT_D3D12;
>> +    const AVFrame *frame = download ? src : dst;
>> +    const AVFrame *other = download ? dst : src;
>> +
>> +    ID3D12Resource       *texture  = (ID3D12Resource *)      frame->data[0];
>> +    int                   index    = (intptr_t)              frame->data[1];
>> +    AVD3D12VASyncContext *sync_ctx = (AVD3D12VASyncContext *)frame-
>>data[2];
>> +
>> +    uint8_t *mapped_data;
>> +    uint8_t *data[4];
>> +    int linesizes[4];
>> +
>> +    D3D12_TEXTURE_COPY_LOCATION staging_y_location;
>> +    D3D12_TEXTURE_COPY_LOCATION staging_uv_location;
>> +
>> +    D3D12_TEXTURE_COPY_LOCATION texture_y_location = {
>> +        .pResource        = texture,
>> +        .Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
>> +        .SubresourceIndex = 0,
>> +    };
>> +
>> +    D3D12_TEXTURE_COPY_LOCATION texture_uv_location = {
>> +        .pResource        = texture,
>> +        .Type             = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX,
>> +        .SubresourceIndex = 1,
>> +    };
>> +
>> +    D3D12_RESOURCE_BARRIER barrier = {
>> +        .Type  = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
>> +        .Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE,
>> +        .Transition = {
>> +            .pResource   = texture,
>> +            .StateBefore = D3D12_RESOURCE_STATE_COMMON,
>> +            .StateAfter  = D3D12_RESOURCE_STATE_COPY_SOURCE,
>> +            .Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
>> +        }
>> +    };
>> +
>> +    s->format = av_d3d12va_map_sw_to_hw_format(ctx->sw_format);
>> +
>> +    if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx-
>>sw_format)
>> +        return AVERROR(EINVAL);
>> +
>> +    if (!s->command_queue) {
>> +        ret = d3d12va_create_helper_objects(ctx);
>> +        if (ret < 0)
>> +            return ret;
>> +    }
>> +
>> +    for (int i = 0; i < 4; i++)
>> +        linesizes[i] = FFALIGN(frame->width * (s->format ==
>DXGI_FORMAT_P010 ? 2 : 1), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
>> +
>> +    staging_y_location = (D3D12_TEXTURE_COPY_LOCATION) {
>> +        .pResource = s->staging_buffer,
>> +        .Type      = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
>> +        .PlacedFootprint = {
>> +            .Offset = 0,
>> +            .Footprint = {
>> +                .Format   = s->format == DXGI_FORMAT_P010 ?
>DXGI_FORMAT_R16_UNORM : DXGI_FORMAT_R8_UNORM,
>> +                .Width    = ctx->width,
>> +                .Height   = ctx->height,
>> +                .Depth    = 1,
>> +                .RowPitch = linesizes[0],
>> +            },
>> +        },
>> +    };
>> +
>> +    staging_uv_location = (D3D12_TEXTURE_COPY_LOCATION) {
>> +        .pResource = s->staging_buffer,
>> +        .Type      = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
>> +        .PlacedFootprint = {
>> +            .Offset = s->luma_component_size,
>> +            .Footprint = {
>> +                .Format   = s->format == DXGI_FORMAT_P010 ?
>DXGI_FORMAT_R16G16_UNORM : DXGI_FORMAT_R8G8_UNORM,
>> +                .Width    = ctx->width  >> 1,
>> +                .Height   = ctx->height >> 1,
>> +                .Depth    = 1,
>> +                .RowPitch = linesizes[0],
>> +            },
>> +        },
>> +    };
>> +
>> +    DX_CHECK(ID3D12CommandAllocator_Reset(s->command_allocator));
>> +
>> +    DX_CHECK(ID3D12GraphicsCommandList_Reset(s->command_list, s-
>>command_allocator, NULL));
>> +
>> +    if (download) {
>> +        ID3D12GraphicsCommandList_ResourceBarrier(s->command_list, 1,
>&barrier);
>> +
>> +        ID3D12GraphicsCommandList_CopyTextureRegion(s->command_list,
>> +            &staging_y_location, 0, 0, 0, &texture_y_location, NULL);
>> +
>> +        ID3D12GraphicsCommandList_CopyTextureRegion(s->command_list,
>> +            &staging_uv_location, 0, 0, 0, &texture_uv_location, NULL);
>> +
>> +        barrier.Transition.StateBefore = barrier.Transition.StateAfter;
>> +        barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_COMMON;
>> +        ID3D12GraphicsCommandList_ResourceBarrier(s->command_list, 1,
>&barrier);
>> +
>> +        DX_CHECK(ID3D12GraphicsCommandList_Close(s->command_list));
>> +
>> +        if (!hwctx->sync)
>> +            DX_CHECK(ID3D12CommandQueue_Wait(s->command_queue,
>sync_ctx->fence, sync_ctx->fence_value));
>> +
>> +        ID3D12CommandQueue_ExecuteCommandLists(s->command_queue,
>1, (ID3D12CommandList **)&s->command_list);
>> +
>> +        ret = av_d3d12va_wait_queue_idle(s->sync_ctx, s->command_queue);
>> +        if (ret)
>> +            return ret;
>> +
>> +        DX_CHECK(ID3D12Resource_Map(s->staging_buffer, 0, NULL,
>&mapped_data));
>> +        av_image_fill_pointers(data, ctx->sw_format, ctx->height,
>mapped_data, linesizes);
>> +
>> +        av_image_copy(dst->data, dst->linesize, data, linesizes,
>> +            ctx->sw_format, ctx->width, ctx->height);
>> +
>> +        ID3D12Resource_Unmap(s->staging_buffer, 0, NULL);
>> +    } else {
>> +        av_log(ctx, AV_LOG_ERROR, "Transfer data to AV_PIX_FMT_D3D12 is
>not supported yet!\n");
>> +        return AVERROR(EINVAL);
>>
>
>You should implement this, if only for debugging. Many vendors don't
>handle all pixel formats correctly, especially for video so being able to
>upload would help in debugging.
>

Yes agreed. Upload needs to be implemented later. I'd like to implement it along with encoder support in the following patch set.

>
>> +    }
>> +
>> +    return 0;
>> +
>> +fail:
>> +    return AVERROR(EINVAL);
>> +}
>> +
>> +static int d3d12va_device_init(AVHWDeviceContext *hwdev)
>> +{
>> +    AVD3D12VADeviceContext *ctx = hwdev->hwctx;
>> +
>> +    if (!ctx->video_device)
>> +        DX_CHECK(ID3D12Device_QueryInterface(ctx->device,
>&IID_ID3D12VideoDevice, (void **)&ctx->video_device));
>> +
>> +    return 0;
>> +
>> +fail:
>> +    return AVERROR(EINVAL);
>> +}
>> +
>> +static void d3d12va_device_uninit(AVHWDeviceContext *hwdev)
>> +{
>> +    AVD3D12VADeviceContext *device_hwctx = hwdev->hwctx;
>> +
>> +    D3D12_OBJECT_RELEASE(device_hwctx->video_device);
>> +    D3D12_OBJECT_RELEASE(device_hwctx->device);
>> +}
>> +
>> +static int d3d12va_device_create(AVHWDeviceContext *ctx, const char
>*device,
>> +                                 AVDictionary *opts, int flags)
>> +{
>> +    AVD3D12VADeviceContext *device_hwctx = ctx->hwctx;
>> +
>> +    HRESULT hr;
>> +    UINT create_flags = 0;
>> +    IDXGIAdapter *pAdapter = NULL;
>> +
>> +    int ret;
>> +    int is_debug       = !!av_dict_get(opts, "debug", NULL, 0);
>> +    device_hwctx->sync = !!av_dict_get(opts, "sync",  NULL, 0);
>> +
>> +    if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
>> +        return AVERROR_UNKNOWN;
>> +
>> +    if (is_debug) {
>> +        ID3D12Debug *pDebug;
>> +        if (d3d12va_get_debug_interface &&
>SUCCEEDED(d3d12va_get_debug_interface(&IID_ID3D12Debug, &pDebug))) {
>> +            create_flags |= DXGI_CREATE_FACTORY_DEBUG;
>> +            ID3D12Debug_EnableDebugLayer(pDebug);
>> +            D3D12_OBJECT_RELEASE(pDebug);
>> +            av_log(ctx, AV_LOG_INFO, "D3D12 debug layer is enabled!\n");
>> +        }
>> +    }
>> +
>> +    if (!device_hwctx->device) {
>> +        IDXGIFactory2 *pDXGIFactory = NULL;
>> +
>> +        if (!d3d12va_create_device || !d3d12va_create_dxgi_factory2) {
>> +            av_log(ctx, AV_LOG_ERROR, "Failed to load D3D12 library or its
>functions\n");
>> +            return AVERROR_UNKNOWN;
>> +        }
>> +
>> +        hr = d3d12va_create_dxgi_factory2(create_flags, &IID_IDXGIFactory2,
>(void **)&pDXGIFactory);
>> +        if (SUCCEEDED(hr)) {
>> +            int adapter = device ? atoi(device) : 0;
>> +            if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter,
>&pAdapter)))
>> +                pAdapter = NULL;
>> +            IDXGIFactory2_Release(pDXGIFactory);
>> +        }
>> +
>> +        if (pAdapter) {
>> +            DXGI_ADAPTER_DESC desc;
>> +            hr = IDXGIAdapter2_GetDesc(pAdapter, &desc);
>> +            if (!FAILED(hr)) {
>> +                av_log(ctx, AV_LOG_INFO, "Using device %04x:%04x (%ls).\n",
>> +                       desc.VendorId, desc.DeviceId, desc.Description);
>> +            }
>> +        }
>> +
>> +        hr = d3d12va_create_device((IUnknown *)pAdapter,
>D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, &device_hwctx->device);
>> +        D3D12_OBJECT_RELEASE(pAdapter);
>> +        if (FAILED(hr)) {
>> +            av_log(ctx, AV_LOG_ERROR, "Failed to create DirectX3D 12 device
>(%lx)\n", (long)hr);
>> +            return AVERROR_UNKNOWN;
>> +        }
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +const HWContextType ff_hwcontext_type_d3d12va = {
>> +    .type                   = AV_HWDEVICE_TYPE_D3D12VA,
>> +    .name                   = "D3D12VA",
>> +
>> +    .device_hwctx_size      = sizeof(AVD3D12VADeviceContext),
>> +    .frames_hwctx_size      = sizeof(AVD3D12VAFramesContext),
>> +    .frames_priv_size       = sizeof(D3D12VAFramesContext),
>> +
>> +    .device_create          = d3d12va_device_create,
>> +    .device_init            = d3d12va_device_init,
>> +    .device_uninit          = d3d12va_device_uninit,
>> +    .frames_get_constraints = d3d12va_frames_get_constraints,
>> +    .frames_init            = d3d12va_frames_init,
>> +    .frames_uninit          = d3d12va_frames_uninit,
>> +    .frames_get_buffer      = d3d12va_get_buffer,
>> +    .transfer_get_formats   = d3d12va_transfer_get_formats,
>> +    .transfer_data_to       = d3d12va_transfer_data,
>> +    .transfer_data_from     = d3d12va_transfer_data,
>> +
>> +    .pix_fmts               = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D12,
>AV_PIX_FMT_NONE },
>> +};
>> diff --git a/libavutil/hwcontext_d3d12va.h b/libavutil/hwcontext_d3d12va.h
>> new file mode 100644
>> index 0000000000..740e460453
>> --- /dev/null
>> +++ b/libavutil/hwcontext_d3d12va.h
>> @@ -0,0 +1,169 @@
>> +/*
>> + * Direct3D 12 HW acceleration.
>> + *
>> + * 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
>> + */
>> +
>> +#ifndef AVUTIL_HWCONTEXT_D3D12VA_H
>> +#define AVUTIL_HWCONTEXT_D3D12VA_H
>> +
>> +/**
>> + * @file
>> + * An API-specific header for AV_HWDEVICE_TYPE_D3D12VA.
>> + *
>> + * This API does not support dynamic frame pools.
>AVHWFramesContext.pool must
>> + * contain AVBufferRefs whose data pointer points to an
>AVD3D12FrameDescriptor struct.
>> + */
>> +#include <stdint.h>
>> +#include <initguid.h>
>> +#include <d3d12.h>
>> +#include <d3d12video.h>
>> +
>> +/**
>> + * @brief This struct is allocated as AVHWDeviceContext.hwctx
>> + *
>> + */
>> +typedef struct AVD3D12VADeviceContext {
>> +    /**
>> +     * Device used for objects creation and access. This can also be
>> +     * used to set the libavcodec decoding device.
>> +     *
>> +     * Can be set by the user. This is the only mandatory field - the other
>> +     * device context fields are set from this and are available for
>convenience.
>> +     *
>> +     * Deallocating the AVHWDeviceContext will always release this interface,
>> +     * and it does not matter whether it was user-allocated.
>> +     */
>> +    ID3D12Device *device;
>> +
>> +    /**
>> +     * If unset, this will be set from the device field on init.
>> +     *
>> +     * Deallocating the AVHWDeviceContext will always release this interface,
>> +     * and it does not matter whether it was user-allocated.
>> +     */
>> +    ID3D12VideoDevice *video_device;
>> +
>> +    /**
>> +     * Specifed by sync=1 when init d3d12va
>> +     *
>> +     * Execute commands as sync mode
>> +     */
>> +    int sync;
>> +} AVD3D12VADeviceContext;
>> +
>> +/**
>> + * @brief This struct is used to sync d3d12 execution
>> + *
>> + */
>> +typedef struct AVD3D12VASyncContext {
>> +    /**
>> +     * D3D12 fence object
>> +     */
>> +    ID3D12Fence *fence;
>> +
>> +    /**
>> +     * A handle to the event object
>> +     */
>> +    HANDLE event;
>> +
>> +    /**
>> +     * The fence value used for sync
>> +     */
>> +    uint64_t fence_value;
>> +} AVD3D12VASyncContext;
>> +
>> +/**
>> + * @brief D3D12 frame descriptor for pool allocation.
>> + *
>> + */
>> +typedef struct AVD3D12FrameDescriptor {
>> +    /**
>> +     * The texture in which the frame is located. The reference count is
>> +     * managed by the AVBufferRef, and destroying the reference will release
>> +     * the interface.
>> +     *
>> +     * Normally stored in AVFrame.data[0].
>> +     */
>> +    ID3D12Resource *texture;
>> +
>> +    /**
>> +     * The index into the array texture element representing the frame
>> +     *
>> +     * Normally stored in AVFrame.data[1] (cast from intptr_t).
>> +     */
>> +    intptr_t index;
>> +
>> +    /**
>> +     * The sync context for the texture
>> +     *
>> +     * Use av_d3d12va_wait_idle(sync_ctx) to ensure the decoding or
>encoding have been finised
>> +     * @see: https://learn.microsoft.com/en-
>us/windows/win32/medfound/direct3d-12-video-overview#directx-12-fences
>> +     *
>> +     * Normally stored in AVFrame.data[2].
>> +     */
>> +    AVD3D12VASyncContext *sync_ctx;
>> +} AVD3D12FrameDescriptor;
>> +
>> +/**
>> + * @brief This struct is allocated as AVHWFramesContext.hwctx
>> + *
>> + */
>> +typedef struct AVD3D12VAFramesContext {
>> +    /**
>> +     * The same implementation as d3d11va
>> +     * This field is not able to be user-allocated at the present.
>> +     */
>> +    AVD3D12FrameDescriptor *texture_infos;
>> +} AVD3D12VAFramesContext;
>> +
>> +/**
>> + * @brief Map sw pixel format to d3d12 format
>> + *
>> + * @return d3d12 specified format
>> + */
>> +DXGI_FORMAT av_d3d12va_map_sw_to_hw_format(enum AVPixelFormat
>pix_fmt);
>> +
>> +/**
>> + * @brief Allocate an AVD3D12VASyncContext
>> + *
>> + * @return Error code (ret < 0 if failed)
>> + */
>> +int av_d3d12va_sync_context_alloc(AVD3D12VADeviceContext *ctx,
>AVD3D12VASyncContext **sync_ctx);
>> +
>> +/**
>> + * @brief Free an AVD3D12VASyncContext
>> + */
>> +void av_d3d12va_sync_context_free(AVD3D12VASyncContext **sync_ctx);
>>
>
>Any reason why this should be allocated dynamically?
>We can always add new fields without bumping the ABI.
>
>
>> +
>> +/**
>> + * @brief Wait for the sync context to the idle state
>> + *
>> + * @return Error code (ret < 0 if failed)
>> + */
>> +int av_d3d12va_wait_idle(AVD3D12VASyncContext *sync_ctx);
>> +
>> +/**
>> + * @brief Wait for a specified command queue to the idle state
>> + *
>> + * @return Error code (ret < 0 if failed)
>> + */
>> +int av_d3d12va_wait_queue_idle(AVD3D12VASyncContext *sync_ctx,
>ID3D12CommandQueue *command_queue);
>> +
>> +#endif /* AVUTIL_HWCONTEXT_D3D12VA_H */
>> diff --git a/libavutil/hwcontext_d3d12va_internal.h
>b/libavutil/hwcontext_d3d12va_internal.h
>> new file mode 100644
>> index 0000000000..bfd89b3545
>> --- /dev/null
>> +++ b/libavutil/hwcontext_d3d12va_internal.h
>> @@ -0,0 +1,59 @@
>> +/*
>> + * Direct3D 12 HW acceleration.
>> + *
>> + * 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
>> + */
>> +
>> +#ifndef AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H
>> +#define AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H
>> +
>> +/**
>> + * @def COBJMACROS
>> + *
>> + * @brief Enable C style interface for D3D12
>> + */
>> +#ifndef COBJMACROS
>> +#define COBJMACROS
>> +#endif
>> +
>> +/**
>> + * @def DX_CHECK
>> + *
>> + * @brief A check macro used by D3D12 functions highly frequently
>> + */
>> +#define DX_CHECK(hr)                              \
>> +    do {                                          \
>> +        if (FAILED(hr))                           \
>> +            goto fail;                            \
>> +    } while (0)
>> +
>> +/**
>> + * @def D3D12_OBJECT_RELEASE
>> + *
>> + * @brief A release macro used by D3D12 objects highly frequently
>> + */
>> +#define D3D12_OBJECT_RELEASE(pInterface)              \
>> +    do {                                              \
>> +        if (pInterface) {                             \
>> +            IUnknown_Release((IUnknown *)pInterface); \
>> +            pInterface = NULL;                        \
>> +        }                                             \
>> +    } while (0)
>> +
>> +#endif /* AVUTIL_HWCONTEXT_D3D12VA_INTERNAL_H */
>> \ No newline at end of file
>> diff --git a/libavutil/hwcontext_internal.h b/libavutil/hwcontext_internal.h
>> index e6266494ac..4df516ee6a 100644
>> --- a/libavutil/hwcontext_internal.h
>> +++ b/libavutil/hwcontext_internal.h
>> @@ -165,6 +165,7 @@ int ff_hwframe_map_replace(AVFrame *dst, const
>AVFrame *src);
>>
>>  extern const HWContextType ff_hwcontext_type_cuda;
>>  extern const HWContextType ff_hwcontext_type_d3d11va;
>> +extern const HWContextType ff_hwcontext_type_d3d12va;
>>  extern const HWContextType ff_hwcontext_type_drm;
>>  extern const HWContextType ff_hwcontext_type_dxva2;
>>  extern const HWContextType ff_hwcontext_type_opencl;
>> diff --git a/libavutil/pixdesc.c b/libavutil/pixdesc.c
>> index e1e0dd2a9e..09fca5ef19 100644
>> --- a/libavutil/pixdesc.c
>> +++ b/libavutil/pixdesc.c
>> @@ -2283,6 +2283,10 @@ static const AVPixFmtDescriptor
>av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
>>  .name = "d3d11",
>>  .flags = AV_PIX_FMT_FLAG_HWACCEL,
>>  },
>> +    [AV_PIX_FMT_D3D12] = {
>> +        .name = "d3d12",
>> +        .flags = AV_PIX_FMT_FLAG_HWACCEL,
>> +    },
>>  [AV_PIX_FMT_GBRPF32BE] = {
>>  .name = "gbrpf32be",
>>  .nb_components = 3,
>> diff --git a/libavutil/pixfmt.h b/libavutil/pixfmt.h
>> index 63e07ba64f..1f0ab2a23c 100644
>> --- a/libavutil/pixfmt.h
>> +++ b/libavutil/pixfmt.h
>> @@ -426,6 +426,15 @@ enum AVPixelFormat {
>>  AV_PIX_FMT_P412BE,      ///< interleaved chroma YUV 4:4:4, 36bpp, data in
>the high bits, big-endian
>>  AV_PIX_FMT_P412LE,      ///< interleaved chroma YUV 4:4:4, 36bpp, data in
>the high bits, little-endian
>>
>> +    /**
>> +     * Hardware surfaces for Direct3D 12.
>> +     *
>> +     * data[0] contains a ID3D12Resource pointer.
>> +     * data[1] contains the resource array index of the frame as intptr_t.
>> +     * data[2] contains the sync context for current resource
>> +     */
>> +    AV_PIX_FMT_D3D12,
>>
>
>Folding all three into a single structure would be more flexible
>towards API users, who, for example, may want to have different
>textures with different sync contexts for each.

This design is aligned with d3d11va. Thought it could be acceptable.

>
>
>> +
>>  AV_PIX_FMT_NB         ///< number of pixel formats, DO NOT USE THIS if you
>want to link with shared libav* because the number of formats might differ
>between versions
>>  };
>>
>> diff --git a/libavutil/tests/hwdevice.c b/libavutil/tests/hwdevice.c
>> index c57586613a..9d7964f9ee 100644
>> --- a/libavutil/tests/hwdevice.c
>> +++ b/libavutil/tests/hwdevice.c
>> @@ -137,6 +137,8 @@ static const struct {
>>  { "0", "1", "2" } },
>>  { AV_HWDEVICE_TYPE_D3D11VA,
>>  { "0", "1", "2" } },
>> +    { AV_HWDEVICE_TYPE_D3D12VA,
>> +      { "0", "1", "2" } },
>>  { AV_HWDEVICE_TYPE_OPENCL,
>>  { "0.0", "0.1", "1.0", "1.1" } },
>>  { AV_HWDEVICE_TYPE_VAAPI,
>> diff --git a/libavutil/version.h b/libavutil/version.h
>> index 24af520e08..9e798b0e3f 100644
>> --- a/libavutil/version.h
>> +++ b/libavutil/version.h
>> @@ -79,7 +79,7 @@
>>  */
>>
>>  #define LIBAVUTIL_VERSION_MAJOR  58
>> -#define LIBAVUTIL_VERSION_MINOR  14
>> +#define LIBAVUTIL_VERSION_MINOR  15
>>  #define LIBAVUTIL_VERSION_MICRO 100
>>
>
>Just a preliminary look. I don't think this should be in 6.1, we're already late,
>and no external users of the API exist yet to make sure it's usable.
>
>I still disagree with the lack of a dynamic frame allocation system (using
>frame pools). It's not a lot of code, and it improves usability significantly,
>as without this, it's not possible to implement anything but simple and
>direct display of frames, as quickly as possible. Filtering, for example,
>would definitely run up against the limit, as filters in general carry
>on using the frames context they receive, if they are able to.

It doesn't matter to me it should be in 6.1 or later. Will fix the mentioned comments and send V6 later. Currently d3d11va lacks of dynamic frame allocation either. It definitely should be implemented for d3d12va. But I think for this decoder patch set it's already functionally workable so I prefer to add it in later patches.

Thanks,
Tong

>_______________________________________________
>ffmpeg-devel mailing list
>ffmpeg-devel@ffmpeg.org
>https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
>
>To unsubscribe, visit link above, or email
>ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".