1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <windows.h>
20
21 #define DXVA2API_USE_BITFIELDS
22 #define COBJMACROS
23
24 #include <d3d9.h>
25 #include <dxva2api.h>
26 #include <initguid.h>
27
28 #include "avassert.h"
29 #include "common.h"
30 #include "hwcontext.h"
31 #include "hwcontext_dxva2.h"
32 #include "hwcontext_internal.h"
33 #include "imgutils.h"
34 #include "pixdesc.h"
35 #include "pixfmt.h"
36 #include "compat/w32dlfcn.h"
37
38 typedef IDirect3D9* WINAPI pDirect3DCreate9(UINT);
39 typedef HRESULT WINAPI pDirect3DCreate9Ex(UINT, IDirect3D9Ex **);
40 typedef HRESULT WINAPI pCreateDeviceManager9(UINT *, IDirect3DDeviceManager9 **);
41
42 #define FF_D3DCREATE_FLAGS (D3DCREATE_SOFTWARE_VERTEXPROCESSING | \
43 D3DCREATE_MULTITHREADED | \
44 D3DCREATE_FPU_PRESERVE)
45
46 static const D3DPRESENT_PARAMETERS dxva2_present_params = {
47 .Windowed = TRUE,
48 .BackBufferWidth = 640,
49 .BackBufferHeight = 480,
50 .BackBufferCount = 0,
51 .SwapEffect = D3DSWAPEFFECT_DISCARD,
52 .Flags = D3DPRESENTFLAG_VIDEO,
53 };
54
55 typedef struct DXVA2Mapping {
56 uint32_t palette_dummy[256];
57 } DXVA2Mapping;
58
59 typedef struct DXVA2FramesContext {
60 IDirect3DSurface9 **surfaces_internal;
61 int nb_surfaces_used;
62
63 HANDLE device_handle;
64 IDirectXVideoAccelerationService *service;
65
66 D3DFORMAT format;
67 } DXVA2FramesContext;
68
69 typedef struct DXVA2DevicePriv {
70 HMODULE d3dlib;
71 HMODULE dxva2lib;
72
73 HANDLE device_handle;
74
75 IDirect3D9 *d3d9;
76 IDirect3DDevice9 *d3d9device;
77 } DXVA2DevicePriv;
78
79 static const struct {
80 D3DFORMAT d3d_format;
81 enum AVPixelFormat pix_fmt;
82 } supported_formats[] = {
83 { MKTAG('N', 'V', '1', '2'), AV_PIX_FMT_NV12 },
84 { MKTAG('P', '0', '1', '0'), AV_PIX_FMT_P010 },
85 { D3DFMT_P8, AV_PIX_FMT_PAL8 },
86 { D3DFMT_A8R8G8B8, AV_PIX_FMT_BGRA },
87 };
88
89 DEFINE_GUID(video_decoder_service, 0xfc51a551, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
90 DEFINE_GUID(video_processor_service, 0xfc51a552, 0xd5e7, 0x11d9, 0xaf, 0x55, 0x00, 0x05, 0x4e, 0x43, 0xff, 0x02);
91
dxva2_frames_uninit(AVHWFramesContext * ctx)92 static void dxva2_frames_uninit(AVHWFramesContext *ctx)
93 {
94 AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
95 AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
96 DXVA2FramesContext *s = ctx->internal->priv;
97 int i;
98
99 if (frames_hwctx->decoder_to_release)
100 IDirectXVideoDecoder_Release(frames_hwctx->decoder_to_release);
101
102 if (s->surfaces_internal) {
103 for (i = 0; i < frames_hwctx->nb_surfaces; i++) {
104 if (s->surfaces_internal[i])
105 IDirect3DSurface9_Release(s->surfaces_internal[i]);
106 }
107 }
108 av_freep(&s->surfaces_internal);
109
110 if (s->service) {
111 IDirectXVideoAccelerationService_Release(s->service);
112 s->service = NULL;
113 }
114
115 if (s->device_handle != INVALID_HANDLE_VALUE) {
116 IDirect3DDeviceManager9_CloseDeviceHandle(device_hwctx->devmgr, s->device_handle);
117 s->device_handle = INVALID_HANDLE_VALUE;
118 }
119 }
120
dxva2_pool_release_dummy(void * opaque,uint8_t * data)121 static void dxva2_pool_release_dummy(void *opaque, uint8_t *data)
122 {
123 // important not to free anything here--data is a surface object
124 // associated with the call to CreateSurface(), and these surfaces are
125 // released in dxva2_frames_uninit()
126 }
127
dxva2_pool_alloc(void * opaque,size_t size)128 static AVBufferRef *dxva2_pool_alloc(void *opaque, size_t size)
129 {
130 AVHWFramesContext *ctx = (AVHWFramesContext*)opaque;
131 DXVA2FramesContext *s = ctx->internal->priv;
132 AVDXVA2FramesContext *hwctx = ctx->hwctx;
133
134 if (s->nb_surfaces_used < hwctx->nb_surfaces) {
135 s->nb_surfaces_used++;
136 return av_buffer_create((uint8_t*)s->surfaces_internal[s->nb_surfaces_used - 1],
137 sizeof(*hwctx->surfaces), dxva2_pool_release_dummy, 0, 0);
138 }
139
140 return NULL;
141 }
142
dxva2_init_pool(AVHWFramesContext * ctx)143 static int dxva2_init_pool(AVHWFramesContext *ctx)
144 {
145 AVDXVA2FramesContext *frames_hwctx = ctx->hwctx;
146 AVDXVA2DeviceContext *device_hwctx = ctx->device_ctx->hwctx;
147 DXVA2FramesContext *s = ctx->internal->priv;
148 int decode = (frames_hwctx->surface_type == DXVA2_VideoDecoderRenderTarget);
149
150 int i;
151 HRESULT hr;
152
153 if (ctx->initial_pool_size <= 0)
154 return 0;
155
156 hr = IDirect3DDeviceManager9_OpenDeviceHandle(device_hwctx->devmgr, &s->device_handle);
157 if (FAILED(hr)) {
158 av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
159 return AVERROR_UNKNOWN;
160 }
161
162 hr = IDirect3DDeviceManager9_GetVideoService(device_hwctx->devmgr,
163 s->device_handle,
164 decode ? &video_decoder_service : &video_processor_service,
165 (void **)&s->service);
166 if (FAILED(hr)) {
167 av_log(ctx, AV_LOG_ERROR, "Failed to create the video service\n");
168 return AVERROR_UNKNOWN;
169 }
170
171 for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
172 if (ctx->sw_format == supported_formats[i].pix_fmt) {
173 s->format = supported_formats[i].d3d_format;
174 break;
175 }
176 }
177 if (i == FF_ARRAY_ELEMS(supported_formats)) {
178 av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
179 av_get_pix_fmt_name(ctx->sw_format));
180 return AVERROR(EINVAL);
181 }
182
183 s->surfaces_internal = av_calloc(ctx->initial_pool_size,
184 sizeof(*s->surfaces_internal));
185 if (!s->surfaces_internal)
186 return AVERROR(ENOMEM);
187
188 hr = IDirectXVideoAccelerationService_CreateSurface(s->service,
189 ctx->width, ctx->height,
190 ctx->initial_pool_size - 1,
191 s->format, D3DPOOL_DEFAULT, 0,
192 frames_hwctx->surface_type,
193 s->surfaces_internal, NULL);
194 if (FAILED(hr)) {
195 av_log(ctx, AV_LOG_ERROR, "Could not create the surfaces\n");
196 return AVERROR_UNKNOWN;
197 }
198
199 ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(*s->surfaces_internal),
200 ctx, dxva2_pool_alloc, NULL);
201 if (!ctx->internal->pool_internal)
202 return AVERROR(ENOMEM);
203
204 frames_hwctx->surfaces = s->surfaces_internal;
205 frames_hwctx->nb_surfaces = ctx->initial_pool_size;
206
207 return 0;
208 }
209
dxva2_frames_init(AVHWFramesContext * ctx)210 static int dxva2_frames_init(AVHWFramesContext *ctx)
211 {
212 AVDXVA2FramesContext *hwctx = ctx->hwctx;
213 DXVA2FramesContext *s = ctx->internal->priv;
214 int ret;
215
216 if (hwctx->surface_type != DXVA2_VideoDecoderRenderTarget &&
217 hwctx->surface_type != DXVA2_VideoProcessorRenderTarget) {
218 av_log(ctx, AV_LOG_ERROR, "Unknown surface type: %lu\n",
219 hwctx->surface_type);
220 return AVERROR(EINVAL);
221 }
222
223 s->device_handle = INVALID_HANDLE_VALUE;
224
225 /* init the frame pool if the caller didn't provide one */
226 if (!ctx->pool) {
227 ret = dxva2_init_pool(ctx);
228 if (ret < 0) {
229 av_log(ctx, AV_LOG_ERROR, "Error creating an internal frame pool\n");
230 return ret;
231 }
232 }
233
234 return 0;
235 }
236
dxva2_get_buffer(AVHWFramesContext * ctx,AVFrame * frame)237 static int dxva2_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
238 {
239 frame->buf[0] = av_buffer_pool_get(ctx->pool);
240 if (!frame->buf[0])
241 return AVERROR(ENOMEM);
242
243 frame->data[3] = frame->buf[0]->data;
244 frame->format = AV_PIX_FMT_DXVA2_VLD;
245 frame->width = ctx->width;
246 frame->height = ctx->height;
247
248 return 0;
249 }
250
dxva2_transfer_get_formats(AVHWFramesContext * ctx,enum AVHWFrameTransferDirection dir,enum AVPixelFormat ** formats)251 static int dxva2_transfer_get_formats(AVHWFramesContext *ctx,
252 enum AVHWFrameTransferDirection dir,
253 enum AVPixelFormat **formats)
254 {
255 enum AVPixelFormat *fmts;
256
257 fmts = av_malloc_array(2, sizeof(*fmts));
258 if (!fmts)
259 return AVERROR(ENOMEM);
260
261 fmts[0] = ctx->sw_format;
262 fmts[1] = AV_PIX_FMT_NONE;
263
264 *formats = fmts;
265
266 return 0;
267 }
268
dxva2_unmap_frame(AVHWFramesContext * ctx,HWMapDescriptor * hwmap)269 static void dxva2_unmap_frame(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)
270 {
271 IDirect3DSurface9 *surface = (IDirect3DSurface9*)hwmap->source->data[3];
272 IDirect3DSurface9_UnlockRect(surface);
273 av_freep(&hwmap->priv);
274 }
275
dxva2_map_frame(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src,int flags)276 static int dxva2_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,
277 int flags)
278 {
279 IDirect3DSurface9 *surface = (IDirect3DSurface9*)src->data[3];
280 DXVA2Mapping *map;
281 D3DSURFACE_DESC surfaceDesc;
282 D3DLOCKED_RECT LockedRect;
283 HRESULT hr;
284 int i, err, nb_planes;
285 int lock_flags = 0;
286
287 nb_planes = av_pix_fmt_count_planes(dst->format);
288
289 hr = IDirect3DSurface9_GetDesc(surface, &surfaceDesc);
290 if (FAILED(hr)) {
291 av_log(ctx, AV_LOG_ERROR, "Error getting a surface description\n");
292 return AVERROR_UNKNOWN;
293 }
294
295 if (!(flags & AV_HWFRAME_MAP_WRITE))
296 lock_flags |= D3DLOCK_READONLY;
297 if (flags & AV_HWFRAME_MAP_OVERWRITE)
298 lock_flags |= D3DLOCK_DISCARD;
299
300 hr = IDirect3DSurface9_LockRect(surface, &LockedRect, NULL, lock_flags);
301 if (FAILED(hr)) {
302 av_log(ctx, AV_LOG_ERROR, "Unable to lock DXVA2 surface\n");
303 return AVERROR_UNKNOWN;
304 }
305
306 map = av_mallocz(sizeof(*map));
307 if (!map) {
308 err = AVERROR(ENOMEM);
309 goto fail;
310 }
311
312 err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
313 dxva2_unmap_frame, map);
314 if (err < 0) {
315 av_freep(&map);
316 goto fail;
317 }
318
319 for (i = 0; i < nb_planes; i++)
320 dst->linesize[i] = LockedRect.Pitch;
321
322 av_image_fill_pointers(dst->data, dst->format, surfaceDesc.Height,
323 (uint8_t*)LockedRect.pBits, dst->linesize);
324
325 if (dst->format == AV_PIX_FMT_PAL8)
326 dst->data[1] = (uint8_t*)map->palette_dummy;
327
328 return 0;
329 fail:
330 IDirect3DSurface9_UnlockRect(surface);
331 return err;
332 }
333
dxva2_transfer_data_to(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src)334 static int dxva2_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
335 const AVFrame *src)
336 {
337 AVFrame *map;
338 int ret;
339
340 if (src->format != ctx->sw_format)
341 return AVERROR(ENOSYS);
342
343 map = av_frame_alloc();
344 if (!map)
345 return AVERROR(ENOMEM);
346 map->format = dst->format;
347
348 ret = dxva2_map_frame(ctx, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
349 if (ret < 0)
350 goto fail;
351
352 av_image_copy(map->data, map->linesize, (const uint8_t **)src->data, src->linesize,
353 ctx->sw_format, src->width, src->height);
354
355 fail:
356 av_frame_free(&map);
357 return ret;
358 }
359
dxva2_transfer_data_from(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src)360 static int dxva2_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
361 const AVFrame *src)
362 {
363 AVFrame *map;
364 ptrdiff_t src_linesize[4], dst_linesize[4];
365 int ret, i;
366
367 if (dst->format != ctx->sw_format)
368 return AVERROR(ENOSYS);
369
370 map = av_frame_alloc();
371 if (!map)
372 return AVERROR(ENOMEM);
373 map->format = dst->format;
374
375 ret = dxva2_map_frame(ctx, map, src, AV_HWFRAME_MAP_READ);
376 if (ret < 0)
377 goto fail;
378
379 for (i = 0; i < 4; i++) {
380 dst_linesize[i] = dst->linesize[i];
381 src_linesize[i] = map->linesize[i];
382 }
383 av_image_copy_uc_from(dst->data, dst_linesize, (const uint8_t **)map->data, src_linesize,
384 ctx->sw_format, src->width, src->height);
385 fail:
386 av_frame_free(&map);
387 return ret;
388 }
389
dxva2_map_from(AVHWFramesContext * ctx,AVFrame * dst,const AVFrame * src,int flags)390 static int dxva2_map_from(AVHWFramesContext *ctx,
391 AVFrame *dst, const AVFrame *src, int flags)
392 {
393 int err;
394
395 if (dst->format != AV_PIX_FMT_NONE && dst->format != ctx->sw_format)
396 return AVERROR(ENOSYS);
397 dst->format = ctx->sw_format;
398
399 err = dxva2_map_frame(ctx, dst, src, flags);
400 if (err < 0)
401 return err;
402
403 err = av_frame_copy_props(dst, src);
404 if (err < 0)
405 return err;
406
407 return 0;
408 }
409
dxva2_device_free(AVHWDeviceContext * ctx)410 static void dxva2_device_free(AVHWDeviceContext *ctx)
411 {
412 AVDXVA2DeviceContext *hwctx = ctx->hwctx;
413 DXVA2DevicePriv *priv = ctx->user_opaque;
414
415 if (hwctx->devmgr && priv->device_handle != INVALID_HANDLE_VALUE)
416 IDirect3DDeviceManager9_CloseDeviceHandle(hwctx->devmgr, priv->device_handle);
417
418 if (hwctx->devmgr)
419 IDirect3DDeviceManager9_Release(hwctx->devmgr);
420
421 if (priv->d3d9device)
422 IDirect3DDevice9_Release(priv->d3d9device);
423
424 if (priv->d3d9)
425 IDirect3D9_Release(priv->d3d9);
426
427 if (priv->d3dlib)
428 dlclose(priv->d3dlib);
429
430 if (priv->dxva2lib)
431 dlclose(priv->dxva2lib);
432
433 av_freep(&ctx->user_opaque);
434 }
435
dxva2_device_create9(AVHWDeviceContext * ctx,UINT adapter)436 static int dxva2_device_create9(AVHWDeviceContext *ctx, UINT adapter)
437 {
438 DXVA2DevicePriv *priv = ctx->user_opaque;
439 D3DPRESENT_PARAMETERS d3dpp = dxva2_present_params;
440 D3DDISPLAYMODE d3ddm;
441 HRESULT hr;
442 pDirect3DCreate9 *createD3D = (pDirect3DCreate9 *)dlsym(priv->d3dlib, "Direct3DCreate9");
443 if (!createD3D) {
444 av_log(ctx, AV_LOG_ERROR, "Failed to locate Direct3DCreate9\n");
445 return AVERROR_UNKNOWN;
446 }
447
448 priv->d3d9 = createD3D(D3D_SDK_VERSION);
449 if (!priv->d3d9) {
450 av_log(ctx, AV_LOG_ERROR, "Failed to create IDirect3D object\n");
451 return AVERROR_UNKNOWN;
452 }
453
454 IDirect3D9_GetAdapterDisplayMode(priv->d3d9, adapter, &d3ddm);
455
456 d3dpp.BackBufferFormat = d3ddm.Format;
457
458 hr = IDirect3D9_CreateDevice(priv->d3d9, adapter, D3DDEVTYPE_HAL, GetDesktopWindow(),
459 FF_D3DCREATE_FLAGS,
460 &d3dpp, &priv->d3d9device);
461 if (FAILED(hr)) {
462 av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device\n");
463 return AVERROR_UNKNOWN;
464 }
465
466 return 0;
467 }
468
dxva2_device_create9ex(AVHWDeviceContext * ctx,UINT adapter)469 static int dxva2_device_create9ex(AVHWDeviceContext *ctx, UINT adapter)
470 {
471 DXVA2DevicePriv *priv = ctx->user_opaque;
472 D3DPRESENT_PARAMETERS d3dpp = dxva2_present_params;
473 D3DDISPLAYMODEEX modeex = {0};
474 IDirect3D9Ex *d3d9ex = NULL;
475 IDirect3DDevice9Ex *exdev = NULL;
476 HRESULT hr;
477 pDirect3DCreate9Ex *createD3DEx = (pDirect3DCreate9Ex *)dlsym(priv->d3dlib, "Direct3DCreate9Ex");
478 if (!createD3DEx)
479 return AVERROR(ENOSYS);
480
481 hr = createD3DEx(D3D_SDK_VERSION, &d3d9ex);
482 if (FAILED(hr))
483 return AVERROR_UNKNOWN;
484
485 modeex.Size = sizeof(D3DDISPLAYMODEEX);
486 hr = IDirect3D9Ex_GetAdapterDisplayModeEx(d3d9ex, adapter, &modeex, NULL);
487 if (FAILED(hr)) {
488 IDirect3D9Ex_Release(d3d9ex);
489 return AVERROR_UNKNOWN;
490 }
491
492 d3dpp.BackBufferFormat = modeex.Format;
493
494 hr = IDirect3D9Ex_CreateDeviceEx(d3d9ex, adapter, D3DDEVTYPE_HAL, GetDesktopWindow(),
495 FF_D3DCREATE_FLAGS,
496 &d3dpp, NULL, &exdev);
497 if (FAILED(hr)) {
498 IDirect3D9Ex_Release(d3d9ex);
499 return AVERROR_UNKNOWN;
500 }
501
502 av_log(ctx, AV_LOG_VERBOSE, "Using D3D9Ex device.\n");
503 priv->d3d9 = (IDirect3D9 *)d3d9ex;
504 priv->d3d9device = (IDirect3DDevice9 *)exdev;
505 return 0;
506 }
507
dxva2_device_create(AVHWDeviceContext * ctx,const char * device,AVDictionary * opts,int flags)508 static int dxva2_device_create(AVHWDeviceContext *ctx, const char *device,
509 AVDictionary *opts, int flags)
510 {
511 AVDXVA2DeviceContext *hwctx = ctx->hwctx;
512 DXVA2DevicePriv *priv;
513 pCreateDeviceManager9 *createDeviceManager = NULL;
514 unsigned resetToken = 0;
515 UINT adapter = D3DADAPTER_DEFAULT;
516 HRESULT hr;
517 int err;
518
519 if (device)
520 adapter = atoi(device);
521
522 priv = av_mallocz(sizeof(*priv));
523 if (!priv)
524 return AVERROR(ENOMEM);
525
526 ctx->user_opaque = priv;
527 ctx->free = dxva2_device_free;
528
529 priv->device_handle = INVALID_HANDLE_VALUE;
530
531 priv->d3dlib = dlopen("d3d9.dll", 0);
532 if (!priv->d3dlib) {
533 av_log(ctx, AV_LOG_ERROR, "Failed to load D3D9 library\n");
534 return AVERROR_UNKNOWN;
535 }
536 priv->dxva2lib = dlopen("dxva2.dll", 0);
537 if (!priv->dxva2lib) {
538 av_log(ctx, AV_LOG_ERROR, "Failed to load DXVA2 library\n");
539 return AVERROR_UNKNOWN;
540 }
541
542 createDeviceManager = (pCreateDeviceManager9 *)dlsym(priv->dxva2lib,
543 "DXVA2CreateDirect3DDeviceManager9");
544 if (!createDeviceManager) {
545 av_log(ctx, AV_LOG_ERROR, "Failed to locate DXVA2CreateDirect3DDeviceManager9\n");
546 return AVERROR_UNKNOWN;
547 }
548
549 if (dxva2_device_create9ex(ctx, adapter) < 0) {
550 // Retry with "classic" d3d9
551 err = dxva2_device_create9(ctx, adapter);
552 if (err < 0)
553 return err;
554 }
555
556 hr = createDeviceManager(&resetToken, &hwctx->devmgr);
557 if (FAILED(hr)) {
558 av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device manager\n");
559 return AVERROR_UNKNOWN;
560 }
561
562 hr = IDirect3DDeviceManager9_ResetDevice(hwctx->devmgr, priv->d3d9device, resetToken);
563 if (FAILED(hr)) {
564 av_log(ctx, AV_LOG_ERROR, "Failed to bind Direct3D device to device manager\n");
565 return AVERROR_UNKNOWN;
566 }
567
568 hr = IDirect3DDeviceManager9_OpenDeviceHandle(hwctx->devmgr, &priv->device_handle);
569 if (FAILED(hr)) {
570 av_log(ctx, AV_LOG_ERROR, "Failed to open device handle\n");
571 return AVERROR_UNKNOWN;
572 }
573
574 return 0;
575 }
576
577 const HWContextType ff_hwcontext_type_dxva2 = {
578 .type = AV_HWDEVICE_TYPE_DXVA2,
579 .name = "DXVA2",
580
581 .device_hwctx_size = sizeof(AVDXVA2DeviceContext),
582 .frames_hwctx_size = sizeof(AVDXVA2FramesContext),
583 .frames_priv_size = sizeof(DXVA2FramesContext),
584
585 .device_create = dxva2_device_create,
586 .frames_init = dxva2_frames_init,
587 .frames_uninit = dxva2_frames_uninit,
588 .frames_get_buffer = dxva2_get_buffer,
589 .transfer_get_formats = dxva2_transfer_get_formats,
590 .transfer_data_to = dxva2_transfer_data_to,
591 .transfer_data_from = dxva2_transfer_data_from,
592 .map_from = dxva2_map_from,
593
594 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_DXVA2_VLD, AV_PIX_FMT_NONE },
595 };
596