From patchwork Fri Dec 16 10:12:02 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steve Lhomme X-Patchwork-Id: 1836 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.65.86 with SMTP id o83csp1270385vsa; Fri, 16 Dec 2016 03:20:24 -0800 (PST) X-Received: by 10.194.235.98 with SMTP id ul2mr2251554wjc.229.1481887224618; Fri, 16 Dec 2016 03:20:24 -0800 (PST) Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id up6si6609852wjc.5.2016.12.16.03.20.21; Fri, 16 Dec 2016 03:20:24 -0800 (PST) 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=@gmail.com; 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; dmarc=fail (p=NONE dis=NONE) header.from=gmail.com Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 2D841680CCC; Fri, 16 Dec 2016 13:20:13 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-wj0-f193.google.com (mail-wj0-f193.google.com [209.85.210.193]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 8886A6809EC for ; Fri, 16 Dec 2016 13:20:06 +0200 (EET) Received: by mail-wj0-f193.google.com with SMTP id kp2so14039458wjc.0 for ; Fri, 16 Dec 2016 03:20:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=tOmcLBrRdtMlbxkAmDbpAVd+d2b9CyylhuNmbSoYfC8=; b=lXs/6Bnuk2stEMqI20P3zbuwJUdE7j0vrdLfGlDayrwNCH+eUIIW1rV70M8U+IFVu+ nbLXQSHH1+R/hR7YqtHHif/v75r9r7kECQmM7NStZkrL+VkerAin35FQPGkjqYseD386 LR31hn78pOWt4yA81NR3xdr9NGMGoQywED2W8EN9pXZBvzajc5UlfM/Gv8FvLB4BItQd fyqLT3anW6ncd6MIuCd0+n7DIFXBXvMk9cBLBRrlMoyBD3aj8Up5idQeOyQbm+/HD+vL 1C1axUX4c0tzz17sG6tGrwjo8bHVzR6geX8nFlN+8KlJOPS04l6M3PRTUGMQCbn4VdTr xU/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=tOmcLBrRdtMlbxkAmDbpAVd+d2b9CyylhuNmbSoYfC8=; b=H4tPmJC/qzfv33TentEoP9Ok1/txrFvjZCBmByExHr7uq1kMo7tK79wMCH1M1eB5H5 ctFm1TNTF0T9aka0Z+bScDMKRFSGOSrKdD4IT6/zpqPleWCO5mjcxv2y67s85QOJC1t+ zqZO5L5j2bF/LkVJb11cm7eylxlWJD0nDuR0bwF4oLFhYKNbnMr6xa9fcMagb9K4U1Yd rSHnYe34MGBOBskFqfrUbJbHTATGVRB+eFA7xJXOWKzBENju2npLFv9j6s8vuns5gJNr T7xNMDrCuW7U4rekJniP3GZdjbaTatwGbm2qJmzjKkLfYEZWvQowJ/U0IuF+qABX+Xzd Eo2g== X-Gm-Message-State: AIkVDXLZJDVsUB1V5XJqrLxkGB1DPuiq+P3JxJeuoRvlyjns2j1pK+UqmXR0r3eZ9LQLUQ== X-Received: by 10.195.11.229 with SMTP id el5mr2693749wjd.64.1481886741000; Fri, 16 Dec 2016 03:12:21 -0800 (PST) Received: from localhost.localdomain (2a01cb0c000ea900449390cb157ec679.ipv6.abo.wanadoo.fr. [2a01:cb0c:e:a900:4493:90cb:157e:c679]) by smtp.gmail.com with ESMTPSA id x140sm2849193wme.19.2016.12.16.03.12.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 16 Dec 2016 03:12:20 -0800 (PST) From: Steve Lhomme X-Google-Original-From: Steve Lhomme To: ffmpeg-devel@ffmpeg.org Date: Fri, 16 Dec 2016 11:12:02 +0100 Message-Id: <20161216101205.1360-2-robUx4@gmail.com> X-Mailer: git-send-email 2.10.2 In-Reply-To: <20161216101205.1360-1-robUx4@gmail.com> References: <20161216101205.1360-1-robUx4@gmail.com> Subject: [FFmpeg-devel] [PATCH 2/5] libautil: add support for AV_HWDEVICE_TYPE_D3D11VA X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 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: Steve Lhomme MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" From: Steve Lhomme --- libavutil/Makefile | 3 + libavutil/hwcontext.c | 3 + libavutil/hwcontext.h | 1 + libavutil/hwcontext_d3d11va.c | 457 +++++++++++++++++++++++++++++++++++++++++ libavutil/hwcontext_d3d11va.h | 81 ++++++++ libavutil/hwcontext_internal.h | 1 + libavutil/version.h | 2 +- 7 files changed, 547 insertions(+), 1 deletion(-) create mode 100644 libavutil/hwcontext_d3d11va.c create mode 100644 libavutil/hwcontext_d3d11va.h diff --git a/libavutil/Makefile b/libavutil/Makefile index 9841645..9b8ce22 100644 --- a/libavutil/Makefile +++ b/libavutil/Makefile @@ -34,6 +34,7 @@ HEADERS = adler32.h \ hmac.h \ hwcontext.h \ hwcontext_cuda.h \ + hwcontext_d3d11va.h \ hwcontext_dxva2.h \ hwcontext_qsv.h \ hwcontext_vaapi.h \ @@ -156,6 +157,7 @@ OBJS = adler32.o \ OBJS-$(!HAVE_ATOMICS_NATIVE) += atomic.o \ OBJS-$(CONFIG_CUDA) += hwcontext_cuda.o +OBJS-$(CONFIG_D3D11VA) += hwcontext_d3d11va.o OBJS-$(CONFIG_DXVA2) += hwcontext_dxva2.o OBJS-$(CONFIG_QSV) += hwcontext_qsv.o OBJS-$(CONFIG_LZO) += lzo.o @@ -170,6 +172,7 @@ SLIBOBJS-$(HAVE_GNU_WINDRES) += avutilres.o SKIPHEADERS-$(HAVE_CUDA_H) += hwcontext_cuda.h SKIPHEADERS-$(CONFIG_CUDA) += hwcontext_cuda_internal.h +SKIPHEADERS-$(CONFIG_D3D11VA) += hwcontext_d3d11va.h SKIPHEADERS-$(CONFIG_DXVA2) += hwcontext_dxva2.h SKIPHEADERS-$(CONFIG_QSV) += hwcontext_qsv.h SKIPHEADERS-$(CONFIG_VAAPI) += hwcontext_vaapi.h diff --git a/libavutil/hwcontext.c b/libavutil/hwcontext.c index 615f1f7..a9db84b 100644 --- a/libavutil/hwcontext.c +++ b/libavutil/hwcontext.c @@ -32,6 +32,9 @@ static const HWContextType *hw_table[] = { #if CONFIG_CUDA &ff_hwcontext_type_cuda, #endif +#if CONFIG_D3D11VA + &ff_hwcontext_type_d3d11va, +#endif #if CONFIG_DXVA2 &ff_hwcontext_type_dxva2, #endif diff --git a/libavutil/hwcontext.h b/libavutil/hwcontext.h index 785da09..1325917 100644 --- a/libavutil/hwcontext.h +++ b/libavutil/hwcontext.h @@ -30,6 +30,7 @@ enum AVHWDeviceType { AV_HWDEVICE_TYPE_VAAPI, AV_HWDEVICE_TYPE_DXVA2, AV_HWDEVICE_TYPE_QSV, + AV_HWDEVICE_TYPE_D3D11VA, }; typedef struct AVHWDeviceInternal AVHWDeviceInternal; diff --git a/libavutil/hwcontext_d3d11va.c b/libavutil/hwcontext_d3d11va.c new file mode 100644 index 0000000..0618da3 --- /dev/null +++ b/libavutil/hwcontext_d3d11va.c @@ -0,0 +1,457 @@ +/* + * 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 + +#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600 +#undef _WIN32_WINNT +#define _WIN32_WINNT 0x0600 +#endif +#define COBJMACROS + +#include +#include +#include + +#include "avassert.h" +#include "common.h" +#include "hwcontext.h" +#include "hwcontext_d3d11va.h" +#include "hwcontext_internal.h" +#include "imgutils.h" +#include "pixdesc.h" +#include "pixfmt.h" +#include "compat/w32dlfcn.h" + +typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory); + +typedef struct D3D11VAFramesContext { + ID3D11VideoDecoderOutputView **surfaces_internal; + int nb_surfaces_used; + + ID3D11DeviceContext *d3d11_context; + + DXGI_FORMAT format; +} D3D11VAFramesContext; + +typedef struct D3D11VADevicePriv { + HMODULE d3dlib; +} D3D11VADevicePriv; + +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 d3d11va_frames_uninit(AVHWFramesContext *ctx) +{ + AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx; + D3D11VAFramesContext *s = ctx->internal->priv; + + if (frames_hwctx->decoder_to_release) + ID3D11VideoDecoder_Release(frames_hwctx->decoder_to_release); + + av_freep(&s->surfaces_internal); + + if (frames_hwctx->staging_texture) + ID3D11Texture2D_Release(frames_hwctx->staging_texture); + + if (s->d3d11_context) { + ID3D11DeviceContext_Release(s->d3d11_context); + s->d3d11_context = NULL; + } + + if (frames_hwctx->dev_ctx_mutex != INVALID_HANDLE_VALUE) + ReleaseMutex(frames_hwctx->dev_ctx_mutex); +} + +static void free_surface(void *opaque, uint8_t *data) +{ + ID3D11VideoDecoderOutputView_Release((ID3D11VideoDecoderOutputView*)data); +} + +static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size) +{ + AVHWFramesContext *ctx = (AVHWFramesContext*)opaque; + D3D11VAFramesContext *s = ctx->internal->priv; + AVD3D11VAFramesContext *hwctx = ctx->hwctx; + + if (s->nb_surfaces_used < hwctx->nb_surfaces) { + s->nb_surfaces_used++; + return av_buffer_create((uint8_t*)s->surfaces_internal[s->nb_surfaces_used - 1], + sizeof(*hwctx->surfaces), free_surface, 0, 0); + } + + return NULL; +} + +static int d3d11va_init_pool(AVHWFramesContext *ctx) +{ + AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx; + AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx; + D3D11VAFramesContext *s = ctx->internal->priv; + + int i; + HRESULT hr; + D3D11_TEXTURE2D_DESC texDesc; + ID3D11Texture2D *p_texture; + D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc; + D3D11_VIDEO_DECODER_DESC decoderDesc; + D3D11_VIDEO_DECODER_CONFIG decoderConfig; + ID3D11Device *d3d11_device; + + if (ctx->initial_pool_size <= 0) + return 0; + + hr = ID3D11VideoContext_QueryInterface(device_hwctx->video_context, &IID_ID3D11DeviceContext, + (void **)&s->d3d11_context); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Failed to get the device context %lx\n", hr); + return AVERROR_UNKNOWN; + } + + 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); + } + + s->surfaces_internal = av_mallocz_array(ctx->initial_pool_size, + sizeof(*s->surfaces_internal)); + if (!s->surfaces_internal) + return AVERROR(ENOMEM); + + ZeroMemory(&texDesc, sizeof(texDesc)); + texDesc.Width = ctx->width; + texDesc.Height = ctx->height; + texDesc.MipLevels = 1; + texDesc.Format = s->format; + texDesc.SampleDesc.Count = 1; + texDesc.ArraySize = ctx->initial_pool_size; + texDesc.Usage = D3D11_USAGE_DEFAULT; + texDesc.BindFlags = D3D11_BIND_DECODER; + + frames_hwctx->dev_ctx_mutex = CreateMutex(NULL, 0, NULL); + if (frames_hwctx->dev_ctx_mutex == INVALID_HANDLE_VALUE) { + av_log(ctx, AV_LOG_ERROR, "Failed to get a mutex for the D3D11VA decoder\n"); + return AVERROR(EINVAL); + } + + hr = ID3D11VideoDevice_QueryInterface(device_hwctx->video_device, &IID_ID3D11Device, (void **)&d3d11_device); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Failed to get the device %lx\n", hr); + return AVERROR_UNKNOWN; + } + + hr = ID3D11Device_CreateTexture2D(d3d11_device, &texDesc, NULL, &p_texture); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Could not create the texture %lx\n", hr); + ID3D11Device_Release(d3d11_device); + return AVERROR_UNKNOWN; + } + + hr = ID3D11VideoDecoder_GetCreationParameters(frames_hwctx->decoder_to_release, &decoderDesc, &decoderConfig); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Could not get the decoder config %lx\n", hr); + ID3D11Texture2D_Release(p_texture); + ID3D11Device_Release(d3d11_device); + return AVERROR_UNKNOWN; + } + + ZeroMemory(&viewDesc, sizeof(viewDesc)); + viewDesc.DecodeProfile = decoderDesc.Guid; + viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D; + for (i=0; iinitial_pool_size; i++) + { + hr = ID3D11VideoDevice_CreateVideoDecoderOutputView(device_hwctx->video_device, + (ID3D11Resource*) p_texture, + &viewDesc, + (ID3D11VideoDecoderOutputView**) &s->surfaces_internal[i]); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Could not create the decoder output %d\n", i); + while (--i >= 0) { + ID3D11VideoDecoderOutputView_Release(s->surfaces_internal[i]); + s->surfaces_internal[i] = NULL; + } + ID3D11Texture2D_Release(p_texture); + ID3D11Device_Release(d3d11_device); + return AVERROR_UNKNOWN; + } + } + ID3D11Texture2D_Release(p_texture); + + texDesc.ArraySize = 1; + texDesc.Usage = D3D11_USAGE_STAGING; + texDesc.BindFlags = 0; + texDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; + hr = ID3D11Device_CreateTexture2D(d3d11_device, &texDesc, NULL, &frames_hwctx->staging_texture); + ID3D11Device_Release(d3d11_device); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture %lx\n", hr); + return AVERROR_UNKNOWN; + } + + ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(*s->surfaces_internal), + ctx, d3d11va_pool_alloc, NULL); + if (!ctx->internal->pool_internal) + return AVERROR(ENOMEM); + + frames_hwctx->surfaces = s->surfaces_internal; + frames_hwctx->nb_surfaces = ctx->initial_pool_size; + + return 0; +} + +static int d3d11va_frames_init(AVHWFramesContext *ctx) +{ + int ret; + + /* init the frame pool if the caller didn't provide one */ + if (!ctx->pool) { + ret = d3d11va_init_pool(ctx); + if (ret < 0) { + av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n"); + return ret; + } + } + + return 0; +} + +static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame) +{ + frame->buf[0] = av_buffer_pool_get(ctx->pool); + if (!frame->buf[0]) + return AVERROR(ENOMEM); + + frame->data[3] = frame->buf[0]->data; + frame->format = AV_PIX_FMT_D3D11VA_VLD; + frame->width = ctx->width; + frame->height = ctx->height; + + return 0; +} + +static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx, + enum AVHWFrameTransferDirection dir, + enum AVPixelFormat **formats) +{ + 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 d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst, + const AVFrame *src) +{ + ID3D11VideoDecoderOutputView *surface; + D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC surfaceDesc; + D3D11_TEXTURE2D_DESC dstDesc; + D3D11_MAPPED_SUBRESOURCE LockedRect; + ID3D11Resource *pTexture; + HRESULT hr; + AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx; + D3D11VAFramesContext *s = ctx->internal->priv; + + uint8_t *surf_data[4] = { NULL }; + int surf_linesize[4] = { 0 }; + int i; + + int download = !!src->hw_frames_ctx; + + surface = (ID3D11VideoDecoderOutputView*)(download ? src->data[3] : dst->data[3]); + + ID3D11VideoDecoderOutputView_GetDesc(surface, &surfaceDesc); + ID3D11VideoDecoderOutputView_GetResource(surface, &pTexture); + ID3D11Texture2D_GetDesc(frames_hwctx->staging_texture, &dstDesc); + + WaitForSingleObjectEx(frames_hwctx->dev_ctx_mutex, INFINITE, FALSE); + + ID3D11DeviceContext_CopySubresourceRegion(s->d3d11_context, (ID3D11Resource*)frames_hwctx->staging_texture, + 0, 0, 0, 0, + (ID3D11Resource*)pTexture, surfaceDesc.Texture2D.ArraySlice, + NULL); + ID3D11Resource_Release(pTexture); + + hr = ID3D11DeviceContext_Map(s->d3d11_context, (ID3D11Resource*)frames_hwctx->staging_texture, + 0, download ? D3D11_MAP_READ : D3D11_MAP_WRITE, 0, &LockedRect); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface %lx\n", hr); + ReleaseMutex(frames_hwctx->dev_ctx_mutex); + return AVERROR_UNKNOWN; + } + + for (i = 0; download ? dst->data[i] : src->data[i]; i++) + surf_linesize[i] = LockedRect.RowPitch; + + av_image_fill_pointers(surf_data, ctx->sw_format, dstDesc.Height, + (uint8_t*)LockedRect.pData, surf_linesize); + + if (download) { + av_image_copy(dst->data, dst->linesize, surf_data, surf_linesize, + ctx->sw_format, src->width, src->height); + } else { + av_image_copy(surf_data, surf_linesize, src->data, src->linesize, + ctx->sw_format, src->width, src->height); + } + + ID3D11DeviceContext_Unmap(s->d3d11_context, (ID3D11Resource*)frames_hwctx->staging_texture, 0); + ReleaseMutex(frames_hwctx->dev_ctx_mutex); + + return 0; +} + +static void d3d11va_device_free(AVHWDeviceContext *ctx) +{ + AVD3D11VADeviceContext *device_hwctx = ctx->hwctx; + D3D11VADevicePriv *priv = ctx->user_opaque; + + if (device_hwctx->video_device) + ID3D11Device_Release(device_hwctx->video_device); + + if (device_hwctx->video_context) + ID3D11VideoContext_Release(device_hwctx->video_context); + + if (priv->d3dlib) + dlclose(priv->d3dlib); + + av_freep(&ctx->user_opaque); +} + +static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device, + AVDictionary *opts, int flags) +{ + AVD3D11VADeviceContext *device_hwctx = ctx->hwctx; + ID3D11Device *d3d11_device; + ID3D11DeviceContext *d3d11_context; + ID3D10Multithread *pMultithread; + D3D11VADevicePriv *priv; + + HRESULT hr; + PFN_D3D11_CREATE_DEVICE createD3D; + IDXGIAdapter *pAdapter = NULL; + UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT; + /* if the DirectX SDK is installed creationFlags |= D3D11_CREATE_DEVICE_DEBUG; */ + + if (device) { + HMODULE dxgilib = dlopen("dxgi.dll", 0); + if (dxgilib) { + PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory; + mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) dlsym(dxgilib, "CreateDXGIFactory"); + if (mCreateDXGIFactory) { + IDXGIFactory2 *pDXGIFactory; + hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory); + if (SUCCEEDED(hr)) { + int adapter = atoi(device); + if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter))) + pAdapter = NULL; + IDXGIFactory2_Release(pDXGIFactory); + } + } + dlclose(dxgilib); + } + } + + priv = av_mallocz(sizeof(*priv)); + if (!priv) + return AVERROR(ENOMEM); + + ctx->user_opaque = priv; + ctx->free = d3d11va_device_free; + + priv->d3dlib = dlopen("d3d11.dll", 0); + if (!priv->d3dlib) { + av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library\n"); + return AVERROR_UNKNOWN; + } + + createD3D = (PFN_D3D11_CREATE_DEVICE) dlsym(priv->d3dlib, "D3D11CreateDevice"); + if (!createD3D) { + av_log(ctx, AV_LOG_ERROR, "Failed to locate D3D11CreateDevice\n"); + return AVERROR_UNKNOWN; + } + + hr = createD3D(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0, + D3D11_SDK_VERSION, &d3d11_device, NULL, &d3d11_context); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device %lx\n", hr); + return AVERROR_UNKNOWN; + } + + hr = ID3D11Device_QueryInterface(d3d11_device, &IID_ID3D10Multithread, (void **)&pMultithread); + if (SUCCEEDED(hr)) { + ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE); + ID3D10Multithread_Release(pMultithread); + } + + hr = ID3D11DeviceContext_QueryInterface(d3d11_context, &IID_ID3D11VideoContext, + (void **)&device_hwctx->video_context); + ID3D11DeviceContext_Release(d3d11_context); + if (FAILED(hr)) { + av_log(ctx, AV_LOG_ERROR, "Failed to get the Video Context %lx\n", hr); + ID3D11Device_Release(d3d11_device); + return AVERROR_UNKNOWN; + } + + hr = ID3D11Device_QueryInterface(d3d11_device, &IID_ID3D11VideoDevice, + (void **)&device_hwctx->video_device); + ID3D11Device_Release(d3d11_device); + if (FAILED(hr)) { + av_log(NULL, AV_LOG_ERROR, "Failed to get the Video Device %lx\n", hr); + return AVERROR_UNKNOWN; + } + + return 0; +} + +const HWContextType ff_hwcontext_type_d3d11va = { + .type = AV_HWDEVICE_TYPE_D3D11VA, + .name = "D3D11VA", + + .device_hwctx_size = sizeof(AVD3D11VADeviceContext), + .frames_hwctx_size = sizeof(AVD3D11VAFramesContext), + .frames_priv_size = sizeof(D3D11VAFramesContext), + + .device_create = d3d11va_device_create, + .frames_init = d3d11va_frames_init, + .frames_uninit = d3d11va_frames_uninit, + .frames_get_buffer = d3d11va_get_buffer, + .transfer_get_formats = d3d11va_transfer_get_formats, + .transfer_data_to = d3d11va_transfer_data, + .transfer_data_from = d3d11va_transfer_data, + + .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11VA_VLD, AV_PIX_FMT_NONE }, +}; diff --git a/libavutil/hwcontext_d3d11va.h b/libavutil/hwcontext_d3d11va.h new file mode 100644 index 0000000..e8d03f4 --- /dev/null +++ b/libavutil/hwcontext_d3d11va.h @@ -0,0 +1,81 @@ +/* + * 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_D3D11VA_H +#define AVUTIL_HWCONTEXT_D3D11VA_H + +/** + * @file + * An API-specific header for AV_HWDEVICE_TYPE_D3D11VA. + * + * Only fixed-size pools are supported. + * + * For user-allocated pools, AVHWFramesContext.pool must return AVBufferRefs + * with the data pointer set to a pointer to ID3D11VideoDecoderOutputView. + */ + +#include + +/** + * This struct is allocated as AVHWDeviceContext.hwctx + */ +typedef struct AVD3D11VADeviceContext { + ID3D11VideoDevice *video_device; + ID3D11VideoContext *video_context; +} AVD3D11VADeviceContext; + +/** + * This struct is allocated as AVHWFramesContext.hwctx + */ +typedef struct AVD3D11VAFramesContext { + /** + * The surface pool. When an external pool is not provided by the caller, + * this will be managed (allocated and filled on init, freed on uninit) by + * libavutil. + * When it is provided the allocation/deallocation is up to the caller. + */ + ID3D11VideoDecoderOutputView **surfaces; + int nb_surfaces; + + /** + * Certain drivers require the decoder to be destroyed before the surfaces. + * To allow internally managed pools to work properly in such cases, this + * field is provided. + * + * The decoder must be created before the surface pool. + * + * If it is non-NULL, libavutil will call ID3D11VideoDecoder_Release() on + * it just before the internal surface pool is freed. + */ + ID3D11VideoDecoder *decoder_to_release; + + /** + * Internal texture to get access to the decoded pixels from the CPU as the + * decoder texture needs D3D11_BIND_DECODER which forbdis CPU access. + */ + ID3D11Texture2D *staging_texture; + + /** + * Internal Mutex to avoid accessing the ID3D11DeviceContext from multiple + * threads simultaneously. + */ + HANDLE dev_ctx_mutex; +} AVD3D11VAFramesContext; + +#endif /* AVUTIL_HWCONTEXT_D3D11VA_H */ diff --git a/libavutil/hwcontext_internal.h b/libavutil/hwcontext_internal.h index 079e42b..aaa6286 100644 --- a/libavutil/hwcontext_internal.h +++ b/libavutil/hwcontext_internal.h @@ -100,6 +100,7 @@ struct AVHWFramesInternal { }; extern const HWContextType ff_hwcontext_type_cuda; +extern const HWContextType ff_hwcontext_type_d3d11va; extern const HWContextType ff_hwcontext_type_dxva2; extern const HWContextType ff_hwcontext_type_qsv; extern const HWContextType ff_hwcontext_type_vaapi; diff --git a/libavutil/version.h b/libavutil/version.h index 9f8c4c2..6dac240 100644 --- a/libavutil/version.h +++ b/libavutil/version.h @@ -80,7 +80,7 @@ #define LIBAVUTIL_VERSION_MAJOR 55 #define LIBAVUTIL_VERSION_MINOR 43 -#define LIBAVUTIL_VERSION_MICRO 100 +#define LIBAVUTIL_VERSION_MICRO 101 #define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \ LIBAVUTIL_VERSION_MINOR, \