From patchwork Fri Jun 2 08:06:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Wu, Tong1" X-Patchwork-Id: 41949 Delivered-To: ffmpegpatchwork2@gmail.com Received: by 2002:a05:6a20:c51c:b0:10c:5e6f:955f with SMTP id gm28csp1055000pzb; Fri, 2 Jun 2023 01:11:44 -0700 (PDT) X-Google-Smtp-Source: ACHHUZ7hxDJIyUIrIiTyO1c5k8IE5yZ4aGP+Cml+IOCJ5lgOOV6AtNmLTQrV6uPXqLaNTvo0a6KD X-Received: by 2002:a17:907:e90:b0:959:18b2:454a with SMTP id ho16-20020a1709070e9000b0095918b2454amr12229113ejc.76.1685693503719; Fri, 02 Jun 2023 01:11:43 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1685693503; cv=none; d=google.com; s=arc-20160816; b=lZo4bNHr1nQe42O4/5+jbmyZzrLNNCMSUKi1CSW9i8h59U6IBpUeCcA5J+Uj8oJswS fSVDvSLsPeGoVCJmr+FZqyLy751uX6qIZimnxNh8iG2NYvUTVzI/NfOFc1vAvOS1iTHc QhS99wVgAguympa/hxxaD0IPYjuVxwNVNV0PVAaEC+z0OOQQyGs6I8dQunYEooQqfLEA zkWX1PyqaElmRMT97h+w77oR0LivvPcg6DtXGok00l0rTcgKyh9g5x65bLwo+g7iVlh2 eiLS6QaBkEWBdW/3V7Ir7TUIA0zPlVW/lAqPoAvdkGhJhwg5sLWObLrfRu6Cu+B32P5b I/Og== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:content-transfer-encoding:cc:reply-to :list-subscribe:list-help:list-post:list-archive:list-unsubscribe :list-id:precedence:subject:mime-version:message-id:date:to:from :dkim-signature:delivered-to; bh=8wid94bOlfB1S7IDz10TnFF8C8c0PG87/8fhFHmIKxg=; b=JuumbUp9jgu0GfG5apw9CwtkhMEmSNNz4E2uJlJUZQ6ZqepxJGuqadPWpSxuzgpj74 p1dOd6z4LSO4tsWE8VlR3vy9yzZMuabMw2o/gJzjkrIv4yyCS4eNHUFDrFd6CaT++ZrB UWo4sH1yfFTfoIHHy1sB3JYB8OM5e7fndV/mj7C4W6inrWqp+RumUx60TgpW0xvBk6iW gn+5NhWFn76aJDBjBV+etkt5BT+9tESAMqOHZmkpYf3B6myhC48ybaeZvlniEIk9z5kP gPI/rj5vJInhTN/VOil1BK2jcVhlHrEYEiK0Mhhr2BOAKXI4UVSlSzwBoGgYpONRsJ2x 3JXw== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@intel.com header.s=Intel header.b=ga+uqW73; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id j20-20020a50ed14000000b005149c8b6824si524518eds.24.2023.06.02.01.11.43; Fri, 02 Jun 2023 01:11:43 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@intel.com header.s=Intel header.b=ga+uqW73; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 6991568C316; Fri, 2 Jun 2023 11:11:39 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 1672168BFD5 for ; Fri, 2 Jun 2023 11:11:30 +0300 (EEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1685693496; x=1717229496; h=from:to:cc:subject:date:message-id:mime-version: content-transfer-encoding; bh=23aVx4jtygbed9N441cDTvilTAWW7N59RkldFUOyfYE=; b=ga+uqW73kp8H0DBMOWb0BH3UWLbVaaaKMkFrYFkk0F8eA2Ilo3StNU/7 A4bqDsGMxylxedF0r9Qe4c7qtGk7SZtC038ndqwg/SdG+02OiCH42BNib Wb6teDj/CZhjKg7z46d7IlURptFZsUFTsY3X+3VfCbbjLtWwiFHbRofy1 wlYvawhO+FneIUR76FJDd3P/3+WMzTvacjIFctel+OhbETDTBbo2Uykj+ rJm/wPLPyFc/hXyoKDurILGIqufZCrXiV/XE3PLd9mKij9/9cIcMn/Ayp dw8u+MZUOBc3JFKV0VTgtwFlCgi+60sRkND/O5PEVaxWCRD3X2XFj8NYt g==; X-IronPort-AV: E=McAfee;i="6600,9927,10728"; a="421629823" X-IronPort-AV: E=Sophos;i="6.00,212,1681196400"; d="scan'208";a="421629823" Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 02 Jun 2023 01:11:20 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10728"; a="852060664" X-IronPort-AV: E=Sophos;i="6.00,212,1681196400"; d="scan'208";a="852060664" Received: from desktop-qn7n0nf.sh.intel.com (HELO localhost.localdomain) ([10.239.160.59]) by fmsmga001.fm.intel.com with ESMTP; 02 Jun 2023 01:11:18 -0700 From: Tong Wu To: ffmpeg-devel@ffmpeg.org Date: Fri, 2 Jun 2023 16:06:53 +0800 Message-Id: <20230602080701.1754-1-tong1.wu@intel.com> X-Mailer: git-send-email 2.35.1.windows.2 MIME-Version: 1.0 Subject: [FFmpeg-devel] [PATCH v3 1/9] libavutil: add hwcontext_d3d12va and AV_PIX_FMT_D3D12 X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Tong Wu , Wu Jianhua Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" X-TUID: G9f8lWL2ypTi From: Wu Jianhua Signed-off-by: Wu Jianhua Signed-off-by: Tong Wu --- configure | 5 + doc/APIchanges | 7 + libavutil/Makefile | 3 + libavutil/hwcontext.c | 4 + libavutil/hwcontext.h | 1 + libavutil/hwcontext_d3d12va.c | 699 +++++++++++++++++++++++++ libavutil/hwcontext_d3d12va.h | 167 ++++++ libavutil/hwcontext_d3d12va_internal.h | 63 +++ libavutil/hwcontext_internal.h | 1 + libavutil/pixdesc.c | 4 + libavutil/pixfmt.h | 9 + libavutil/tests/hwdevice.c | 2 + 12 files changed, 965 insertions(+) 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 495493aa0e..b86064e36f 100755 --- a/configure +++ b/configure @@ -337,6 +337,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] @@ -1885,6 +1886,7 @@ HWACCEL_AUTODETECT_LIBRARY_LIST=" cuda_llvm cuvid d3d11va + d3d12va dxva2 ffnvcodec nvdec @@ -2999,6 +3001,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" @@ -6449,6 +6452,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 f040211f7d..b64ed73a64 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-05-xx - xxxxxxxxxx - lavu 58.7.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-05-29 - xxxxxxxxxx - lavc 60.16.100 - avcodec.h codec_id.h Add AV_CODEC_ID_EVC, FF_PROFILE_EVC_BASELINE, and FF_PROFILE_EVC_MAIN. 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..d159aef08b --- /dev/null +++ b/libavutil/hwcontext_d3d12va.c @@ -0,0 +1,699 @@ +/* + * Direct3D 12 HW acceleration. + * + * copyright (c) 2022-2023 Wu Jianhua + * + * 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 + +typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY2)(UINT Flags, REFIID riid, void **ppFactory); + +static AVOnce functions_loaded = AV_ONCE_INIT; + +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) +{ + 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"); +} + +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 = *psync_ctx; + if (!psync_ctx || !sync_ctx) + return; + + 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); +} + +int av_d3d12va_wait_queue_idle(AVD3D12VASyncContext *sync_ctx, ID3D12CommandQueue *command_queue) +{ + 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; + } + + 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) { + D3D12_OBJECT_RELEASE(texture); + av_freep(&desc); + return NULL; + } + + return buf; + +fail: + D3D12_OBJECT_RELEASE(texture); + av_d3d12va_sync_context_free(&sync_ctx); + 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; + + if (ctx->initial_pool_size > D3D12VA_MAX_SURFACES) { + av_log(ctx, AV_LOG_WARNING, "Too big initial pool size(%d) for surfaces. " + "The size will be limited to %d automatically\n", ctx->initial_pool_size, D3D12VA_MAX_SURFACES); + ctx->initial_pool_size = D3D12VA_MAX_SURFACES; + } + + 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); + } + + 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..060f692d11 --- /dev/null +++ b/libavutil/hwcontext_d3d12va.h @@ -0,0 +1,167 @@ +/* + * Direct3D 12 HW acceleration. + * + * copyright (c) 2022-2023 Wu Jianhua + * + * 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. + * + */ +#include +#include +#include +#include + +/** + * @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); + +/** + * @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..e118a579aa --- /dev/null +++ b/libavutil/hwcontext_d3d12va_internal.h @@ -0,0 +1,63 @@ +/* + * Direct3D 12 HW acceleration. + * + * copyright (c) 2022-2023 Wu Jianhua + * + * 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) if (FAILED(hr)) { \ + goto fail; \ +} + +/** + * @def D3D12_OBJECT_RELEASE + * + * @brief A release macro used by D3D12 objects highly frequently + */ +#define D3D12_OBJECT_RELEASE(pInterface) if (pInterface) { \ + IUnknown_Release((IUnknown *)pInterface); \ + pInterface = NULL; \ +} + +/** + * @def D3D12VA_MAX_SURFACES + * + * @brief Maximum number surfaces + * The reference processing over decoding will be corrupted on some drivers + * if the max number of reference frames exceeds this. + */ +#define D3D12VA_MAX_SURFACES 32 + +#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, + 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,