Go to the documentation of this file.
30 #include <dxgidebug.h>
57 HANDLE d3dlib, dxgilib;
59 d3dlib = dlopen(
"d3d11.dll", 0);
60 dxgilib = dlopen(
"dxgi.dll", 0);
61 if (!d3dlib || !dxgilib)
64 mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib,
"D3D11CreateDevice");
113 WaitForSingleObjectEx(
ctx, INFINITE, FALSE);
127 ID3D11Texture2D_Release(frames_hwctx->
texture);
130 if (
s->staging_texture)
131 ID3D11Texture2D_Release(
s->staging_texture);
132 s->staging_texture =
NULL;
138 const void *hwconfig,
142 int nb_sw_formats = 0;
152 UINT format_support = 0;
154 if (SUCCEEDED(hr) && (format_support & D3D11_FORMAT_SUPPORT_TEXTURE2D))
171 ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
182 ID3D11Texture2D_Release(tex);
186 if (
s->nb_surfaces <=
s->nb_surfaces_used) {
188 s->nb_surfaces_used + 1,
191 ID3D11Texture2D_Release(tex);
194 s->nb_surfaces =
s->nb_surfaces_used + 1;
199 s->nb_surfaces_used++;
206 ID3D11Texture2D_Release(tex);
220 ID3D11Texture2D *tex;
221 D3D11_TEXTURE2D_DESC texDesc = {
223 .Height =
ctx->height,
226 .SampleDesc = { .Count = 1 },
228 .Usage = D3D11_USAGE_DEFAULT,
233 hr = ID3D11Device_CreateTexture2D(device_hwctx->
device, &texDesc,
NULL, &tex);
247 D3D11_TEXTURE2D_DESC texDesc;
252 ID3D11Texture2D_GetDesc(hwctx->
texture, &texDesc);
254 if (
s->nb_surfaces_used >= texDesc.ArraySize) {
259 ID3D11Texture2D_AddRef(hwctx->
texture);
271 D3D11_TEXTURE2D_DESC texDesc;
285 texDesc = (D3D11_TEXTURE2D_DESC){
287 .Height =
ctx->height,
290 .SampleDesc = { .Count = 1 },
291 .ArraySize =
ctx->initial_pool_size,
292 .Usage = D3D11_USAGE_DEFAULT,
298 D3D11_TEXTURE2D_DESC texDesc2;
299 ID3D11Texture2D_GetDesc(hwctx->
texture, &texDesc2);
301 if (texDesc.Width != texDesc2.Width ||
302 texDesc.Height != texDesc2.Height ||
303 texDesc.Format != texDesc2.Format) {
308 ctx->initial_pool_size = texDesc2.ArraySize;
311 }
else if (!(texDesc.BindFlags & D3D11_BIND_RENDER_TARGET) && texDesc.ArraySize > 0) {
312 hr = ID3D11Device_CreateTexture2D(device_hwctx->
device, &texDesc,
NULL, &hwctx->
texture);
322 s->nb_surfaces =
ctx->initial_pool_size;
363 fmts[0] =
ctx->sw_format;
367 if (
s->format == DXGI_FORMAT_420_OPAQUE)
380 D3D11_TEXTURE2D_DESC texDesc = {
382 .Height =
ctx->height,
385 .SampleDesc = { .Count = 1 },
387 .Usage = D3D11_USAGE_STAGING,
388 .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
391 hr = ID3D11Device_CreateTexture2D(device_hwctx->
device, &texDesc,
NULL, &
s->staging_texture);
402 D3D11_TEXTURE2D_DESC *
desc,
403 D3D11_MAPPED_SUBRESOURCE *
map)
407 for (
i = 0;
i < 4;
i++)
408 linesize[
i] =
map->RowPitch;
411 (uint8_t*)
map->pData, linesize);
423 ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)
frame->
data[0];
425 ID3D11Resource *staging;
428 uint8_t *map_data[4];
430 D3D11_TEXTURE2D_DESC
desc;
431 D3D11_MAPPED_SUBRESOURCE
map;
440 if (!
s->staging_texture) {
441 ID3D11Texture2D_GetDesc((ID3D11Texture2D *)texture, &
desc);
447 staging = (ID3D11Resource *)
s->staging_texture;
449 ID3D11Texture2D_GetDesc(
s->staging_texture, &
desc);
452 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->
device_context,
457 staging, 0, D3D11_MAP_READ, 0, &
map);
464 ctx->sw_format,
w,
h);
466 ID3D11DeviceContext_Unmap(device_hwctx->
device_context, staging, 0);
469 staging, 0, D3D11_MAP_WRITE, 0, &
map);
476 ctx->sw_format,
w,
h);
478 ID3D11DeviceContext_Unmap(device_hwctx->
device_context, staging, 0);
480 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->
device_context,
481 texture,
index, 0, 0, 0,
499 if (!device_hwctx->
lock) {
501 if (device_hwctx->
lock_ctx == INVALID_HANDLE_VALUE) {
516 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->
device, &IID_ID3D11VideoDevice,
523 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->
device_context, &IID_ID3D11VideoContext,
536 if (device_hwctx->
device) {
537 ID3D11Device_Release(device_hwctx->
device);
557 CloseHandle(device_hwctx->
lock_ctx);
558 device_hwctx->
lock_ctx = INVALID_HANDLE_VALUE;
566 IDXGIAdapter *adapter =
NULL;
567 IDXGIFactory2 *factory;
569 long int id = strtol(vendor_id,
NULL, 0);
577 while (IDXGIFactory2_EnumAdapters(factory, adapter_id++, &adapter) != DXGI_ERROR_NOT_FOUND) {
579 DXGI_ADAPTER_DESC adapter_desc;
584 IDXGIAdapter_Release(adapter);
588 hr = IDXGIAdapter2_GetDesc(adapter, &adapter_desc);
589 ID3D11Device_Release(device);
590 IDXGIAdapter_Release(adapter);
594 }
else if (adapter_desc.VendorId ==
id) {
595 IDXGIFactory2_Release(factory);
596 return adapter_id - 1;
600 IDXGIFactory2_Release(factory);
610 IDXGIAdapter *pAdapter =
NULL;
611 ID3D10Multithread *pMultithread;
612 UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
618 creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
630 adapter = atoi(device);
637 "vendor id %s\n", e->
value);
644 IDXGIFactory2 *pDXGIFactory;
649 if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
651 IDXGIFactory2_Release(pDXGIFactory);
656 DXGI_ADAPTER_DESC
desc;
657 hr = IDXGIAdapter2_GetDesc(pAdapter, &
desc);
664 hr =
mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE,
NULL, creationFlags,
NULL, 0,
667 IDXGIAdapter_Release(pAdapter);
673 hr = ID3D11Device_QueryInterface(device_hwctx->
device, &IID_ID3D10Multithread, (
void **)&pMultithread);
675 ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
676 ID3D10Multithread_Release(pMultithread);
679 #if !HAVE_UWP && HAVE_DXGIDEBUG_H
681 HANDLE dxgidebug_dll = LoadLibrary(
"dxgidebug.dll");
683 HRESULT (WINAPI * pf_DXGIGetDebugInterface)(
const GUID *riid,
void **ppDebug)
684 = (
void *)GetProcAddress(dxgidebug_dll,
"DXGIGetDebugInterface");
685 if (pf_DXGIGetDebugInterface) {
686 IDXGIDebug *dxgi_debug =
NULL;
687 hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (
void**)&dxgi_debug);
688 if (SUCCEEDED(hr) && dxgi_debug) {
689 IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
static AVBufferRef * d3d11va_alloc_single(AVHWFramesContext *ctx)
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
AVBufferPool * pool_internal
#define AV_LOG_WARNING
Something somehow does not look correct.
AVPixelFormat
Pixel format.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
@ DXGI_FORMAT_B8G8R8A8_UNORM
uint8_t * data
The data buffer.
static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)
This structure describes decoded (raw) audio or video data.
UINT MiscFlags
D3D11_TEXTURE2D_DESC.MiscFlags used for texture creation.
static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
#define AV_LOG_VERBOSE
Detailed information.
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
enum AVPixelFormat * valid_hw_formats
A list of possible values for format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static void fill_texture_ptrs(uint8_t *data[4], int linesize[4], AVHWFramesContext *ctx, D3D11_TEXTURE2D_DESC *desc, D3D11_MAPPED_SUBRESOURCE *map)
HRESULT(WINAPI * PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
UINT BindFlags
D3D11_TEXTURE2D_DESC.BindFlags used for texture creation.
const HWContextType ff_hwcontext_type_d3d11va
static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
ID3D11Texture2D * texture
The texture in which the frame is located.
static int d3d11va_create_staging_texture(AVHWFramesContext *ctx, DXGI_FORMAT format)
@ AV_HWDEVICE_TYPE_D3D11VA
AVBufferPool * av_buffer_pool_init2(size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, size_t size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
static void d3d11va_default_unlock(void *ctx)
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
static int d3d11va_frames_get_constraints(AVHWDeviceContext *ctx, const void *hwconfig, AVHWFramesConstraints *constraints)
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
static FFHWFramesContext * ffhwframesctx(AVHWFramesContext *ctx)
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
static av_cold void load_functions(void)
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
ID3D11VideoContext * video_context
If unset, this will be set from the device_context field on init.
ID3D11Device * device
Device used for texture creation and access.
static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
static AVOnce functions_loaded
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
#define av_realloc_f(p, o, n)
AVD3D11FrameDescriptor * texture_infos
In case if texture structure member above is not NULL contains the same texture pointer for all eleme...
static const struct @363 supported_formats[]
static void d3d11va_default_lock(void *ctx)
ID3D11VideoDevice * video_device
If unset, this will be set from the device field on init.
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
static AVBufferRef * wrap_texture_buf(AVHWFramesContext *ctx, ID3D11Texture2D *tex, int index)
void(* unlock)(void *lock_ctx)
This struct is allocated as AVHWFramesContext.hwctx.
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
static int d3d11va_device_find_adapter_by_vendor_id(AVHWDeviceContext *ctx, uint32_t flags, const char *vendor_id)
#define AV_PIX_FMT_X2BGR10
static int d3d11va_frames_init(AVHWFramesContext *ctx)
static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
static void free_texture(void *opaque, uint8_t *data)
ID3D11Texture2D * texture
The canonical texture used for pool allocation.
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
#define AV_LOG_INFO
Standard information.
@ DXGI_FORMAT_R16G16B16A16_FLOAT
#define i(width, name, range_min, range_max)
#define av_malloc_array(a, b)
This struct is allocated as AVHWDeviceContext.hwctx.
intptr_t index
The index into the array texture element representing the frame, or 0 if the texture is not an array ...
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
void(* lock)(void *lock_ctx)
Callbacks for locking.
AVHWFrameTransferDirection
This struct describes a set or pool of "hardware" frames (i.e.
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame.
static AVBufferRef * d3d11va_pool_alloc(void *opaque, size_t size)
enum AVPixelFormat pix_fmt
static void av_image_copy2(uint8_t *const dst_data[4], const int dst_linesizes[4], uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Wrapper around av_image_copy() to workaround the limitation that the conversion from uint8_t * const ...
static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
ID3D11Texture2D * staging_texture
A reference to a data buffer.
static int d3d11va_device_init(AVHWDeviceContext *hwdev)
AVD3D11VAFramesContext p
The public AVD3D11VAFramesContext.
const VDPAUPixFmtMap * map
#define AV_PIX_FMT_RGBAF16
D3D11 frame descriptor for pool allocation.
#define flags(name, subs,...)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
ID3D11DeviceContext * device_context
If unset, this will be set from the device field on init.
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.