616 lines
20 KiB
C
Executable file
616 lines
20 KiB
C
Executable file
/*
|
|
* 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 <windows.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
#include <initguid.h>
|
|
#include <d3d11.h>
|
|
#include <dxgi1_2.h>
|
|
|
|
#if HAVE_DXGIDEBUG_H
|
|
#include <dxgidebug.h>
|
|
#endif
|
|
|
|
#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 "thread.h"
|
|
#include "compat/w32dlfcn.h"
|
|
|
|
typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
|
|
|
|
static AVOnce functions_loaded = AV_ONCE_INIT;
|
|
|
|
static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory;
|
|
static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice;
|
|
|
|
static av_cold void load_functions(void)
|
|
{
|
|
#if !HAVE_UWP
|
|
// We let these "leak" - this is fine, as unloading has no great benefit, and
|
|
// Windows will mark a DLL as loaded forever if its internal refcount overflows
|
|
// from too many LoadLibrary calls.
|
|
HANDLE d3dlib, dxgilib;
|
|
|
|
d3dlib = dlopen("d3d11.dll", 0);
|
|
dxgilib = dlopen("dxgi.dll", 0);
|
|
if (!d3dlib || !dxgilib)
|
|
return;
|
|
|
|
mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
|
|
mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
|
|
#else
|
|
// In UWP (which lacks LoadLibrary), CreateDXGIFactory isn't available,
|
|
// only CreateDXGIFactory1
|
|
mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) D3D11CreateDevice;
|
|
mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) CreateDXGIFactory1;
|
|
#endif
|
|
}
|
|
|
|
typedef struct D3D11VAFramesContext {
|
|
int nb_surfaces_used;
|
|
|
|
DXGI_FORMAT format;
|
|
|
|
ID3D11Texture2D *staging_texture;
|
|
} D3D11VAFramesContext;
|
|
|
|
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 },
|
|
// Special opaque formats. The pix_fmt is merely a place holder, as the
|
|
// opaque format cannot be accessed directly.
|
|
{ DXGI_FORMAT_420_OPAQUE, AV_PIX_FMT_YUV420P },
|
|
};
|
|
|
|
static void d3d11va_default_lock(void *ctx)
|
|
{
|
|
WaitForSingleObjectEx(ctx, INFINITE, FALSE);
|
|
}
|
|
|
|
static void d3d11va_default_unlock(void *ctx)
|
|
{
|
|
ReleaseMutex(ctx);
|
|
}
|
|
|
|
static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
|
|
{
|
|
AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx;
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
|
|
if (frames_hwctx->texture)
|
|
ID3D11Texture2D_Release(frames_hwctx->texture);
|
|
frames_hwctx->texture = NULL;
|
|
|
|
if (s->staging_texture)
|
|
ID3D11Texture2D_Release(s->staging_texture);
|
|
s->staging_texture = NULL;
|
|
}
|
|
|
|
static int d3d11va_frames_get_constraints(AVHWDeviceContext *ctx,
|
|
const void *hwconfig,
|
|
AVHWFramesConstraints *constraints)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
|
|
int nb_sw_formats = 0;
|
|
HRESULT hr;
|
|
int i;
|
|
|
|
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 (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
|
|
UINT format_support = 0;
|
|
hr = ID3D11Device_CheckFormatSupport(device_hwctx->device, supported_formats[i].d3d_format, &format_support);
|
|
if (SUCCEEDED(hr) && (format_support & D3D11_FORMAT_SUPPORT_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_D3D11;
|
|
constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void free_texture(void *opaque, uint8_t *data)
|
|
{
|
|
ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
|
|
av_free(data);
|
|
}
|
|
|
|
static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
|
|
{
|
|
AVBufferRef *buf;
|
|
AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
|
|
if (!desc) {
|
|
ID3D11Texture2D_Release(tex);
|
|
return NULL;
|
|
}
|
|
|
|
desc->texture = tex;
|
|
desc->index = index;
|
|
|
|
buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
|
|
if (!buf) {
|
|
ID3D11Texture2D_Release(tex);
|
|
av_free(desc);
|
|
return NULL;
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
|
|
{
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
AVD3D11VAFramesContext *hwctx = ctx->hwctx;
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
|
|
HRESULT hr;
|
|
ID3D11Texture2D *tex;
|
|
D3D11_TEXTURE2D_DESC texDesc = {
|
|
.Width = ctx->width,
|
|
.Height = ctx->height,
|
|
.MipLevels = 1,
|
|
.Format = s->format,
|
|
.SampleDesc = { .Count = 1 },
|
|
.ArraySize = 1,
|
|
.Usage = D3D11_USAGE_DEFAULT,
|
|
.BindFlags = hwctx->BindFlags,
|
|
.MiscFlags = hwctx->MiscFlags,
|
|
};
|
|
|
|
hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
|
|
if (FAILED(hr)) {
|
|
av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
|
|
return NULL;
|
|
}
|
|
|
|
return wrap_texture_buf(tex, 0);
|
|
}
|
|
|
|
static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
|
|
{
|
|
AVHWFramesContext *ctx = (AVHWFramesContext*)opaque;
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
AVD3D11VAFramesContext *hwctx = ctx->hwctx;
|
|
D3D11_TEXTURE2D_DESC texDesc;
|
|
|
|
if (!hwctx->texture)
|
|
return d3d11va_alloc_single(ctx);
|
|
|
|
ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
|
|
|
|
if (s->nb_surfaces_used >= texDesc.ArraySize) {
|
|
av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
|
|
return NULL;
|
|
}
|
|
|
|
ID3D11Texture2D_AddRef(hwctx->texture);
|
|
return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
|
|
}
|
|
|
|
static int d3d11va_frames_init(AVHWFramesContext *ctx)
|
|
{
|
|
AVD3D11VAFramesContext *hwctx = ctx->hwctx;
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
|
|
int i;
|
|
HRESULT hr;
|
|
D3D11_TEXTURE2D_DESC texDesc;
|
|
|
|
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);
|
|
}
|
|
|
|
texDesc = (D3D11_TEXTURE2D_DESC){
|
|
.Width = ctx->width,
|
|
.Height = ctx->height,
|
|
.MipLevels = 1,
|
|
.Format = s->format,
|
|
.SampleDesc = { .Count = 1 },
|
|
.ArraySize = ctx->initial_pool_size,
|
|
.Usage = D3D11_USAGE_DEFAULT,
|
|
.BindFlags = hwctx->BindFlags,
|
|
.MiscFlags = hwctx->MiscFlags,
|
|
};
|
|
|
|
if (hwctx->texture) {
|
|
D3D11_TEXTURE2D_DESC texDesc2;
|
|
ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
|
|
|
|
if (texDesc.Width != texDesc2.Width ||
|
|
texDesc.Height != texDesc2.Height ||
|
|
texDesc.Format != texDesc2.Format) {
|
|
av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
} else if (texDesc.ArraySize > 0) {
|
|
hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
|
|
if (FAILED(hr)) {
|
|
av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D11FrameDescriptor),
|
|
ctx, d3d11va_pool_alloc, NULL);
|
|
if (!ctx->internal->pool_internal)
|
|
return AVERROR(ENOMEM);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
|
|
{
|
|
AVD3D11FrameDescriptor *desc;
|
|
|
|
frame->buf[0] = av_buffer_pool_get(ctx->pool);
|
|
if (!frame->buf[0])
|
|
return AVERROR(ENOMEM);
|
|
|
|
desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
|
|
|
|
frame->data[0] = (uint8_t *)desc->texture;
|
|
frame->data[1] = (uint8_t *)desc->index;
|
|
frame->format = AV_PIX_FMT_D3D11;
|
|
frame->width = ctx->width;
|
|
frame->height = ctx->height;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
|
|
enum AVHWFrameTransferDirection dir,
|
|
enum AVPixelFormat **formats)
|
|
{
|
|
D3D11VAFramesContext *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;
|
|
|
|
// Don't signal support for opaque formats. Actual access would fail.
|
|
if (s->format == DXGI_FORMAT_420_OPAQUE)
|
|
fmts[0] = AV_PIX_FMT_NONE;
|
|
|
|
*formats = fmts;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int d3d11va_create_staging_texture(AVHWFramesContext *ctx)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
HRESULT hr;
|
|
D3D11_TEXTURE2D_DESC texDesc = {
|
|
.Width = ctx->width,
|
|
.Height = ctx->height,
|
|
.MipLevels = 1,
|
|
.Format = s->format,
|
|
.SampleDesc = { .Count = 1 },
|
|
.ArraySize = 1,
|
|
.Usage = D3D11_USAGE_STAGING,
|
|
.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
|
|
};
|
|
|
|
hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
|
|
if (FAILED(hr)) {
|
|
av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
|
|
AVHWFramesContext *ctx,
|
|
D3D11_TEXTURE2D_DESC *desc,
|
|
D3D11_MAPPED_SUBRESOURCE *map)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
linesize[i] = map->RowPitch;
|
|
|
|
av_image_fill_pointers(data, ctx->sw_format, desc->Height,
|
|
(uint8_t*)map->pData, linesize);
|
|
}
|
|
|
|
static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
|
|
const AVFrame *src)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
|
|
D3D11VAFramesContext *s = ctx->internal->priv;
|
|
int download = src->format == AV_PIX_FMT_D3D11;
|
|
const AVFrame *frame = download ? src : dst;
|
|
const AVFrame *other = download ? dst : src;
|
|
// (The interface types are compatible.)
|
|
ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
|
|
int index = (intptr_t)frame->data[1];
|
|
ID3D11Resource *staging;
|
|
int w = FFMIN(dst->width, src->width);
|
|
int h = FFMIN(dst->height, src->height);
|
|
uint8_t *map_data[4];
|
|
int map_linesize[4];
|
|
D3D11_TEXTURE2D_DESC desc;
|
|
D3D11_MAPPED_SUBRESOURCE map;
|
|
HRESULT hr;
|
|
|
|
if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
|
|
return AVERROR(EINVAL);
|
|
|
|
device_hwctx->lock(device_hwctx->lock_ctx);
|
|
|
|
if (!s->staging_texture) {
|
|
int res = d3d11va_create_staging_texture(ctx);
|
|
if (res < 0)
|
|
return res;
|
|
}
|
|
|
|
staging = (ID3D11Resource *)s->staging_texture;
|
|
|
|
ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
|
|
|
|
if (download) {
|
|
ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
|
|
staging, 0, 0, 0, 0,
|
|
texture, index, NULL);
|
|
|
|
hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
|
|
staging, 0, D3D11_MAP_READ, 0, &map);
|
|
if (FAILED(hr))
|
|
goto map_failed;
|
|
|
|
fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
|
|
|
|
av_image_copy(dst->data, dst->linesize, (const uint8_t **)map_data, map_linesize,
|
|
ctx->sw_format, w, h);
|
|
|
|
ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
|
|
} else {
|
|
hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
|
|
staging, 0, D3D11_MAP_WRITE, 0, &map);
|
|
if (FAILED(hr))
|
|
goto map_failed;
|
|
|
|
fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
|
|
|
|
av_image_copy(map_data, map_linesize, (const uint8_t **)src->data, src->linesize,
|
|
ctx->sw_format, w, h);
|
|
|
|
ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
|
|
|
|
ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
|
|
texture, index, 0, 0, 0,
|
|
staging, 0, NULL);
|
|
}
|
|
|
|
device_hwctx->unlock(device_hwctx->lock_ctx);
|
|
return 0;
|
|
|
|
map_failed:
|
|
av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
|
|
device_hwctx->unlock(device_hwctx->lock_ctx);
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
static int d3d11va_device_init(AVHWDeviceContext *hwdev)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
|
|
HRESULT hr;
|
|
|
|
if (!device_hwctx->lock) {
|
|
device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
|
|
if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
|
|
av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
|
|
return AVERROR(EINVAL);
|
|
}
|
|
device_hwctx->lock = d3d11va_default_lock;
|
|
device_hwctx->unlock = d3d11va_default_unlock;
|
|
}
|
|
|
|
if (!device_hwctx->device_context) {
|
|
ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
|
|
if (!device_hwctx->device_context)
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
if (!device_hwctx->video_device) {
|
|
hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
|
|
(void **)&device_hwctx->video_device);
|
|
if (FAILED(hr))
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
if (!device_hwctx->video_context) {
|
|
hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
|
|
(void **)&device_hwctx->video_context);
|
|
if (FAILED(hr))
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
|
|
|
|
if (device_hwctx->device) {
|
|
ID3D11Device_Release(device_hwctx->device);
|
|
device_hwctx->device = NULL;
|
|
}
|
|
|
|
if (device_hwctx->device_context) {
|
|
ID3D11DeviceContext_Release(device_hwctx->device_context);
|
|
device_hwctx->device_context = NULL;
|
|
}
|
|
|
|
if (device_hwctx->video_device) {
|
|
ID3D11VideoDevice_Release(device_hwctx->video_device);
|
|
device_hwctx->video_device = NULL;
|
|
}
|
|
|
|
if (device_hwctx->video_context) {
|
|
ID3D11VideoContext_Release(device_hwctx->video_context);
|
|
device_hwctx->video_context = NULL;
|
|
}
|
|
|
|
if (device_hwctx->lock == d3d11va_default_lock) {
|
|
CloseHandle(device_hwctx->lock_ctx);
|
|
device_hwctx->lock_ctx = INVALID_HANDLE_VALUE;
|
|
device_hwctx->lock = NULL;
|
|
}
|
|
}
|
|
|
|
static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
|
|
AVDictionary *opts, int flags)
|
|
{
|
|
AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
|
|
|
|
HRESULT hr;
|
|
IDXGIAdapter *pAdapter = NULL;
|
|
ID3D10Multithread *pMultithread;
|
|
UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
|
|
int is_debug = !!av_dict_get(opts, "debug", NULL, 0);
|
|
int ret;
|
|
|
|
// (On UWP we can't check this.)
|
|
#if !HAVE_UWP
|
|
if (!LoadLibrary("d3d11_1sdklayers.dll"))
|
|
is_debug = 0;
|
|
#endif
|
|
|
|
if (is_debug)
|
|
creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
|
|
|
|
if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
|
|
return AVERROR_UNKNOWN;
|
|
if (!mD3D11CreateDevice || !mCreateDXGIFactory) {
|
|
av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library or its functions\n");
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
if (device) {
|
|
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);
|
|
}
|
|
}
|
|
|
|
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 = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
|
|
D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
|
|
if (pAdapter)
|
|
IDXGIAdapter_Release(pAdapter);
|
|
if (FAILED(hr)) {
|
|
av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
|
|
return AVERROR_UNKNOWN;
|
|
}
|
|
|
|
hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
|
|
if (SUCCEEDED(hr)) {
|
|
ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
|
|
ID3D10Multithread_Release(pMultithread);
|
|
}
|
|
|
|
#if !HAVE_UWP && HAVE_DXGIDEBUG_H
|
|
if (is_debug) {
|
|
HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
|
|
if (dxgidebug_dll) {
|
|
HRESULT (WINAPI * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
|
|
= (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
|
|
if (pf_DXGIGetDebugInterface) {
|
|
IDXGIDebug *dxgi_debug = NULL;
|
|
hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
|
|
if (SUCCEEDED(hr) && dxgi_debug)
|
|
IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
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,
|
|
.device_init = d3d11va_device_init,
|
|
.device_uninit = d3d11va_device_uninit,
|
|
.frames_get_constraints = d3d11va_frames_get_constraints,
|
|
.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_D3D11, AV_PIX_FMT_NONE },
|
|
};
|