37 DEFINE_GUID(ff_DXVA2_ModeMPEG2_VLD, 0xee27417f, 0x5e28,0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);
38 DEFINE_GUID(ff_DXVA2_ModeMPEG2and1_VLD, 0x86695f12, 0x340e,0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);
39 DEFINE_GUID(ff_DXVA2_ModeH264_E, 0x1b81be68, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
40 DEFINE_GUID(ff_DXVA2_ModeH264_F, 0x1b81be69, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
41 DEFINE_GUID(ff_DXVADDI_Intel_ModeH264_E, 0x604F8E68, 0x4951,0x4C54,0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6);
42 DEFINE_GUID(ff_DXVA2_ModeVC1_D, 0x1b81beA3, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
43 DEFINE_GUID(ff_DXVA2_ModeVC1_D2010, 0x1b81beA4, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
44 DEFINE_GUID(ff_DXVA2_ModeHEVC_VLD_Main, 0x5b11d51b, 0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);
45 DEFINE_GUID(ff_DXVA2_ModeHEVC_VLD_Main10,0x107af0e0, 0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);
46 DEFINE_GUID(ff_DXVA2_ModeVP9_VLD_Profile0,0x463707f8,0xa1d0,0x4585,0x87,0x6d,0x83,0xaa,0x6d,0x60,0xb8,0x9e);
47 DEFINE_GUID(ff_DXVA2_ModeVP9_VLD_10bit_Profile2,0xa4c749ef,0x6ecf,0x48aa,0x84,0x48,0x50,0xa7,0xa1,0x16,0x5f,0xf7);
48 DEFINE_GUID(ff_DXVA2_ModeAV1_VLD_Profile0,0xb8be4ccb,0xcf53,0x46ba,0x8d,0x59,0xd6,0xb8,0xa6,0xda,0x5d,0x2a);
49 DEFINE_GUID(ff_DXVA2_NoEncrypt, 0x1b81beD0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
50 DEFINE_GUID(ff_GUID_NULL, 0x00000000, 0x0000,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00);
51 DEFINE_GUID(ff_IID_IDirectXVideoDecoderService, 0xfc51a551,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
93 { &ff_DXVA2_ModeVC1_D, AV_CODEC_ID_VC1 },
94 { &ff_DXVA2_ModeVC1_D, AV_CODEC_ID_WMV3 },
111 const void *cfg_list,
115 unsigned i, best_score = 0;
118 for (i = 0; i < cfg_count; i++) {
120 UINT ConfigBitstreamRaw;
121 GUID guidConfigBitstreamEncryption;
125 D3D11_VIDEO_DECODER_CONFIG *cfg = &((D3D11_VIDEO_DECODER_CONFIG *)cfg_list)[
i];
126 ConfigBitstreamRaw = cfg->ConfigBitstreamRaw;
127 guidConfigBitstreamEncryption = cfg->guidConfigBitstreamEncryption;
132 DXVA2_ConfigPictureDecode *cfg = &((DXVA2_ConfigPictureDecode *)cfg_list)[
i];
133 ConfigBitstreamRaw = cfg->ConfigBitstreamRaw;
134 guidConfigBitstreamEncryption = cfg->guidConfigBitstreamEncryption;
138 if (ConfigBitstreamRaw == 1)
144 if (IsEqualGUID(&guidConfigBitstreamEncryption, &ff_DXVA2_NoEncrypt))
146 if (score > best_score) {
161 static int d3d11va_validate_output(
void *service, GUID
guid,
const void *surface_format)
165 hr = ID3D11VideoDevice_CheckVideoDecoderFormat((ID3D11VideoDevice *)service,
167 *(DXGI_FORMAT *)surface_format,
174 static int dxva2_validate_output(
void *decoder_service, GUID
guid,
const void *surface_format)
178 unsigned j, target_count;
179 D3DFORMAT *target_list;
180 hr = IDirectXVideoDecoderService_GetDecoderRenderTargets((IDirectXVideoDecoderService *)decoder_service, &
guid, &target_count, &target_list);
182 for (j = 0; j < target_count; j++) {
183 const D3DFORMAT
format = target_list[j];
184 if (format == *(D3DFORMAT *)surface_format) {
189 CoTaskMemFree(target_list);
216 unsigned guid_count,
const GUID *guid_list)
223 for (i = 0; i < guid_count; i++) {
224 const GUID *
guid = &guid_list[
i];
227 "{%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x}",
228 (
unsigned) guid->Data1, guid->Data2, guid->Data3,
229 guid->Data4[0], guid->Data4[1],
230 guid->Data4[2], guid->Data4[3],
231 guid->Data4[4], guid->Data4[5],
232 guid->Data4[6], guid->Data4[7]);
239 for (format = 0; format < 200; format++) {
240 if (d3d11va_validate_output(service, *guid, &format))
248 MKTAG(
'P',
'0',
'1',
'0')};
251 if (dxva2_validate_output(service, *guid, &formats[i]))
261 unsigned guid_count,
const GUID *guid_list, GUID *decoder_guid)
268 *decoder_guid = ff_GUID_NULL;
269 for (i = 0; dxva_modes[
i].
guid; i++) {
275 for (j = 0; j < guid_count; j++) {
276 if (IsEqualGUID(mode->
guid, &guid_list[j]))
284 validate = d3d11va_validate_output(service, *mode->
guid, surface_format);
288 validate = dxva2_validate_output(service, *mode->
guid, surface_format);
291 *decoder_guid = *mode->
guid;
296 if (IsEqualGUID(decoder_guid, &ff_GUID_NULL)) {
301 if (IsEqualGUID(decoder_guid, &ff_DXVADDI_Intel_ModeH264_E))
309 IUnknown_Release((IUnknown *)opaque);
319 static int dxva2_get_decoder_configuration(
AVCodecContext *avctx,
const GUID *device_guid,
320 const DXVA2_VideoDesc *
desc,
321 DXVA2_ConfigPictureDecode *config)
325 DXVA2_ConfigPictureDecode *cfg_list;
329 hr = IDirectXVideoDecoderService_GetDecoderConfigurations(sctx->dxva2_service, device_guid,
desc,
NULL, &cfg_count, &cfg_list);
337 *config = cfg_list[
ret];
338 CoTaskMemFree(cfg_list);
349 MKTAG(
'P',
'0',
'1',
'0') :
MKTAG(
'N',
'V',
'1',
'2');
350 DXVA2_VideoDesc
desc = { 0 };
351 DXVA2_ConfigPictureDecode config;
354 HANDLE device_handle;
359 hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr,
366 hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr, device_handle,
367 &ff_IID_IDirectXVideoDecoderService,
368 (
void **)&sctx->dxva2_service);
369 IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, device_handle);
375 hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(sctx->dxva2_service, &guid_count, &guid_list);
382 guid_count, guid_list, &device_guid);
383 CoTaskMemFree(guid_list);
390 desc.Format = surface_format;
392 ret = dxva2_get_decoder_configuration(avctx, &device_guid, &desc, &config);
397 hr = IDirectXVideoDecoderService_CreateVideoDecoder(sctx->dxva2_service, &device_guid,
398 &desc, &config, frames_hwctx->surfaces,
399 frames_hwctx->nb_surfaces, &sctx->dxva2_decoder);
405 sctx->dxva2_config = config;
420 static int d3d11va_get_decoder_configuration(
AVCodecContext *avctx,
421 ID3D11VideoDevice *video_device,
422 const D3D11_VIDEO_DECODER_DESC *
desc,
423 D3D11_VIDEO_DECODER_CONFIG *config)
425 unsigned cfg_count = 0;
426 D3D11_VIDEO_DECODER_CONFIG *cfg_list =
NULL;
430 hr = ID3D11VideoDevice_GetVideoDecoderConfigCount(video_device,
desc, &cfg_count);
436 cfg_list =
av_malloc_array(cfg_count,
sizeof(D3D11_VIDEO_DECODER_CONFIG));
437 if (cfg_list ==
NULL)
439 for (i = 0; i < cfg_count; i++) {
440 hr = ID3D11VideoDevice_GetVideoDecoderConfig(video_device,
desc, i, &cfg_list[i]);
442 av_log(avctx,
AV_LOG_ERROR,
"Unable to retrieve decoder configurations. (hr=0x%lX)\n", hr);
450 *config = cfg_list[
ret];
461 default:
return DXGI_FORMAT_UNKNOWN;
469 unsigned guid_count,
i;
471 D3D11_VIDEO_DECODER_DESC
desc = { 0 };
472 D3D11_VIDEO_DECODER_CONFIG config;
476 DXGI_FORMAT surface_format = d3d11va_map_sw_to_hw_format(frames_ctx->
sw_format);
477 D3D11_TEXTURE2D_DESC texdesc;
481 if (!frames_hwctx->texture) {
485 ID3D11Texture2D_GetDesc(frames_hwctx->texture, &texdesc);
487 guid_count = ID3D11VideoDevice_GetVideoDecoderProfileCount(device_hwctx->video_device);
489 if (guid_list ==
NULL || guid_count == 0) {
494 for (i = 0; i < guid_count; i++) {
495 hr = ID3D11VideoDevice_GetVideoDecoderProfile(device_hwctx->video_device, i, &guid_list[i]);
504 guid_count, guid_list, &decoder_guid);
511 desc.OutputFormat = surface_format;
512 desc.Guid = decoder_guid;
514 ret = d3d11va_get_decoder_configuration(avctx, device_hwctx->video_device, &desc, &config);
518 sctx->d3d11_views =
av_mallocz_array(texdesc.ArraySize,
sizeof(sctx->d3d11_views[0]));
519 if (!sctx->d3d11_views)
521 sctx->nb_d3d11_views = texdesc.ArraySize;
523 for (i = 0; i < sctx->nb_d3d11_views; i++) {
524 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc = {
525 .DecodeProfile = decoder_guid,
526 .ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D,
531 hr = ID3D11VideoDevice_CreateVideoDecoderOutputView(device_hwctx->video_device,
532 (ID3D11Resource*) frames_hwctx->texture,
534 (ID3D11VideoDecoderOutputView**) &sctx->d3d11_views[i]);
541 hr = ID3D11VideoDevice_CreateVideoDecoder(device_hwctx->video_device, &desc,
542 &config, &sctx->d3d11_decoder);
548 sctx->d3d11_config = config;
549 sctx->d3d11_texture = frames_hwctx->texture;
567 WaitForSingleObjectEx(
D3D11VA_CONTEXT(ctx)->context_mutex, INFINITE, FALSE);
597 int surface_alignment, num_surfaces;
610 surface_alignment = 32;
614 surface_alignment = 128;
616 surface_alignment = 16;
640 frames_hwctx->
surface_type = DXVA2_VideoDecoderRenderTarget;
648 frames_hwctx->
BindFlags |= D3D11_BIND_DECODER;
689 ret = d3d11va_create_decoder(avctx);
694 d3d11_ctx->
decoder = sctx->d3d11_decoder;
696 d3d11_ctx->
cfg = &sctx->d3d11_config;
698 d3d11_ctx->
surface = sctx->d3d11_views;
710 ret = dxva2_create_decoder(avctx);
715 dxva_ctx->
decoder = sctx->dxva2_decoder;
716 dxva_ctx->
cfg = &sctx->dxva2_config;
738 for (i = 0; i < sctx->nb_d3d11_views; i++) {
739 if (sctx->d3d11_views[i])
740 ID3D11VideoDecoderOutputView_Release(sctx->d3d11_views[i]);
746 if (sctx->dxva2_service)
747 IDirectXVideoDecoderService_Release(sctx->dxva2_service);
758 intptr_t
index = (intptr_t)frame->
data[1];
759 if (index < 0 || index >= sctx->nb_d3d11_views ||
760 sctx->d3d11_texture != (ID3D11Texture2D *)frame->
data[0]) {
764 return sctx->d3d11_views[
index];
767 return frame->
data[3];
779 return (intptr_t)frame->
data[1];
781 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
782 ID3D11VideoDecoderOutputView_GetDesc((ID3D11VideoDecoderOutputView*) surface, &viewDesc);
783 return viewDesc.Texture2D.ArraySlice;
787 for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++) {
810 hr = ID3D11VideoContext_GetDecoderBuffer(
D3D11VA_CONTEXT(ctx)->video_context,
813 &dxva_size, &dxva_data);
818 &dxva_data, &dxva_size);
825 if (size <= dxva_size) {
826 memcpy(dxva_data, data, size);
830 D3D11_VIDEO_DECODER_BUFFER_DESC *dsc11 = dsc;
831 memset(dsc11, 0,
sizeof(*dsc11));
832 dsc11->BufferType =
type;
833 dsc11->DataSize =
size;
834 dsc11->NumMBsInBuffer = mb_count;
839 DXVA2_DecodeBufferDesc *dsc2 = dsc;
840 memset(dsc2, 0,
sizeof(*dsc2));
841 dsc2->CompressedBufferType =
type;
842 dsc2->DataSize =
size;
843 dsc2->NumMBsInBuffer = mb_count;
863 "Failed to release buffer type %u: 0x%x\n",
875 if (!frame->
buf[i]) {
887 const void *pp,
unsigned pp_size,
888 const void *qm,
unsigned qm_size,
894 unsigned buffer_count = 0;
896 D3D11_VIDEO_DECODER_BUFFER_DESC buffer11[4];
899 DXVA2_DecodeBufferDesc buffer2[4];
927 if (hr != E_PENDING || ++runs > 50)
941 buffer = &buffer11[buffer_count];
942 type = D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
947 buffer = &buffer2[buffer_count];
948 type = DXVA2_PictureParametersBufferType;
956 "Failed to add picture parameter buffer\n");
964 buffer = &buffer11[buffer_count];
965 type = D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX;
970 buffer = &buffer2[buffer_count];
971 type = DXVA2_InverseQuantizationMatrixBufferType;
979 "Failed to add inverse quantization matrix buffer\n");
987 buffer = &buffer11[buffer_count + 0];
988 buffer_slice = &buffer11[buffer_count + 1];
993 buffer = &buffer2[buffer_count + 0];
994 buffer_slice = &buffer2[buffer_count + 1];
998 result = commit_bs_si(avctx,
1003 "Failed to add bitstream or slice control buffer\n");
1010 assert(buffer_count == 1 + (qm_size > 0) + 2);
1014 hr = ID3D11VideoContext_SubmitDecoderBuffers(
D3D11VA_CONTEXT(ctx)->video_context,
1016 buffer_count, buffer11);
1020 DXVA2_DecodeExecuteParams exec = {
1021 .NumCompBuffers = buffer_count,
1022 .pCompressedBuffers = buffer2,
1023 .pExtensionData =
NULL,
#define FF_PROFILE_H264_MAIN
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
This structure is used to provides the necessary configurations and data to the Direct3D11 FFmpeg HWA...
static enum AVPixelFormat pix_fmt
#define AV_NUM_DATA_POINTERS
#define FF_PROFILE_MPEG2_MAIN
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
int coded_width
Bitstream width / height, may be different from width/height e.g.
DEFINE_GUID(ff_DXVA2_ModeMPEG2_VLD, 0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9)
static int dxva_get_decoder_guid(AVCodecContext *avctx, void *service, void *surface_format, unsigned guid_count, const GUID *guid_list, GUID *decoder_guid)
This struct is allocated as AVHWFramesContext.hwctx.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
enum AVPixelFormat pix_fmt
Supported pixel format.
int width
The allocated dimensions of the frames in this pool.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
static void * get_surface(const AVCodecContext *avctx, const AVFrame *frame)
LPDIRECT3DSURFACE9 * surface
The array of Direct3D surfaces used to create the decoder.
int av_usleep(unsigned usec)
Sleep for a period of time.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
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
#define D3D11VA_CONTEXT(ctx)
const DXVA2_ConfigPictureDecode * cfg
DXVA2 configuration used to create the decoder.
UINT BindFlags
D3D11_TEXTURE2D_DESC.BindFlags used for texture creation.
unsigned surface_count
The number of surface in the surface array.
int ff_dxva2_common_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
int ff_dxva2_decode_uninit(AVCodecContext *avctx)
static const dxva_mode dxva_modes[]
void * hwaccel_context
Hardware accelerator context.
HANDLE context_mutex
Mutex to access video_context.
ID3D11VideoDecoder * decoder
D3D11 decoder object.
DWORD surface_type
The surface type (e.g.
static av_cold int end(AVCodecContext *avctx)
int ff_dxva2_common_end_frame(AVCodecContext *avctx, AVFrame *frame, const void *pp, unsigned pp_size, const void *qm, unsigned qm_size, int(*commit_bs_si)(AVCodecContext *, DECODER_BUFFER_DESC *bs, DECODER_BUFFER_DESC *slice))
#define FF_PROFILE_HEVC_MAIN
#define DXVA_SHARED_CONTEXT(avctx)
static void ff_dxva2_lock(AVCodecContext *avctx)
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
#define AV_LOG_VERBOSE
Detailed information.
#define FF_PROFILE_HEVC_MAIN_10
uint64_t workaround
A bit field configuring the workarounds needed for using the decoder.
AVCodecID
Identify the syntax and semantics of the bitstream.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
D3D11_VIDEO_DECODER_CONFIG * cfg
D3D11 configuration used to create the decoder.
static AVBufferRef * bufref_wrap_interface(IUnknown *iface)
int ff_dxva2_is_d3d11(const AVCodecContext *avctx)
#define FF_PROFILE_H264_HIGH
#define DXVA2_CONTEXT(ctx)
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
static const int prof_hevc_main10[]
ID3D11VideoContext * video_context
If unset, this will be set from the device_context field on init.
int initial_pool_size
Initial size of the frame pool.
static void ff_dxva2_unlock(AVCodecContext *avctx)
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
static const chunk_decoder decoder[8]
#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO
Work around for Direct3D11 and old Intel GPUs with ClearVideo interface.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
#define FF_PROFILE_UNKNOWN
static void bufref_free_interface(void *opaque, uint8_t *data)
unsigned surface_count
The number of surface in the surface array.
ID3D11VideoContext * video_context
D3D11 VideoContext.
static int dxva_get_decoder_configuration(AVCodecContext *avctx, const void *cfg_list, unsigned cfg_count)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
int ff_dxva2_decode_init(AVCodecContext *avctx)
AVHWDeviceContext * device_ctx
void(* unlock)(void *lock_ctx)
preferred ID for MPEG-1/2 video decoding
enum AVPixelFormat pix_fmt
#define FF_ARRAY_ELEMS(a)
static int dxva_check_codec_compatibility(AVCodecContext *avctx, const dxva_mode *mode)
static const int prof_h264_high[]
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Libavcodec external API header.
unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx, const AVDXVAContext *ctx, const AVFrame *frame)
static int is_supported(enum AVCodecID id)
main external API structure.
uint8_t * data
The data buffer.
void * hwctx
The format-specific data, allocated and freed automatically along with this context.
static const int prof_vp9_profile0[]
int ff_dxva2_commit_buffer(AVCodecContext *avctx, AVDXVAContext *ctx, DECODER_BUFFER_DESC *dsc, unsigned type, const void *data, unsigned size, unsigned mb_count)
#define AV_PIX_FMT_YUV420P10
static const int prof_mpeg2_main[]
#define FF_PROFILE_AV1_MAIN
uint64_t workaround
A bit field configuring the workarounds needed for using the decoder.
This struct describes a set or pool of "hardware" frames (i.e.
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
This struct is allocated as AVHWFramesContext.hwctx.
AVBufferRef * decoder_ref
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Hardware surfaces for Direct3D11.
A reference to a data buffer.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal and external API header
static int ref[MAX_W *MAX_W]
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
ID3D11VideoDecoderOutputView ** surface
The array of Direct3D surfaces used to create the decoder.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
IDirect3DSurface9 ** surfaces
The surface pool.
static int frame_add_buf(AVFrame *frame, AVBufferRef *ref)
This struct is allocated as AVHWDeviceContext.hwctx.
static void dxva_list_guids_debug(AVCodecContext *avctx, void *service, unsigned guid_count, const GUID *guid_list)
void(* lock)(void *lock_ctx)
Callbacks for locking.
#define FF_PROFILE_MPEG2_SIMPLE
static const int prof_av1_profile0[]
#define DXVA_CONTEXT(avctx)
static const int prof_hevc_main[]
and forward the result(frame or status change) to the corresponding input.If nothing is possible
This struct is allocated as AVHWDeviceContext.hwctx.
#define AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH
Hardware acceleration should still be attempted for decoding when the codec profile does not match th...
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active)...
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
IDirectXVideoDecoder * decoder
DXVA2 decoder object.
#define av_malloc_array(a, b)
#define FF_PROFILE_H264_CONSTRAINED_BASELINE
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
#define MKTAG(a, b, c, d)
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
AVPixelFormat
Pixel format.
mode
Use these values in ebur128_init (or'ed).
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
static const int prof_vp9_profile2[]
This structure is used to provides the necessary configurations and data to the DXVA2 FFmpeg HWAccel ...
void * av_mallocz_array(size_t nmemb, size_t size)