From: "Wu, Tong1" <tong1.wu-at-intel.com@ffmpeg.org>
To: FFmpeg development discussions and patches <ffmpeg-devel@ffmpeg.org>
Subject: Re: [FFmpeg-devel] [PATCH v12 1/9] libavutil: add hwcontext_d3d12va and AV_PIX_FMT_D3D12
Date: Thu, 21 Dec 2023 11:38:32 +0000
Message-ID: <SN6PR11MB2990539FC2F4999C4AEB514AC095A@SN6PR11MB2990.namprd11.prod.outlook.com> (raw)
In-Reply-To: <NmAamwk--3-9@lynne.ee>
>There are still no public external API users to actually test the API,
>which is concerning. It took months for the Vulkan API to be portable
>enough to work with the major Vulkan users out there. Granted, Vulkan
>is special.
>
>Is there any public test code out there? If not, I'd prefer the API to be
>declared as experimental for now, so we can make changes if needed.
>
Actually there have already been a number of discussions on this before for VLC and MPV.
https://code.videolan.org/videolan/vlc/-/issues/28360
https://github.com/mpv-player/mpv/issues/12071
Some have tried by themselves and it's working well. Since it cannot be official and public before it lands in FFmpeg, I believe it's probably very soon to have d3d12 hwdec support for them.
Thanks,
Tong
>Dec 21, 2023, 09:31 by haihao.xiang-at-intel.com@ffmpeg.org:
>
>> On Ma, 2023-12-18 at 06:28 +0000, Xiang, Haihao wrote:
>>
>>> On Di, 2023-12-05 at 14:46 +0800, Tong Wu wrote:
>>> > From: Wu Jianhua <toqsxw@outlook.com>
>>> >
>>> > Signed-off-by: Wu Jianhua <toqsxw@outlook.com>
>>> > Signed-off-by: Tong Wu <tong1.wu@intel.com>
>>> > ---
>>> >
>>> > Compared to v11, v12 set the initial value to 0 for the fence value,
>>> > fixing a potential dynamic pool sync issue. Hence removed the non zero
>>> > initial_pool_size for
>>> > d3d12va decoder.
>>> >
>>> > Some other minor error message changes.
>>> >
>>> >
>>> >
>>> > configure | 5 +
>>> > doc/APIchanges | 5 +
>>> > libavutil/Makefile | 3 +
>>> > libavutil/hwcontext.c | 4 +
>>> > libavutil/hwcontext.h | 1 +
>>> > libavutil/hwcontext_d3d12va.c | 703 +++++++++++++++++++++++++
>>> > libavutil/hwcontext_d3d12va.h | 134 +++++
>>> > libavutil/hwcontext_d3d12va_internal.h | 59 +++
>>> > libavutil/hwcontext_internal.h | 1 +
>>> > libavutil/pixdesc.c | 4 +
>>> > libavutil/pixfmt.h | 7 +
>>> > libavutil/tests/hwdevice.c | 2 +
>>> > libavutil/version.h | 2 +-
>>> > 13 files changed, 929 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 d77c053226..1a343ac6b9 100755
>>> > --- a/configure
>>> > +++ b/configure
>>> > @@ -336,6 +336,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
>>> > @@ -3048,6 +3050,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"
>>> > @@ -6575,6 +6578,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 4a2dc1c44f..0435926d80 100644
>>> > --- a/doc/APIchanges
>>> > +++ b/doc/APIchanges
>>> > @@ -2,6 +2,11 @@ The last version increases of all libraries were on
>2023-
>>> > 02-
>>> > 09
>>> >
>>> > API changes, most recent first:
>>> >
>>> > +2023-11-07 - xxxxxxxxxx - lavu 58.33.100 - pixfmt.h hwcontext.h
>>> > hwcontext_d3d12va.h
>>> > + Add AV_HWDEVICE_TYPE_D3D12VA and AV_PIX_FMT_D3D12.
>>> > + Add AVD3D12VADeviceContext, AVD3D12VASyncContext,
>AVD3D12VAFrame and
>>> > + AVD3D12VAFramesContext.
>>> > +
>>> > 2023-11-08 - b82957a66a7 - lavu 58.32.100 - channel_layout.h
>>> > Add AV_CH_LAYOUT_7POINT2POINT3 and
>AV_CHANNEL_LAYOUT_7POINT2POINT3.
>>> > Add AV_CH_LAYOUT_9POINT1POINT4_BACK and
>>> > AV_CHANNEL_LAYOUT_9POINT1POINT4_BACK.
>>> > diff --git a/libavutil/Makefile b/libavutil/Makefile
>>> > index 4711f8cde8..6a8566f1d9 100644
>>> > --- a/libavutil/Makefile
>>> > +++ b/libavutil/Makefile
>>> > @@ -42,6 +42,7 @@ HEADERS =
>>> > adler32.h \
>>> > hwcontext.h \
>>> > hwcontext_cuda.h \
>>> > hwcontext_d3d11va.h \
>>> > + hwcontext_d3d12va.h \
>>> > hwcontext_drm.h \
>>> > hwcontext_dxva2.h \
>>> > hwcontext_qsv.h \
>>> > @@ -190,6 +191,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
>>> > @@ -213,6 +215,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 3650d4653a..e23bad230f 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..1600d94cb0
>>> > --- /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);
>>> > +
>>> > +typedef struct D3D12VAFramesContext {
>>> > + ID3D12Resource *staging_download_buffer;
>>> > + ID3D12Resource *staging_upload_buffer;
>>> > + ID3D12CommandQueue *command_queue;
>>> > + ID3D12CommandAllocator *command_allocator;
>>> > + ID3D12GraphicsCommandList *command_list;
>>> > + AVD3D12VASyncContext sync_ctx;
>>> > + UINT luma_component_size;
>>> > +} D3D12VAFramesContext;
>>> > +
>>> > +typedef struct D3D12VADevicePriv {
>>> > + HANDLE d3d12lib;
>>> > + HANDLE dxgilib;
>>> > + PFN_CREATE_DXGI_FACTORY2 create_dxgi_factory2;
>>> > + PFN_D3D12_CREATE_DEVICE create_device;
>>> > + PFN_D3D12_GET_DEBUG_INTERFACE get_debug_interface;
>>> > +} D3D12VADevicePriv;
>>> > +
>>> > +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 },
>>> > +};
>>> > +
>>> > +static void d3d12va_default_lock(void *ctx)
>>> > +{
>>> > + WaitForSingleObjectEx(ctx, INFINITE, FALSE);
>>> > +}
>>> > +
>>> > +static void d3d12va_default_unlock(void *ctx)
>>> > +{
>>> > + ReleaseMutex(ctx);
>>> > +}
>>> > +
>>> > +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;
>>> > + }
>>> > +}
>>> > +
>>> > +static int d3d12va_fence_completion(AVD3D12VASyncContext
>*psync_ctx)
>>> > +{
>>> > + uint64_t completion = ID3D12Fence_GetCompletedValue(psync_ctx-
>>fence);
>>> > + if (completion < psync_ctx->fence_value) {
>>> > + if (FAILED(ID3D12Fence_SetEventOnCompletion(psync_ctx->fence,
>>> > psync_ctx->fence_value, psync_ctx->event)))
>>> > + return AVERROR(EINVAL);
>>> > +
>>> > + WaitForSingleObjectEx(psync_ctx->event, INFINITE, FALSE);
>>> > + }
>>> > +
>>> > + return 0;
>>> > +}
>>> > +
>>> > +static inline int d3d12va_wait_queue_idle(AVD3D12VASyncContext
>*psync_ctx,
>>> > ID3D12CommandQueue *command_queue)
>>> > +{
>>> > + DX_CHECK(ID3D12CommandQueue_Signal(command_queue,
>psync_ctx->fence,
>>> > ++psync_ctx->fence_value));
>>> > + return d3d12va_fence_completion(psync_ctx);
>>> > +
>>> > +fail:
>>> > + return AVERROR(EINVAL);
>>> > +}
>>> > +
>>> > +static int d3d12va_create_staging_buffer_resource(AVHWFramesContext
>*ctx,
>>> > D3D12_RESOURCE_STATES states,
>>> > + ID3D12Resource
>>> > **ppResource, int download)
>>> > +{
>>> > + AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>>> > + D3D12VAFramesContext *s = ctx->internal->priv;
>>> > + D3D12_HEAP_PROPERTIES props = { .Type = download ?
>>> > D3D12_HEAP_TYPE_READBACK : D3D12_HEAP_TYPE_UPLOAD };
>>> > + D3D12_RESOURCE_DESC desc = {
>>> > + .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
>>> > + .Alignment = 0,
>>> > + .Width = s->luma_component_size + (s-
>>> > > luma_component_size >> 1),
>>> > + .Height = 1,
>>> > + .DepthOrArraySize = 1,
>>> > + .MipLevels = 1,
>>> > + .Format = DXGI_FORMAT_UNKNOWN,
>>> > + .SampleDesc = { .Count = 1, .Quality = 0 },
>>> > + .Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
>>> > + .Flags = D3D12_RESOURCE_FLAG_NONE,
>>> > + };
>>> > +
>>> > + if (FAILED(ID3D12Device_CreateCommittedResource(device_hwctx-
>>device,
>>> > &props, D3D12_HEAP_FLAG_NONE, &desc,
>>> > + states, NULL, &IID_ID3D12Resource, (void **)ppResource))) {
>>> > + av_log(ctx, AV_LOG_ERROR, "Could not create the staging buffer
>>> > resource\n");
>>> > + return AVERROR_UNKNOWN;
>>> > + }
>>> > +
>>> > + return 0;
>>> > +}
>>> > +
>>> > +static int d3d12va_create_helper_objects(AVHWFramesContext *ctx)
>>> > +{
>>> > + AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>>> > + AVD3D12VAFramesContext *frames_hwctx = ctx->hwctx;
>>> > + D3D12VAFramesContext *s = ctx->internal->priv;
>>> > +
>>> > + D3D12_COMMAND_QUEUE_DESC queue_desc = {
>>> > + .Type = D3D12_COMMAND_LIST_TYPE_COPY,
>>> > + .Priority = 0,
>>> > + .NodeMask = 0,
>>> > + };
>>> > +
>>> > + s->luma_component_size = FFALIGN(ctx->width * (frames_hwctx-
>>format ==
>>> > DXGI_FORMAT_P010 ? 2 : 1),
>>> > + D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) *
>>> > ctx->height;
>>> > +
>>> > + DX_CHECK(ID3D12Device_CreateFence(device_hwctx->device, 0,
>>> > D3D12_FENCE_FLAG_NONE,
>>> > + &IID_ID3D12Fence, (void **)&s-
>>> > > sync_ctx.fence));
>>> > +
>>> > + s->sync_ctx.event = CreateEvent(NULL, FALSE, FALSE, NULL);
>>> > + if (!s->sync_ctx.event)
>>> > + goto fail;
>>> > +
>>> > + DX_CHECK(ID3D12Device_CreateCommandQueue(device_hwctx-
>>device,
>>> > &queue_desc,
>>> > + &IID_ID3D12CommandQueue, (void **)&s->command_queue));
>>> > +
>>> > + DX_CHECK(ID3D12Device_CreateCommandAllocator(device_hwctx-
>>device,
>>> > queue_desc.Type,
>>> > + &IID_ID3D12CommandAllocator, (void **)&s-
>>command_allocator));
>>> > +
>>> > + DX_CHECK(ID3D12Device_CreateCommandList(device_hwctx->device,
>0,
>>> > queue_desc.Type,
>>> > + s->command_allocator, NULL,
>&IID_ID3D12GraphicsCommandList,
>>> > (void **)&s->command_list));
>>> > +
>>> > + DX_CHECK(ID3D12GraphicsCommandList_Close(s->command_list));
>>> > +
>>> > + ID3D12CommandQueue_ExecuteCommandLists(s->command_queue,
>1,
>>> > (ID3D12CommandList **)&s->command_list);
>>> > +
>>> > + return 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;
>>> > +
>>> > + D3D12_OBJECT_RELEASE(s->sync_ctx.fence);
>>> > + if (s->sync_ctx.event)
>>> > + CloseHandle(s->sync_ctx.event);
>>> > +
>>> > + D3D12_OBJECT_RELEASE(s->staging_download_buffer);
>>> > + D3D12_OBJECT_RELEASE(s->staging_upload_buffer);
>>> > + D3D12_OBJECT_RELEASE(s->command_allocator);
>>> > + D3D12_OBJECT_RELEASE(s->command_list);
>>> > + D3D12_OBJECT_RELEASE(s->command_queue);
>>> > +}
>>> > +
>>> > +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)
>>> > +{
>>> > + AVD3D12VAFrame *frame = (AVD3D12VAFrame *)data;
>>> > +
>>> > + D3D12_OBJECT_RELEASE(frame->texture);
>>> > + D3D12_OBJECT_RELEASE(frame->sync_ctx.fence);
>>> > + if (frame->sync_ctx.event)
>>> > + CloseHandle(frame->sync_ctx.event);
>>> > +
>>> > + av_freep(&data);
>>> > +}
>>> > +
>>> > +static AVBufferRef *d3d12va_pool_alloc(void *opaque, size_t size)
>>> > +{
>>> > + AVHWFramesContext *ctx = (AVHWFramesContext *)opaque;
>>> > + AVD3D12VAFramesContext *hwctx = ctx->hwctx;
>>> > + AVD3D12VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
>>> > +
>>> > + AVBufferRef *buf;
>>> > + AVD3D12VAFrame *frame;
>>> > + D3D12_HEAP_PROPERTIES props = { .Type =
>D3D12_HEAP_TYPE_DEFAULT };
>>> > + D3D12_RESOURCE_DESC desc = {
>>> > + .Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D,
>>> > + .Alignment = 0,
>>> > + .Width = ctx->width,
>>> > + .Height = ctx->height,
>>> > + .DepthOrArraySize = 1,
>>> > + .MipLevels = 1,
>>> > + .Format = hwctx->format,
>>> > + .SampleDesc = {.Count = 1, .Quality = 0 },
>>> > + .Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN,
>>> > + .Flags = D3D12_RESOURCE_FLAG_NONE,
>>> > + };
>>> > +
>>> > + frame = av_mallocz(sizeof(AVD3D12VAFrame));
>>> > + if (!frame)
>>> > + return NULL;
>>> > +
>>> > + if (FAILED(ID3D12Device_CreateCommittedResource(device_hwctx-
>>device,
>>> > &props, D3D12_HEAP_FLAG_NONE, &desc,
>>> > + D3D12_RESOURCE_STATE_COMMON, NULL, &IID_ID3D12Resource,
>(void
>>> > **)&frame->texture))) {
>>> > + av_log(ctx, AV_LOG_ERROR, "Could not create the texture\n");
>>> > + goto fail;
>>> > + }
>>> > +
>>> > + DX_CHECK(ID3D12Device_CreateFence(device_hwctx->device, 0,
>>> > D3D12_FENCE_FLAG_NONE,
>>> > + &IID_ID3D12Fence, (void **)&frame-
>>> > > sync_ctx.fence));
>>> > +
>>> > + frame->sync_ctx.event = CreateEvent(NULL, FALSE, FALSE, NULL);
>>> > + if (!frame->sync_ctx.event)
>>> > + goto fail;
>>> > +
>>> > + buf = av_buffer_create((uint8_t *)frame, sizeof(frame), free_texture,
>>> > NULL, 0);
>>> > + if (!buf)
>>> > + goto fail;
>>> > +
>>> > + return buf;
>>> > +
>>> > +fail:
>>> > + free_texture(NULL, (uint8_t *)frame);
>>> > + return NULL;
>>> > +}
>>> > +
>>> > +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) {
>>> > + if (hwctx->format != DXGI_FORMAT_UNKNOWN &&
>>> > + hwctx->format != supported_formats[i].d3d_format)
>>> > + av_log(ctx, AV_LOG_WARNING, "Incompatible DXGI format
>>> > provided by user, will be overided\n");
>>> > + hwctx->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);
>>> > + }
>>> > +
>>> > + ctx->internal->pool_internal =
>>> > av_buffer_pool_init2(sizeof(AVD3D12VAFrame),
>>> > + 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;
>>> > +
>>> > + 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, NULL,
>>> > + ctx->sw_format, ctx->width, ctx->height,
>>> > + D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
>>> > + if (ret < 0)
>>> > + return ret;
>>> > +
>>> > + frame->data[0] = frame->buf[0]->data;
>>> > + 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;
>>> > +
>>> > + AVD3D12VAFrame *f = (AVD3D12VAFrame *)frame->data[0];
>>> > + ID3D12Resource *texture = (ID3D12Resource *)f->texture;
>>> > +
>>> > + uint8_t *mapped_data;
>>> > + uint8_t *data[4];
>>> > + int linesizes[4];
>>> > +
>>> > + D3D12_TEXTURE_COPY_LOCATION staging_y_location = { 0 };
>>> > + D3D12_TEXTURE_COPY_LOCATION staging_uv_location = { 0 };
>>> > +
>>> > + 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 = download ?
>D3D12_RESOURCE_STATE_COPY_SOURCE :
>>> > D3D12_RESOURCE_STATE_COPY_DEST,
>>> > + .Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES,
>>> > + },
>>> > + };
>>> > +
>>> > + if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format !=
>>> > ctx-
>>> > > sw_format)
>>> > + return AVERROR(EINVAL);
>>> > +
>>> > + hwctx->lock(hwctx->lock_ctx);
>>> > +
>>> > + if (!s->command_queue) {
>>> > + ret = d3d12va_create_helper_objects(ctx);
>>> > + if (ret < 0)
>>> > + goto fail;
>>> > + }
>>> > +
>>> > + for (int i = 0; i < 4; i++)
>>> > + linesizes[i] = FFALIGN(frame->width * (frames_hwctx->format ==
>>> > DXGI_FORMAT_P010 ? 2 : 1),
>>> > + D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);
>>> > +
>>> > + staging_y_location = (D3D12_TEXTURE_COPY_LOCATION) {
>>> > + .Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
>>> > + .PlacedFootprint = {
>>> > + .Offset = 0,
>>> > + .Footprint = {
>>> > + .Format = frames_hwctx->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) {
>>> > + .Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT,
>>> > + .PlacedFootprint = {
>>> > + .Offset = s->luma_component_size,
>>> > + .Footprint = {
>>> > + .Format = frames_hwctx->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) {
>>> > + if (!s->staging_download_buffer) {
>>> > + ret = d3d12va_create_staging_buffer_resource(ctx,
>>> > D3D12_RESOURCE_STATE_COPY_DEST,
>>> > + &s-
>>> > > staging_download_buffer, 1);
>>> > + if (ret < 0) {
>>> > + goto fail;
>>> > + }
>>> > + }
>>> > +
>>> > + staging_y_location.pResource = staging_uv_location.pResource = s-
>>> > > staging_download_buffer;
>>> > +
>>> > + 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));
>>> > +
>>> > + DX_CHECK(ID3D12CommandQueue_Wait(s->command_queue, f-
>>> > >sync_ctx.fence,
>>> > f->sync_ctx.fence_value));
>>> > +
>>> > + ID3D12CommandQueue_ExecuteCommandLists(s-
>>command_queue, 1,
>>> > (ID3D12CommandList **)&s->command_list);
>>> > +
>>> > + ret = d3d12va_wait_queue_idle(&s->sync_ctx, s-
>>command_queue);
>>> > + if (ret < 0)
>>> > + goto fail;
>>> > +
>>> > + DX_CHECK(ID3D12Resource_Map(s->staging_download_buffer, 0,
>NULL,
>>> > (void **)&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_download_buffer, 0, NULL);
>>> > + } else {
>>> > + if (!s->staging_upload_buffer) {
>>> > + ret = d3d12va_create_staging_buffer_resource(ctx,
>>> > D3D12_RESOURCE_STATE_GENERIC_READ,
>>> > + &s-
>>> > > staging_upload_buffer, 0);
>>> > + if (ret < 0) {
>>> > + goto fail;
>>> > + }
>>> > + }
>>> > +
>>> > + staging_y_location.pResource = staging_uv_location.pResource = s-
>>> > > staging_upload_buffer;
>>> > +
>>> > + DX_CHECK(ID3D12Resource_Map(s->staging_upload_buffer, 0,
>NULL,
>>> > (void
>>> > **)&mapped_data));
>>> > + av_image_fill_pointers(data, ctx->sw_format, ctx->height,
>>> > mapped_data, linesizes);
>>> > +
>>> > + av_image_copy(data, linesizes, src->data, src->linesize,
>>> > + ctx->sw_format, ctx->width, ctx->height);
>>> > +
>>> > + ID3D12Resource_Unmap(s->staging_upload_buffer, 0, NULL);
>>> > +
>>> > + ID3D12GraphicsCommandList_ResourceBarrier(s->command_list, 1,
>>> > &barrier);
>>> > +
>>> > + ID3D12GraphicsCommandList_CopyTextureRegion(s-
>>command_list,
>>> > + &texture_y_location, 0,
>>> > 0, 0,
>>> > + &staging_y_location,
>>> > NULL);
>>> > +
>>> > + ID3D12GraphicsCommandList_CopyTextureRegion(s-
>>command_list,
>>> > + &texture_uv_location,
>>> > 0,
>>> > 0, 0,
>>> > + &staging_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));
>>> > +
>>> > + ID3D12CommandQueue_ExecuteCommandLists(s-
>>command_queue, 1,
>>> > (ID3D12CommandList **)&s->command_list);
>>> > +
>>> > + ret = d3d12va_wait_queue_idle(&s->sync_ctx, s-
>>command_queue);
>>> > + if (ret < 0)
>>> > + goto fail;
>>> > + }
>>> > +
>>> > + hwctx->unlock(hwctx->lock_ctx);
>>> > +
>>> > + return 0;
>>> > +
>>> > +fail:
>>> > + hwctx->unlock(hwctx->lock_ctx);
>>> > + return AVERROR(EINVAL);
>>> > +}
>>> > +
>>> > +static int d3d12va_load_functions(AVHWDeviceContext *hwdev)
>>> > +{
>>> > + D3D12VADevicePriv *priv = hwdev->internal->priv;
>>> > +
>>> > +#if !HAVE_UWP
>>> > + priv->d3d12lib = dlopen("d3d12.dll", 0);
>>> > + priv->dxgilib = dlopen("dxgi.dll", 0);
>>> > +
>>> > + if (!priv->d3d12lib || !priv->dxgilib)
>>> > + goto fail;
>>> > +
>>> > + priv->create_device =
>(PFN_D3D12_CREATE_DEVICE)GetProcAddress(priv-
>>> > > d3d12lib, "D3D12CreateDevice");
>>> > + if (!priv->create_device)
>>> > + goto fail;
>>> > +
>>> > + priv->create_dxgi_factory2 =
>>> > (PFN_CREATE_DXGI_FACTORY2)GetProcAddress(priv->dxgilib,
>>> > "CreateDXGIFactory2");
>>> > + if (!priv->create_dxgi_factory2)
>>> > + goto fail;
>>> > +
>>> > + priv->get_debug_interface =
>>> > (PFN_D3D12_GET_DEBUG_INTERFACE)GetProcAddress(priv->d3d12lib,
>>> > "D3D12GetDebugInterface");
>>> > +#else
>>> > + priv->create_device = (PFN_D3D12_CREATE_DEVICE)
>>> > D3D12CreateDevice;
>>> > + priv->create_dxgi_factory2 = (PFN_CREATE_DXGI_FACTORY2)
>>> > CreateDXGIFactory2;
>>> > + priv->get_debug_interface = (PFN_D3D12_GET_DEBUG_INTERFACE)
>>> > D3D12GetDebugInterface;
>>> > +#endif
>>> > + return 0;
>>> > +
>>> > +fail:
>>> > + av_log(hwdev, AV_LOG_ERROR, "Failed to load D3D12 library or its
>>> > functions\n");
>>> > + return AVERROR_UNKNOWN;
>>> > +}
>>> > +
>>> > +static void d3d12va_device_free(AVHWDeviceContext *hwdev)
>>> > +{
>>> > + AVD3D12VADeviceContext *ctx = hwdev->hwctx;
>>> > + D3D12VADevicePriv *priv = hwdev->internal->priv;
>>> > +
>>> > + D3D12_OBJECT_RELEASE(ctx->device);
>>> > +
>>> > + if (priv->d3d12lib)
>>> > + dlclose(priv->d3d12lib);
>>> > +
>>> > + if (priv->dxgilib)
>>> > + dlclose(priv->dxgilib);
>>> > +}
>>> > +
>>> > +static int d3d12va_device_init(AVHWDeviceContext *hwdev)
>>> > +{
>>> > + AVD3D12VADeviceContext *ctx = hwdev->hwctx;
>>> > +
>>> > + if (!ctx->lock) {
>>> > + ctx->lock_ctx = CreateMutex(NULL, 0, NULL);
>>> > + if (ctx->lock_ctx == INVALID_HANDLE_VALUE) {
>>> > + av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
>>> > + return AVERROR(EINVAL);
>>> > + }
>>> > + ctx->lock = d3d12va_default_lock;
>>> > + ctx->unlock = d3d12va_default_unlock;
>>> > + }
>>> > +
>>> > + 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);
>>> > +
>>> > + if (device_hwctx->lock == d3d12va_default_lock) {
>>> > + CloseHandle(device_hwctx->lock_ctx);
>>> > + device_hwctx->lock_ctx = INVALID_HANDLE_VALUE;
>>> > + device_hwctx->lock = NULL;
>>> > + }
>>> > +}
>>> > +
>>> > +static int d3d12va_device_create(AVHWDeviceContext *hwdev, const
>char
>>> > *device,
>>> > + AVDictionary *opts, int flags)
>>> > +{
>>> > + AVD3D12VADeviceContext *ctx = hwdev->hwctx;
>>> > + D3D12VADevicePriv *priv = hwdev->internal->priv;
>>> > +
>>> > + HRESULT hr;
>>> > + UINT create_flags = 0;
>>> > + IDXGIAdapter *pAdapter = NULL;
>>> > +
>>> > + int ret;
>>> > + int is_debug = !!av_dict_get(opts, "debug", NULL, 0);
>>> > +
>>> > + hwdev->free = d3d12va_device_free;
>>> > +
>>> > + ret = d3d12va_load_functions(hwdev);
>>> > + if (ret < 0)
>>> > + return ret;
>>> > +
>>> > + if (is_debug) {
>>> > + ID3D12Debug *pDebug;
>>> > + if (priv->get_debug_interface && SUCCEEDED(priv-
>>> > > get_debug_interface(&IID_ID3D12Debug, (void **)&pDebug))) {
>>> > + create_flags |= DXGI_CREATE_FACTORY_DEBUG;
>>> > + ID3D12Debug_EnableDebugLayer(pDebug);
>>> > + D3D12_OBJECT_RELEASE(pDebug);
>>> > + av_log(hwdev, AV_LOG_INFO, "D3D12 debug layer is enabled!\n");
>>> > + }
>>> > + }
>>> > +
>>> > + if (!ctx->device) {
>>> > + IDXGIFactory2 *pDXGIFactory = NULL;
>>> > +
>>> > + hr = priv->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 = priv->create_device((IUnknown *)pAdapter,
>>> > D3D_FEATURE_LEVEL_12_0, &IID_ID3D12Device, (void **)&ctx->device);
>>> > + D3D12_OBJECT_RELEASE(pAdapter);
>>> > + if (FAILED(hr)) {
>>> > + av_log(ctx, AV_LOG_ERROR, "Failed to create Direct 3D 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),
>>> > + .device_priv_size = sizeof(D3D12VADevicePriv),
>>> > + .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..ff06e6f2ef
>>> > --- /dev/null
>>> > +++ b/libavutil/hwcontext_d3d12va.h
>>> > @@ -0,0 +1,134 @@
>>> > +/*
>>> > + * 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.
>>> > + *
>>> > + * AVHWFramesContext.pool must contain AVBufferRefs whose
>>> > + * data pointer points to an AVD3D12VAFrame struct.
>>> > + */
>>> > +#include <stdint.h>
>>> > +#include <initguid.h>
>>> > +#include <d3d12.h>
>>> > +#include <d3d12sdklayers.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;
>>> > +
>>> > + /**
>>> > + * Callbacks for locking. They protect access to the internal staging
>>> > + * texture (for av_hwframe_transfer_data() calls). They do NOT protect
>>> > + * access to hwcontext or decoder state in general.
>>> > + *
>>> > + * If unset on init, the hwcontext implementation will set them to use
>>> > an
>>> > + * internal mutex.
>>> > + *
>>> > + * The underlying lock must be recursive. lock_ctx is for free use by
>>> > the
>>> > + * locking implementation.
>>> > + */
>>> > + void (*lock)(void *lock_ctx);
>>> > + void (*unlock)(void *lock_ctx);
>>> > + void *lock_ctx;
>>> > +} AVD3D12VADeviceContext;
>>> > +
>>> > +/**
>>> > + * @brief This struct is used to sync d3d12 execution
>>> > + *
>>> > + */
>>> > +typedef struct AVD3D12VASyncContext {
>>> > + /**
>>> > + * D3D12 fence object
>>> > + */
>>> > + ID3D12Fence *fence;
>>> > +
>>> > + /**
>>> > + * A handle to the event object that's raised when the fence
>>> > + * reaches a certain value.
>>> > + */
>>> > + HANDLE event;
>>> > +
>>> > + /**
>>> > + * The fence value used for sync
>>> > + */
>>> > + uint64_t fence_value;
>>> > +} AVD3D12VASyncContext;
>>> > +
>>> > +/**
>>> > + * @brief D3D12VA frame descriptor for pool allocation.
>>> > + *
>>> > + */
>>> > +typedef struct AVD3D12VAFrame {
>>> > + /**
>>> > + * The texture in which the frame is located. The reference count is
>>> > + * managed by the AVBufferRef, and destroying the reference will
>>> > release
>>> > + * the interface.
>>> > + */
>>> > + ID3D12Resource *texture;
>>> > +
>>> > + /**
>>> > + * The sync context for the texture
>>> > + *
>>> > + * @see:
>>> > https://learn.microsoft.com/en-us/windows/win32/medfound/direct3d-
>12-video-overview#directx-12-fences
>>> > + */
>>> > + AVD3D12VASyncContext sync_ctx;
>>> > +} AVD3D12VAFrame;
>>> > +
>>> > +/**
>>> > + * @brief This struct is allocated as AVHWFramesContext.hwctx
>>> > + *
>>> > + */
>>> > +typedef struct AVD3D12VAFramesContext {
>>> > + /**
>>> > + * DXGI_FORMAT format. MUST be compatible with the pixel format.
>>> > + * If unset, will be automatically set.
>>> > + */
>>> > + DXGI_FORMAT format;
>>> > +} AVD3D12VAFramesContext;
>>> > +
>>> > +#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 4e4a63e287..0db4167934 100644
>>> > --- a/libavutil/pixdesc.c
>>> > +++ b/libavutil/pixdesc.c
>>> > @@ -2311,6 +2311,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 a26c72d56b..58f9ad28bd 100644
>>> > --- a/libavutil/pixfmt.h
>>> > +++ b/libavutil/pixfmt.h
>>> > @@ -429,6 +429,13 @@ enum AVPixelFormat {
>>> > AV_PIX_FMT_GBRAP14BE, ///< planar GBR 4:4:4:4 56bpp, big-endian
>>> > AV_PIX_FMT_GBRAP14LE, ///< planar GBR 4:4:4:4 56bpp, little-endian
>>> >
>>> > + /**
>>> > + * Hardware surfaces for Direct3D 12.
>>> > + *
>>> > + * data[0] points to an AVD3D12VAFrame
>>> > + */
>>> > + AV_PIX_FMT_D3D12,
>>> > +
>>> > 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 c5fa7c3692..0684996bf2 100644
>>> > --- a/libavutil/version.h
>>> > +++ b/libavutil/version.h
>>> > @@ -79,7 +79,7 @@
>>> > */
>>> >
>>> > #define LIBAVUTIL_VERSION_MAJOR 58
>>> > -#define LIBAVUTIL_VERSION_MINOR 32
>>> > +#define LIBAVUTIL_VERSION_MINOR 33
>>> > #define LIBAVUTIL_VERSION_MICRO 100
>>> >
>>> > #define
>LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
>>>
>>>
>>> v12 LGTM, and works well in my testing. I'll merge v12 if there are no
>>> objections / comments.
>>>
>>
>> Fixed conflicts in Changelog / version.h / APIChange and pushed.
>>
>> Thanks
>> Haihao
>>
>>
>> _______________________________________________
>> 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".
>>
>
>_______________________________________________
>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".
_______________________________________________
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".
prev parent reply other threads:[~2023-12-21 11:38 UTC|newest]
Thread overview: 15+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-12-05 6:46 Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 2/9] avcodec: add D3D12VA hardware accelerated H264 decoding Tong Wu
2023-12-24 23:06 ` Michael Niedermayer
2023-12-25 2:07 ` Wu, Tong1
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 3/9] avcodec: add D3D12VA hardware accelerated HEVC decoding Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 4/9] avcodec: add D3D12VA hardware accelerated VP9 decoding Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 5/9] avcodec: add D3D12VA hardware accelerated AV1 decoding Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 6/9] avcodec: add D3D12VA hardware accelerated MPEG-2 decoding Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 7/9] avcodec: add D3D12VA hardware accelerated VC1 decoding Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 8/9] Changelog: D3D12VA hardware accelerated H264, HEVC, VP9, AV1, MPEG-2 and " Tong Wu
2023-12-05 6:46 ` [FFmpeg-devel] [PATCH v12 9/9] avcodec/d3d12va_hevc: enable allow_profile_mismatch flag for d3d12va msp profile Tong Wu
2023-12-18 6:28 ` [FFmpeg-devel] [PATCH v12 1/9] libavutil: add hwcontext_d3d12va and AV_PIX_FMT_D3D12 Xiang, Haihao
2023-12-21 8:30 ` Xiang, Haihao
2023-12-21 9:00 ` Lynne
2023-12-21 11:38 ` Wu, Tong1 [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=SN6PR11MB2990539FC2F4999C4AEB514AC095A@SN6PR11MB2990.namprd11.prod.outlook.com \
--to=tong1.wu-at-intel.com@ffmpeg.org \
--cc=ffmpeg-devel@ffmpeg.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Git Inbox Mirror of the ffmpeg-devel mailing list - see https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
This inbox may be cloned and mirrored by anyone:
git clone --mirror https://master.gitmailbox.com/ffmpegdev/0 ffmpegdev/git/0.git
# If you have public-inbox 1.1+ installed, you may
# initialize and index your mirror using the following commands:
public-inbox-init -V2 ffmpegdev ffmpegdev/ https://master.gitmailbox.com/ffmpegdev \
ffmpegdev@gitmailbox.com
public-inbox-index ffmpegdev
Example config snippet for mirrors.
AGPL code for this site: git clone https://public-inbox.org/public-inbox.git