FFmpeg coverage

Line	Branch	Exec	Source
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 "config.h"
20
21			#if HAVE_VAAPI_WIN32
22			# include <windows.h>
23			#define COBJMACROS
24			# include <initguid.h>
25			# include <dxgi1_2.h>
26			# include "compat/w32dlfcn.h"
27			# include <va/va_win32.h>
28			typedef HRESULT (WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
29			#endif
30			#if HAVE_VAAPI_X11
31			# include <va/va_x11.h>
32			#endif
33			#if HAVE_VAAPI_DRM
34			# include <va/va_drm.h>
35			#endif
36
37			#if CONFIG_LIBDRM
38			# include <va/va_drmcommon.h>
39			# include <xf86drm.h>
40			# include <drm_fourcc.h>
41			# ifndef DRM_FORMAT_MOD_INVALID
42			# define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1)
43			# endif
44			#endif
45
46			#include <fcntl.h>
47			#if HAVE_UNISTD_H
48			# include <unistd.h>
49			#endif
50
51
52			#include "avassert.h"
53			#include "buffer.h"
54			#include "common.h"
55			#include "hwcontext.h"
56			#include "hwcontext_drm.h"
57			#include "hwcontext_internal.h"
58			#include "hwcontext_vaapi.h"
59			#include "mem.h"
60			#include "pixdesc.h"
61			#include "pixfmt.h"
62
63
64			typedef struct VAAPIDevicePriv {
65			#if HAVE_VAAPI_X11
66			Display *x11_display;
67			#endif
68
69			int drm_fd;
70			} VAAPIDevicePriv;
71
72			typedef struct VAAPISurfaceFormat {
73			enum AVPixelFormat pix_fmt;
74			VAImageFormat image_format;
75			} VAAPISurfaceFormat;
76
77			typedef struct VAAPIDeviceContext {
78			/**
79			* The public AVVAAPIDeviceContext. See hwcontext_vaapi.h for it.
80			*/
81			AVVAAPIDeviceContext p;
82
83			// Surface formats which can be used with this device.
84			VAAPISurfaceFormat *formats;
85			int nb_formats;
86			} VAAPIDeviceContext;
87
88			typedef struct VAAPIFramesContext {
89			/**
90			* The public AVVAAPIFramesContext. See hwcontext_vaapi.h for it.
91			*/
92			AVVAAPIFramesContext p;
93
94			// Surface attributes set at create time.
95			VASurfaceAttrib *attributes;
96			int nb_attributes;
97			// RT format of the underlying surface (Intel driver ignores this anyway).
98			unsigned int rt_format;
99			// Whether vaDeriveImage works.
100			int derive_works;
101			// Caches whether VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2 is unsupported for
102			// surface imports.
103			int prime_2_import_unsupported;
104			} VAAPIFramesContext;
105
106			typedef struct VAAPIMapping {
107			// Handle to the derived or copied image which is mapped.
108			VAImage image;
109			// The mapping flags actually used.
110			int flags;
111			} VAAPIMapping;
112
113			typedef struct VAAPIFormat {
114			unsigned int fourcc;
115			unsigned int rt_format;
116			enum AVPixelFormat pix_fmt;
117			int chroma_planes_swapped;
118			} VAAPIFormatDescriptor;
119
120			#define MAP(va, rt, av, swap_uv) { \
121			VA_FOURCC_ ## va, \
122			VA_RT_FORMAT_ ## rt, \
123			AV_PIX_FMT_ ## av, \
124			swap_uv, \
125			}
126			// The map fourcc <-> pix_fmt isn't bijective because of the annoying U/V
127			// plane swap cases. The frame handling below tries to hide these.
128			static const VAAPIFormatDescriptor vaapi_format_map[] = {
129			MAP(NV12, YUV420, NV12, 0),
130			#ifdef VA_FOURCC_I420
131			MAP(I420, YUV420, YUV420P, 0),
132			#endif
133			MAP(YV12, YUV420, YUV420P, 1),
134			MAP(IYUV, YUV420, YUV420P, 0),
135			MAP(422H, YUV422, YUV422P, 0),
136			#ifdef VA_FOURCC_YV16
137			MAP(YV16, YUV422, YUV422P, 1),
138			#endif
139			MAP(UYVY, YUV422, UYVY422, 0),
140			MAP(YUY2, YUV422, YUYV422, 0),
141			#ifdef VA_FOURCC_Y210
142			MAP(Y210, YUV422_10, Y210, 0),
143			#endif
144			#ifdef VA_FOURCC_Y212
145			MAP(Y212, YUV422_12, Y212, 0),
146			#endif
147			MAP(411P, YUV411, YUV411P, 0),
148			MAP(422V, YUV422, YUV440P, 0),
149			MAP(444P, YUV444, YUV444P, 0),
150			#ifdef VA_FOURCC_XYUV
151			MAP(XYUV, YUV444, VUYX, 0),
152			#endif
153			MAP(Y800, YUV400, GRAY8, 0),
154			#ifdef VA_FOURCC_P010
155			MAP(P010, YUV420_10BPP, P010, 0),
156			#endif
157			#ifdef VA_FOURCC_P012
158			MAP(P012, YUV420_12, P012, 0),
159			#endif
160			MAP(BGRA, RGB32, BGRA, 0),
161			MAP(BGRX, RGB32, BGR0, 0),
162			MAP(RGBA, RGB32, RGBA, 0),
163			MAP(RGBX, RGB32, RGB0, 0),
164			#ifdef VA_FOURCC_ABGR
165			MAP(ABGR, RGB32, ABGR, 0),
166			MAP(XBGR, RGB32, 0BGR, 0),
167			#endif
168			MAP(ARGB, RGB32, ARGB, 0),
169			MAP(XRGB, RGB32, 0RGB, 0),
170			#ifdef VA_FOURCC_X2R10G10B10
171			MAP(X2R10G10B10, RGB32_10, X2RGB10, 0),
172			#endif
173			#ifdef VA_FOURCC_Y410
174			// libva doesn't include a fourcc for XV30 and the driver only declares
175			// support for Y410, so we must fudge the mapping here.
176			MAP(Y410, YUV444_10, XV30, 0),
177			#endif
178			#ifdef VA_FOURCC_Y412
179			// libva doesn't include a fourcc for XV36 and the driver only declares
180			// support for Y412, so we must fudge the mapping here.
181			MAP(Y412, YUV444_12, XV36, 0),
182			#endif
183			};
184			#undef MAP
185
186			static const VAAPIFormatDescriptor *
187		✗	vaapi_format_from_fourcc(unsigned int fourcc)
188			{
189			int i;
190		✗	for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++)
191		✗	if (vaapi_format_map[i].fourcc == fourcc)
192		✗	return &vaapi_format_map[i];
193		✗	return NULL;
194			}
195
196			static const VAAPIFormatDescriptor *
197		✗	vaapi_format_from_pix_fmt(enum AVPixelFormat pix_fmt)
198			{
199			int i;
200		✗	for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++)
201		✗	if (vaapi_format_map[i].pix_fmt == pix_fmt)
202		✗	return &vaapi_format_map[i];
203		✗	return NULL;
204			}
205
206		✗	static enum AVPixelFormat vaapi_pix_fmt_from_fourcc(unsigned int fourcc)
207			{
208			const VAAPIFormatDescriptor *desc;
209		✗	desc = vaapi_format_from_fourcc(fourcc);
210		✗	if (desc)
211		✗	return desc->pix_fmt;
212			else
213		✗	return AV_PIX_FMT_NONE;
214			}
215
216		✗	static int vaapi_get_image_format(AVHWDeviceContext *hwdev,
217			enum AVPixelFormat pix_fmt,
218			VAImageFormat **image_format)
219			{
220		✗	VAAPIDeviceContext *ctx = hwdev->hwctx;
221			int i;
222
223		✗	for (i = 0; i < ctx->nb_formats; i++) {
224		✗	if (ctx->formats[i].pix_fmt == pix_fmt) {
225		✗	if (image_format)
226		✗	*image_format = &ctx->formats[i].image_format;
227		✗	return 0;
228			}
229			}
230		✗	return AVERROR(ENOSYS);
231			}
232
233		✗	static int vaapi_frames_get_constraints(AVHWDeviceContext *hwdev,
234			const void *hwconfig,
235			AVHWFramesConstraints *constraints)
236			{
237		✗	VAAPIDeviceContext *ctx = hwdev->hwctx;
238		✗	AVVAAPIDeviceContext *hwctx = &ctx->p;
239		✗	const AVVAAPIHWConfig *config = hwconfig;
240		✗	VASurfaceAttrib *attr_list = NULL;
241			VAStatus vas;
242			enum AVPixelFormat pix_fmt;
243			unsigned int fourcc;
244			int err, i, j, attr_count, pix_fmt_count;
245
246		✗	if (config &&
247		✗	!(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {
248		✗	attr_count = 0;
249		✗	vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
250			0, &attr_count);
251		✗	if (vas != VA_STATUS_SUCCESS) {
252		✗	av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
253			"%d (%s).\n", vas, vaErrorStr(vas));
254		✗	err = AVERROR(ENOSYS);
255		✗	goto fail;
256			}
257
258		✗	attr_list = av_malloc(attr_count * sizeof(*attr_list));
259		✗	if (!attr_list) {
260		✗	err = AVERROR(ENOMEM);
261		✗	goto fail;
262			}
263
264		✗	vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
265			attr_list, &attr_count);
266		✗	if (vas != VA_STATUS_SUCCESS) {
267		✗	av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
268			"%d (%s).\n", vas, vaErrorStr(vas));
269		✗	err = AVERROR(ENOSYS);
270		✗	goto fail;
271			}
272
273		✗	pix_fmt_count = 0;
274		✗	for (i = 0; i < attr_count; i++) {
275		✗	switch (attr_list[i].type) {
276		✗	case VASurfaceAttribPixelFormat:
277		✗	fourcc = attr_list[i].value.value.i;
278		✗	pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
279		✗	if (pix_fmt != AV_PIX_FMT_NONE) {
280		✗	++pix_fmt_count;
281			} else {
282			// Something unsupported - ignore.
283			}
284		✗	break;
285		✗	case VASurfaceAttribMinWidth:
286		✗	constraints->min_width = attr_list[i].value.value.i;
287		✗	break;
288		✗	case VASurfaceAttribMinHeight:
289		✗	constraints->min_height = attr_list[i].value.value.i;
290		✗	break;
291		✗	case VASurfaceAttribMaxWidth:
292		✗	constraints->max_width = attr_list[i].value.value.i;
293		✗	break;
294		✗	case VASurfaceAttribMaxHeight:
295		✗	constraints->max_height = attr_list[i].value.value.i;
296		✗	break;
297			}
298			}
299		✗	if (pix_fmt_count == 0) {
300			// Nothing usable found. Presumably there exists something which
301			// works, so leave the set null to indicate unknown.
302		✗	constraints->valid_sw_formats = NULL;
303			} else {
304		✗	constraints->valid_sw_formats = av_malloc_array(pix_fmt_count + 1,
305			sizeof(pix_fmt));
306		✗	if (!constraints->valid_sw_formats) {
307		✗	err = AVERROR(ENOMEM);
308		✗	goto fail;
309			}
310
311		✗	for (i = j = 0; i < attr_count; i++) {
312			int k;
313
314		✗	if (attr_list[i].type != VASurfaceAttribPixelFormat)
315		✗	continue;
316		✗	fourcc = attr_list[i].value.value.i;
317		✗	pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
318
319		✗	if (pix_fmt == AV_PIX_FMT_NONE)
320		✗	continue;
321
322		✗	for (k = 0; k < j; k++) {
323		✗	if (constraints->valid_sw_formats[k] == pix_fmt)
324		✗	break;
325			}
326
327		✗	if (k == j)
328		✗	constraints->valid_sw_formats[j++] = pix_fmt;
329			}
330		✗	constraints->valid_sw_formats[j] = AV_PIX_FMT_NONE;
331			}
332			} else {
333			// No configuration supplied.
334			// Return the full set of image formats known by the implementation.
335		✗	constraints->valid_sw_formats = av_malloc_array(ctx->nb_formats + 1,
336			sizeof(pix_fmt));
337		✗	if (!constraints->valid_sw_formats) {
338		✗	err = AVERROR(ENOMEM);
339		✗	goto fail;
340			}
341		✗	for (i = j = 0; i < ctx->nb_formats; i++) {
342			int k;
343
344		✗	for (k = 0; k < j; k++) {
345		✗	if (constraints->valid_sw_formats[k] == ctx->formats[i].pix_fmt)
346		✗	break;
347			}
348
349		✗	if (k == j)
350		✗	constraints->valid_sw_formats[j++] = ctx->formats[i].pix_fmt;
351			}
352
353		✗	constraints->valid_sw_formats[j] = AV_PIX_FMT_NONE;
354			}
355
356		✗	constraints->valid_hw_formats = av_malloc_array(2, sizeof(pix_fmt));
357		✗	if (!constraints->valid_hw_formats) {
358		✗	err = AVERROR(ENOMEM);
359		✗	goto fail;
360			}
361		✗	constraints->valid_hw_formats[0] = AV_PIX_FMT_VAAPI;
362		✗	constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
363
364		✗	err = 0;
365		✗	fail:
366		✗	av_freep(&attr_list);
367		✗	return err;
368			}
369
370			static const struct {
371			const char *friendly_name;
372			const char *match_string;
373			unsigned int quirks;
374			} vaapi_driver_quirks_table[] = {
375			#if !VA_CHECK_VERSION(1, 0, 0)
376			// The i965 driver did not conform before version 2.0.
377			{
378			"Intel i965 (Quick Sync)",
379			"i965",
380			AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS,
381			},
382			#endif
383			{
384			"Intel iHD",
385			"ubit",
386			AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE,
387			},
388			{
389			"VDPAU wrapper",
390			"Splitted-Desktop Systems VDPAU backend for VA-API",
391			AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES,
392			},
393			};
394
395		✗	static int vaapi_device_init(AVHWDeviceContext *hwdev)
396			{
397		✗	VAAPIDeviceContext *ctx = hwdev->hwctx;
398		✗	AVVAAPIDeviceContext *hwctx = &ctx->p;
399		✗	VAImageFormat *image_list = NULL;
400			VAStatus vas;
401			const char *vendor_string;
402			int err, i, image_count;
403			enum AVPixelFormat pix_fmt;
404			unsigned int fourcc;
405
406		✗	image_count = vaMaxNumImageFormats(hwctx->display);
407		✗	if (image_count <= 0) {
408		✗	err = AVERROR(EIO);
409		✗	goto fail;
410			}
411		✗	image_list = av_malloc(image_count * sizeof(*image_list));
412		✗	if (!image_list) {
413		✗	err = AVERROR(ENOMEM);
414		✗	goto fail;
415			}
416		✗	vas = vaQueryImageFormats(hwctx->display, image_list, &image_count);
417		✗	if (vas != VA_STATUS_SUCCESS) {
418		✗	err = AVERROR(EIO);
419		✗	goto fail;
420			}
421
422		✗	ctx->formats = av_malloc(image_count * sizeof(*ctx->formats));
423		✗	if (!ctx->formats) {
424		✗	err = AVERROR(ENOMEM);
425		✗	goto fail;
426			}
427		✗	ctx->nb_formats = 0;
428		✗	for (i = 0; i < image_count; i++) {
429		✗	fourcc = image_list[i].fourcc;
430		✗	pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
431		✗	if (pix_fmt == AV_PIX_FMT_NONE) {
432		✗	av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> unknown.\n",
433			fourcc);
434			} else {
435		✗	av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> %s.\n",
436			fourcc, av_get_pix_fmt_name(pix_fmt));
437		✗	ctx->formats[ctx->nb_formats].pix_fmt = pix_fmt;
438		✗	ctx->formats[ctx->nb_formats].image_format = image_list[i];
439		✗	++ctx->nb_formats;
440			}
441			}
442
443		✗	vendor_string = vaQueryVendorString(hwctx->display);
444		✗	if (vendor_string)
445		✗	av_log(hwdev, AV_LOG_VERBOSE, "VAAPI driver: %s.\n", vendor_string);
446
447		✗	if (hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_USER_SET) {
448		✗	av_log(hwdev, AV_LOG_VERBOSE, "Using quirks set by user (%#x).\n",
449			hwctx->driver_quirks);
450			} else {
451			// Detect the driver in use and set quirk flags if necessary.
452		✗	hwctx->driver_quirks = 0;
453		✗	if (vendor_string) {
454		✗	for (i = 0; i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table); i++) {
455		✗	if (strstr(vendor_string,
456		✗	vaapi_driver_quirks_table[i].match_string)) {
457		✗	av_log(hwdev, AV_LOG_VERBOSE, "Matched driver string "
458			"as known nonstandard driver \"%s\", setting "
459			"quirks (%#x).\n",
460		✗	vaapi_driver_quirks_table[i].friendly_name,
461		✗	vaapi_driver_quirks_table[i].quirks);
462		✗	hwctx->driver_quirks |=
463		✗	vaapi_driver_quirks_table[i].quirks;
464		✗	break;
465			}
466			}
467		✗	if (!(i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table))) {
468		✗	av_log(hwdev, AV_LOG_VERBOSE, "Driver not found in known "
469			"nonstandard list, using standard behaviour.\n");
470			}
471			} else {
472		✗	av_log(hwdev, AV_LOG_VERBOSE, "Driver has no vendor string, "
473			"assuming standard behaviour.\n");
474			}
475			}
476
477		✗	av_free(image_list);
478		✗	return 0;
479		✗	fail:
480		✗	av_freep(&ctx->formats);
481		✗	av_free(image_list);
482		✗	return err;
483			}
484
485		✗	static void vaapi_device_uninit(AVHWDeviceContext *hwdev)
486			{
487		✗	VAAPIDeviceContext *ctx = hwdev->hwctx;
488
489		✗	av_freep(&ctx->formats);
490		✗	}
491
492		✗	static void vaapi_buffer_free(void *opaque, uint8_t *data)
493			{
494		✗	AVHWFramesContext *hwfc = opaque;
495		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
496			VASurfaceID surface_id;
497			VAStatus vas;
498
499		✗	surface_id = (VASurfaceID)(uintptr_t)data;
500
501		✗	vas = vaDestroySurfaces(hwctx->display, &surface_id, 1);
502		✗	if (vas != VA_STATUS_SUCCESS) {
503		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to destroy surface %#x: "
504			"%d (%s).\n", surface_id, vas, vaErrorStr(vas));
505			}
506		✗	}
507
508		✗	static AVBufferRef *vaapi_pool_alloc(void *opaque, size_t size)
509			{
510		✗	AVHWFramesContext *hwfc = opaque;
511		✗	VAAPIFramesContext *ctx = hwfc->hwctx;
512		✗	AVVAAPIFramesContext *avfc = &ctx->p;
513		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
514			VASurfaceID surface_id;
515			VAStatus vas;
516			AVBufferRef *ref;
517
518		✗	if (hwfc->initial_pool_size > 0 &&
519		✗	avfc->nb_surfaces >= hwfc->initial_pool_size)
520		✗	return NULL;
521
522		✗	vas = vaCreateSurfaces(hwctx->display, ctx->rt_format,
523		✗	hwfc->width, hwfc->height,
524			&surface_id, 1,
525		✗	ctx->attributes, ctx->nb_attributes);
526		✗	if (vas != VA_STATUS_SUCCESS) {
527		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to create surface: "
528			"%d (%s).\n", vas, vaErrorStr(vas));
529		✗	return NULL;
530			}
531		✗	av_log(hwfc, AV_LOG_DEBUG, "Created surface %#x.\n", surface_id);
532
533		✗	ref = av_buffer_create((uint8_t*)(uintptr_t)surface_id,
534			sizeof(surface_id), &vaapi_buffer_free,
535			hwfc, AV_BUFFER_FLAG_READONLY);
536		✗	if (!ref) {
537		✗	vaDestroySurfaces(hwctx->display, &surface_id, 1);
538		✗	return NULL;
539			}
540
541		✗	if (hwfc->initial_pool_size > 0) {
542			// This is a fixed-size pool, so we must still be in the initial
543			// allocation sequence.
544		✗	av_assert0(avfc->nb_surfaces < hwfc->initial_pool_size);
545		✗	avfc->surface_ids[avfc->nb_surfaces] = surface_id;
546		✗	++avfc->nb_surfaces;
547			}
548
549		✗	return ref;
550			}
551
552		✗	static int vaapi_frames_init(AVHWFramesContext *hwfc)
553			{
554		✗	VAAPIFramesContext *ctx = hwfc->hwctx;
555		✗	AVVAAPIFramesContext *avfc = &ctx->p;
556		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
557			const VAAPIFormatDescriptor *desc;
558			VAImageFormat *expected_format;
559		✗	AVBufferRef *test_surface = NULL;
560			VASurfaceID test_surface_id;
561			VAImage test_image;
562			VAStatus vas;
563			int err, i;
564
565		✗	desc = vaapi_format_from_pix_fmt(hwfc->sw_format);
566		✗	if (!desc) {
567		✗	av_log(hwfc, AV_LOG_ERROR, "Unsupported format: %s.\n",
568			av_get_pix_fmt_name(hwfc->sw_format));
569		✗	return AVERROR(EINVAL);
570			}
571
572		✗	if (!hwfc->pool) {
573		✗	if (!(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {
574		✗	int need_memory_type = !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE);
575		✗	int need_pixel_format = 1;
576		✗	for (i = 0; i < avfc->nb_attributes; i++) {
577		✗	if (avfc->attributes[i].type == VASurfaceAttribMemoryType)
578		✗	need_memory_type = 0;
579		✗	if (avfc->attributes[i].type == VASurfaceAttribPixelFormat)
580		✗	need_pixel_format = 0;
581			}
582		✗	ctx->nb_attributes =
583		✗	avfc->nb_attributes + need_memory_type + need_pixel_format;
584
585		✗	ctx->attributes = av_malloc(ctx->nb_attributes *
586			sizeof(*ctx->attributes));
587		✗	if (!ctx->attributes) {
588		✗	err = AVERROR(ENOMEM);
589		✗	goto fail;
590			}
591
592		✗	for (i = 0; i < avfc->nb_attributes; i++)
593		✗	ctx->attributes[i] = avfc->attributes[i];
594		✗	if (need_memory_type) {
595		✗	ctx->attributes[i++] = (VASurfaceAttrib) {
596			.type = VASurfaceAttribMemoryType,
597			.flags = VA_SURFACE_ATTRIB_SETTABLE,
598			.value.type = VAGenericValueTypeInteger,
599			.value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA,
600			};
601			}
602		✗	if (need_pixel_format) {
603		✗	ctx->attributes[i++] = (VASurfaceAttrib) {
604			.type = VASurfaceAttribPixelFormat,
605			.flags = VA_SURFACE_ATTRIB_SETTABLE,
606			.value.type = VAGenericValueTypeInteger,
607		✗	.value.value.i = desc->fourcc,
608			};
609			}
610		✗	av_assert0(i == ctx->nb_attributes);
611			} else {
612		✗	ctx->attributes = NULL;
613		✗	ctx->nb_attributes = 0;
614			}
615
616		✗	ctx->rt_format = desc->rt_format;
617
618		✗	if (hwfc->initial_pool_size > 0) {
619			// This pool will be usable as a render target, so we need to store
620			// all of the surface IDs somewhere that vaCreateContext() calls
621			// will be able to access them.
622		✗	avfc->nb_surfaces = 0;
623		✗	avfc->surface_ids = av_malloc(hwfc->initial_pool_size *
624			sizeof(*avfc->surface_ids));
625		✗	if (!avfc->surface_ids) {
626		✗	err = AVERROR(ENOMEM);
627		✗	goto fail;
628			}
629			} else {
630			// This pool allows dynamic sizing, and will not be usable as a
631			// render target.
632		✗	avfc->nb_surfaces = 0;
633		✗	avfc->surface_ids = NULL;
634			}
635
636		✗	ffhwframesctx(hwfc)->pool_internal =
637		✗	av_buffer_pool_init2(sizeof(VASurfaceID), hwfc,
638			&vaapi_pool_alloc, NULL);
639		✗	if (!ffhwframesctx(hwfc)->pool_internal) {
640		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to create VAAPI surface pool.\n");
641		✗	err = AVERROR(ENOMEM);
642		✗	goto fail;
643			}
644			}
645
646			// Allocate a single surface to test whether vaDeriveImage() is going
647			// to work for the specific configuration.
648		✗	if (hwfc->pool) {
649		✗	test_surface = av_buffer_pool_get(hwfc->pool);
650		✗	if (!test_surface) {
651		✗	av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
652			"user-configured buffer pool.\n");
653		✗	err = AVERROR(ENOMEM);
654		✗	goto fail;
655			}
656			} else {
657		✗	test_surface = av_buffer_pool_get(ffhwframesctx(hwfc)->pool_internal);
658		✗	if (!test_surface) {
659		✗	av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
660			"internal buffer pool.\n");
661		✗	err = AVERROR(ENOMEM);
662		✗	goto fail;
663			}
664			}
665		✗	test_surface_id = (VASurfaceID)(uintptr_t)test_surface->data;
666
667		✗	ctx->derive_works = 0;
668
669		✗	err = vaapi_get_image_format(hwfc->device_ctx,
670			hwfc->sw_format, &expected_format);
671		✗	if (err == 0) {
672		✗	vas = vaDeriveImage(hwctx->display, test_surface_id, &test_image);
673		✗	if (vas == VA_STATUS_SUCCESS) {
674		✗	if (expected_format->fourcc == test_image.format.fourcc) {
675		✗	av_log(hwfc, AV_LOG_DEBUG, "Direct mapping possible.\n");
676		✗	ctx->derive_works = 1;
677			} else {
678		✗	av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
679			"derived image format %08x does not match "
680			"expected format %08x.\n",
681		✗	expected_format->fourcc, test_image.format.fourcc);
682			}
683		✗	vaDestroyImage(hwctx->display, test_image.image_id);
684			} else {
685		✗	av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
686			"deriving image does not work: "
687			"%d (%s).\n", vas, vaErrorStr(vas));
688			}
689			} else {
690		✗	av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
691			"image format is not supported.\n");
692			}
693
694		✗	av_buffer_unref(&test_surface);
695		✗	return 0;
696
697		✗	fail:
698		✗	av_buffer_unref(&test_surface);
699		✗	av_freep(&avfc->surface_ids);
700		✗	av_freep(&ctx->attributes);
701		✗	return err;
702			}
703
704		✗	static void vaapi_frames_uninit(AVHWFramesContext *hwfc)
705			{
706		✗	VAAPIFramesContext *ctx = hwfc->hwctx;
707		✗	AVVAAPIFramesContext *avfc = &ctx->p;
708
709		✗	av_freep(&avfc->surface_ids);
710		✗	av_freep(&ctx->attributes);
711		✗	}
712
713		✗	static int vaapi_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame)
714			{
715		✗	frame->buf[0] = av_buffer_pool_get(hwfc->pool);
716		✗	if (!frame->buf[0])
717		✗	return AVERROR(ENOMEM);
718
719		✗	frame->data[3] = frame->buf[0]->data;
720		✗	frame->format = AV_PIX_FMT_VAAPI;
721		✗	frame->width = hwfc->width;
722		✗	frame->height = hwfc->height;
723
724		✗	return 0;
725			}
726
727		✗	static int vaapi_transfer_get_formats(AVHWFramesContext *hwfc,
728			enum AVHWFrameTransferDirection dir,
729			enum AVPixelFormat **formats)
730			{
731		✗	VAAPIDeviceContext *ctx = hwfc->device_ctx->hwctx;
732			enum AVPixelFormat *pix_fmts;
733			int i, k, sw_format_available;
734
735		✗	sw_format_available = 0;
736		✗	for (i = 0; i < ctx->nb_formats; i++) {
737		✗	if (ctx->formats[i].pix_fmt == hwfc->sw_format)
738		✗	sw_format_available = 1;
739			}
740
741		✗	pix_fmts = av_malloc((ctx->nb_formats + 1) * sizeof(*pix_fmts));
742		✗	if (!pix_fmts)
743		✗	return AVERROR(ENOMEM);
744
745		✗	if (sw_format_available) {
746		✗	pix_fmts[0] = hwfc->sw_format;
747		✗	k = 1;
748			} else {
749		✗	k = 0;
750			}
751		✗	for (i = 0; i < ctx->nb_formats; i++) {
752		✗	if (ctx->formats[i].pix_fmt == hwfc->sw_format)
753		✗	continue;
754		✗	av_assert0(k < ctx->nb_formats);
755		✗	pix_fmts[k++] = ctx->formats[i].pix_fmt;
756			}
757		✗	pix_fmts[k] = AV_PIX_FMT_NONE;
758
759		✗	*formats = pix_fmts;
760		✗	return 0;
761			}
762
763		✗	static void vaapi_unmap_frame(AVHWFramesContext *hwfc,
764			HWMapDescriptor *hwmap)
765			{
766		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
767		✗	VAAPIMapping *map = hwmap->priv;
768			VASurfaceID surface_id;
769			VAStatus vas;
770
771		✗	surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];
772		✗	av_log(hwfc, AV_LOG_DEBUG, "Unmap surface %#x.\n", surface_id);
773
774		✗	vas = vaUnmapBuffer(hwctx->display, map->image.buf);
775		✗	if (vas != VA_STATUS_SUCCESS) {
776		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to unmap image from surface "
777			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
778			}
779
780		✗	if ((map->flags & AV_HWFRAME_MAP_WRITE) &&
781		✗	!(map->flags & AV_HWFRAME_MAP_DIRECT)) {
782		✗	vas = vaPutImage(hwctx->display, surface_id, map->image.image_id,
783		✗	0, 0, hwfc->width, hwfc->height,
784		✗	0, 0, hwfc->width, hwfc->height);
785		✗	if (vas != VA_STATUS_SUCCESS) {
786		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to write image to surface "
787			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
788			}
789			}
790
791		✗	vas = vaDestroyImage(hwctx->display, map->image.image_id);
792		✗	if (vas != VA_STATUS_SUCCESS) {
793		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to destroy image from surface "
794			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
795			}
796
797		✗	av_free(map);
798		✗	}
799
800		✗	static int vaapi_map_frame(AVHWFramesContext *hwfc,
801			AVFrame *dst, const AVFrame *src, int flags)
802			{
803		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
804		✗	VAAPIFramesContext *ctx = hwfc->hwctx;
805			VASurfaceID surface_id;
806			const VAAPIFormatDescriptor *desc;
807			VAImageFormat *image_format;
808			VAAPIMapping *map;
809			VAStatus vas;
810		✗	void *address = NULL;
811			int err, i;
812			#if VA_CHECK_VERSION(1, 21, 0)
813		✗	uint32_t vaflags = 0;
814			#endif
815
816		✗	surface_id = (VASurfaceID)(uintptr_t)src->data[3];
817		✗	av_log(hwfc, AV_LOG_DEBUG, "Map surface %#x.\n", surface_id);
818
819		✗	if (!ctx->derive_works && (flags & AV_HWFRAME_MAP_DIRECT)) {
820			// Requested direct mapping but it is not possible.
821		✗	return AVERROR(EINVAL);
822			}
823		✗	if (dst->format == AV_PIX_FMT_NONE)
824		✗	dst->format = hwfc->sw_format;
825		✗	if (dst->format != hwfc->sw_format && (flags & AV_HWFRAME_MAP_DIRECT)) {
826			// Requested direct mapping but the formats do not match.
827		✗	return AVERROR(EINVAL);
828			}
829
830		✗	err = vaapi_get_image_format(hwfc->device_ctx, dst->format, &image_format);
831		✗	if (err < 0) {
832			// Requested format is not a valid output format.
833		✗	return err;
834			}
835
836		✗	map = av_malloc(sizeof(*map));
837		✗	if (!map)
838		✗	return AVERROR(ENOMEM);
839		✗	map->flags = flags;
840		✗	map->image.image_id = VA_INVALID_ID;
841
842		✗	vas = vaSyncSurface(hwctx->display, surface_id);
843		✗	if (vas != VA_STATUS_SUCCESS) {
844		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to sync surface "
845			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
846		✗	err = AVERROR(EIO);
847		✗	goto fail;
848			}
849
850			// The memory which we map using derive need not be connected to the CPU
851			// in a way conducive to fast access. On Gen7-Gen9 Intel graphics, the
852			// memory is mappable but not cached, so normal memcpy()-like access is
853			// very slow to read it (but writing is ok). It is possible to read much
854			// faster with a copy routine which is aware of the limitation, but we
855			// assume for now that the user is not aware of that and would therefore
856			// prefer not to be given direct-mapped memory if they request read access.
857		✗	if (ctx->derive_works && dst->format == hwfc->sw_format &&
858		✗	((flags & AV_HWFRAME_MAP_DIRECT) || !(flags & AV_HWFRAME_MAP_READ))) {
859		✗	vas = vaDeriveImage(hwctx->display, surface_id, &map->image);
860		✗	if (vas != VA_STATUS_SUCCESS) {
861		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
862			"surface %#x: %d (%s).\n",
863			surface_id, vas, vaErrorStr(vas));
864		✗	err = AVERROR(EIO);
865		✗	goto fail;
866			}
867		✗	if (map->image.format.fourcc != image_format->fourcc) {
868		✗	av_log(hwfc, AV_LOG_ERROR, "Derive image of surface %#x "
869			"is in wrong format: expected %#08x, got %#08x.\n",
870		✗	surface_id, image_format->fourcc, map->image.format.fourcc);
871		✗	err = AVERROR(EIO);
872		✗	goto fail;
873			}
874		✗	map->flags |= AV_HWFRAME_MAP_DIRECT;
875			} else {
876		✗	vas = vaCreateImage(hwctx->display, image_format,
877			hwfc->width, hwfc->height, &map->image);
878		✗	if (vas != VA_STATUS_SUCCESS) {
879		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to create image for "
880			"surface %#x: %d (%s).\n",
881			surface_id, vas, vaErrorStr(vas));
882		✗	err = AVERROR(EIO);
883		✗	goto fail;
884			}
885		✗	if (!(flags & AV_HWFRAME_MAP_OVERWRITE)) {
886		✗	vas = vaGetImage(hwctx->display, surface_id, 0, 0,
887		✗	hwfc->width, hwfc->height, map->image.image_id);
888		✗	if (vas != VA_STATUS_SUCCESS) {
889		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to read image from "
890			"surface %#x: %d (%s).\n",
891			surface_id, vas, vaErrorStr(vas));
892		✗	err = AVERROR(EIO);
893		✗	goto fail;
894			}
895			}
896			}
897
898			#if VA_CHECK_VERSION(1, 21, 0)
899		✗	if (flags & AV_HWFRAME_MAP_READ)
900		✗	vaflags |= VA_MAPBUFFER_FLAG_READ;
901		✗	if (flags & AV_HWFRAME_MAP_WRITE)
902		✗	vaflags |= VA_MAPBUFFER_FLAG_WRITE;
903			// On drivers not implementing vaMapBuffer2 libva calls vaMapBuffer instead.
904		✗	vas = vaMapBuffer2(hwctx->display, map->image.buf, &address, vaflags);
905			#else
906			vas = vaMapBuffer(hwctx->display, map->image.buf, &address);
907			#endif
908		✗	if (vas != VA_STATUS_SUCCESS) {
909		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to map image from surface "
910			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
911		✗	err = AVERROR(EIO);
912		✗	goto fail;
913			}
914
915		✗	err = ff_hwframe_map_create(src->hw_frames_ctx,
916			dst, src, &vaapi_unmap_frame, map);
917		✗	if (err < 0)
918		✗	goto fail;
919
920		✗	dst->width = src->width;
921		✗	dst->height = src->height;
922
923		✗	for (i = 0; i < map->image.num_planes; i++) {
924		✗	dst->data[i] = (uint8_t*)address + map->image.offsets[i];
925		✗	dst->linesize[i] = map->image.pitches[i];
926			}
927
928		✗	desc = vaapi_format_from_fourcc(map->image.format.fourcc);
929		✗	if (desc && desc->chroma_planes_swapped) {
930			// Chroma planes are YVU rather than YUV, so swap them.
931		✗	FFSWAP(uint8_t*, dst->data[1], dst->data[2]);
932			}
933
934		✗	return 0;
935
936		✗	fail:
937		✗	if (map) {
938		✗	if (address)
939		✗	vaUnmapBuffer(hwctx->display, map->image.buf);
940		✗	if (map->image.image_id != VA_INVALID_ID)
941		✗	vaDestroyImage(hwctx->display, map->image.image_id);
942		✗	av_free(map);
943			}
944		✗	return err;
945			}
946
947		✗	static int vaapi_transfer_data_from(AVHWFramesContext *hwfc,
948			AVFrame *dst, const AVFrame *src)
949			{
950			AVFrame *map;
951			int err;
952
953		✗	if (dst->width > hwfc->width || dst->height > hwfc->height)
954		✗	return AVERROR(EINVAL);
955
956		✗	map = av_frame_alloc();
957		✗	if (!map)
958		✗	return AVERROR(ENOMEM);
959		✗	map->format = dst->format;
960
961		✗	err = vaapi_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
962		✗	if (err)
963		✗	goto fail;
964
965		✗	map->width = dst->width;
966		✗	map->height = dst->height;
967
968		✗	err = av_frame_copy(dst, map);
969		✗	if (err)
970		✗	goto fail;
971
972		✗	err = 0;
973		✗	fail:
974		✗	av_frame_free(&map);
975		✗	return err;
976			}
977
978		✗	static int vaapi_transfer_data_to(AVHWFramesContext *hwfc,
979			AVFrame *dst, const AVFrame *src)
980			{
981			AVFrame *map;
982			int err;
983
984		✗	if (src->width > hwfc->width || src->height > hwfc->height)
985		✗	return AVERROR(EINVAL);
986
987		✗	map = av_frame_alloc();
988		✗	if (!map)
989		✗	return AVERROR(ENOMEM);
990		✗	map->format = src->format;
991
992		✗	err = vaapi_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
993		✗	if (err)
994		✗	goto fail;
995
996		✗	map->width = src->width;
997		✗	map->height = src->height;
998
999		✗	err = av_frame_copy(map, src);
1000		✗	if (err)
1001		✗	goto fail;
1002
1003		✗	err = 0;
1004		✗	fail:
1005		✗	av_frame_free(&map);
1006		✗	return err;
1007			}
1008
1009		✗	static int vaapi_map_to_memory(AVHWFramesContext *hwfc, AVFrame *dst,
1010			const AVFrame *src, int flags)
1011			{
1012			int err;
1013
1014		✗	if (dst->format != AV_PIX_FMT_NONE) {
1015		✗	err = vaapi_get_image_format(hwfc->device_ctx, dst->format, NULL);
1016		✗	if (err < 0)
1017		✗	return err;
1018			}
1019
1020		✗	err = vaapi_map_frame(hwfc, dst, src, flags);
1021		✗	if (err)
1022		✗	return err;
1023
1024		✗	err = av_frame_copy_props(dst, src);
1025		✗	if (err)
1026		✗	return err;
1027
1028		✗	return 0;
1029			}
1030
1031			#if CONFIG_LIBDRM
1032
1033			#define DRM_MAP(va, layers, ...) { \
1034			VA_FOURCC_ ## va, \
1035			layers, \
1036			{ __VA_ARGS__ } \
1037			}
1038			static const struct {
1039			uint32_t va_fourcc;
1040			int nb_layer_formats;
1041			uint32_t layer_formats[AV_DRM_MAX_PLANES];
1042			} vaapi_drm_format_map[] = {
1043			#ifdef DRM_FORMAT_R8
1044			DRM_MAP(NV12, 2, DRM_FORMAT_R8, DRM_FORMAT_RG88),
1045			DRM_MAP(NV12, 2, DRM_FORMAT_R8, DRM_FORMAT_GR88),
1046			#endif
1047			DRM_MAP(NV12, 1, DRM_FORMAT_NV12),
1048			#if defined(VA_FOURCC_P010) && defined(DRM_FORMAT_R16)
1049			DRM_MAP(P010, 2, DRM_FORMAT_R16, DRM_FORMAT_RG1616),
1050			#endif
1051			#if defined(VA_FOURCC_P012) && defined(DRM_FORMAT_R16)
1052			DRM_MAP(P012, 2, DRM_FORMAT_R16, DRM_FORMAT_RG1616),
1053			#endif
1054			DRM_MAP(BGRA, 1, DRM_FORMAT_ARGB8888),
1055			DRM_MAP(BGRX, 1, DRM_FORMAT_XRGB8888),
1056			DRM_MAP(RGBA, 1, DRM_FORMAT_ABGR8888),
1057			DRM_MAP(RGBX, 1, DRM_FORMAT_XBGR8888),
1058			#ifdef VA_FOURCC_ABGR
1059			DRM_MAP(ABGR, 1, DRM_FORMAT_RGBA8888),
1060			DRM_MAP(XBGR, 1, DRM_FORMAT_RGBX8888),
1061			#endif
1062			DRM_MAP(ARGB, 1, DRM_FORMAT_BGRA8888),
1063			DRM_MAP(XRGB, 1, DRM_FORMAT_BGRX8888),
1064			#if defined(VA_FOURCC_XYUV) && defined(DRM_FORMAT_XYUV8888)
1065			DRM_MAP(XYUV, 1, DRM_FORMAT_XYUV8888),
1066			#endif
1067			#if defined(VA_FOURCC_Y412) && defined(DRM_FORMAT_XVYU2101010)
1068			DRM_MAP(Y410, 1, DRM_FORMAT_XVYU2101010),
1069			#endif
1070			#if defined(VA_FOURCC_Y412) && defined(DRM_FORMAT_XVYU12_16161616)
1071			DRM_MAP(Y412, 1, DRM_FORMAT_XVYU12_16161616),
1072			#endif
1073			#if defined(VA_FOURCC_X2R10G10B10) && defined(DRM_FORMAT_XRGB2101010)
1074			DRM_MAP(X2R10G10B10, 1, DRM_FORMAT_XRGB2101010),
1075			#endif
1076			};
1077			#undef DRM_MAP
1078
1079		✗	static void vaapi_unmap_from_drm(AVHWFramesContext *dst_fc,
1080			HWMapDescriptor *hwmap)
1081			{
1082		✗	AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx;
1083
1084		✗	VASurfaceID surface_id = (VASurfaceID)(uintptr_t)hwmap->priv;
1085
1086		✗	av_log(dst_fc, AV_LOG_DEBUG, "Destroy surface %#x.\n", surface_id);
1087
1088		✗	vaDestroySurfaces(dst_dev->display, &surface_id, 1);
1089		✗	}
1090
1091		✗	static int vaapi_map_from_drm(AVHWFramesContext *src_fc, AVFrame *dst,
1092			const AVFrame *src, int flags)
1093			{
1094			#if VA_CHECK_VERSION(1, 1, 0)
1095		✗	VAAPIFramesContext *src_vafc = src_fc->hwctx;
1096			int use_prime2;
1097			#else
1098			int k;
1099			#endif
1100		✗	AVHWFramesContext *dst_fc =
1101		✗	(AVHWFramesContext*)dst->hw_frames_ctx->data;
1102		✗	AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx;
1103			const AVDRMFrameDescriptor *desc;
1104			const VAAPIFormatDescriptor *format_desc;
1105			VASurfaceID surface_id;
1106		✗	VAStatus vas = VA_STATUS_SUCCESS;
1107			uint32_t va_fourcc;
1108			int err, i, j;
1109
1110			#if !VA_CHECK_VERSION(1, 1, 0)
1111			unsigned long buffer_handle;
1112			VASurfaceAttribExternalBuffers buffer_desc;
1113			VASurfaceAttrib attrs[2] = {
1114			{
1115			.type = VASurfaceAttribMemoryType,
1116			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1117			.value.type = VAGenericValueTypeInteger,
1118			.value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
1119			},
1120			{
1121			.type = VASurfaceAttribExternalBufferDescriptor,
1122			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1123			.value.type = VAGenericValueTypePointer,
1124			.value.value.p = &buffer_desc,
1125			}
1126			};
1127			#endif
1128
1129		✗	desc = (AVDRMFrameDescriptor*)src->data[0];
1130
1131		✗	if (desc->nb_objects != 1) {
1132		✗	av_log(dst_fc, AV_LOG_ERROR, "VAAPI can only map frames "
1133			"made from a single DRM object.\n");
1134		✗	return AVERROR(EINVAL);
1135			}
1136
1137		✗	va_fourcc = 0;
1138		✗	for (i = 0; i < FF_ARRAY_ELEMS(vaapi_drm_format_map); i++) {
1139		✗	if (desc->nb_layers != vaapi_drm_format_map[i].nb_layer_formats)
1140		✗	continue;
1141		✗	for (j = 0; j < desc->nb_layers; j++) {
1142		✗	if (desc->layers[j].format !=
1143		✗	vaapi_drm_format_map[i].layer_formats[j])
1144		✗	break;
1145			}
1146		✗	if (j != desc->nb_layers)
1147		✗	continue;
1148		✗	va_fourcc = vaapi_drm_format_map[i].va_fourcc;
1149		✗	break;
1150			}
1151		✗	if (!va_fourcc) {
1152		✗	av_log(dst_fc, AV_LOG_ERROR, "DRM format not supported "
1153			"by VAAPI.\n");
1154		✗	return AVERROR(EINVAL);
1155			}
1156
1157		✗	av_log(dst_fc, AV_LOG_DEBUG, "Map DRM object %d to VAAPI as "
1158		✗	"%08x.\n", desc->objects[0].fd, va_fourcc);
1159
1160		✗	format_desc = vaapi_format_from_fourcc(va_fourcc);
1161		✗	av_assert0(format_desc);
1162
1163			#if VA_CHECK_VERSION(1, 1, 0)
1164		✗	use_prime2 = !src_vafc->prime_2_import_unsupported &&
1165		✗	desc->objects[0].format_modifier != DRM_FORMAT_MOD_INVALID;
1166		✗	if (use_prime2) {
1167			VADRMPRIMESurfaceDescriptor prime_desc;
1168		✗	VASurfaceAttrib prime_attrs[2] = {
1169			{
1170			.type = VASurfaceAttribMemoryType,
1171			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1172			.value.type = VAGenericValueTypeInteger,
1173			.value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2,
1174			},
1175			{
1176			.type = VASurfaceAttribExternalBufferDescriptor,
1177			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1178			.value.type = VAGenericValueTypePointer,
1179			.value.value.p = &prime_desc,
1180			}
1181			};
1182		✗	prime_desc.fourcc = va_fourcc;
1183		✗	prime_desc.width = src_fc->width;
1184		✗	prime_desc.height = src_fc->height;
1185		✗	prime_desc.num_objects = desc->nb_objects;
1186		✗	for (i = 0; i < desc->nb_objects; ++i) {
1187		✗	prime_desc.objects[i].fd = desc->objects[i].fd;
1188		✗	prime_desc.objects[i].size = desc->objects[i].size;
1189		✗	prime_desc.objects[i].drm_format_modifier =
1190		✗	desc->objects[i].format_modifier;
1191			}
1192
1193		✗	prime_desc.num_layers = desc->nb_layers;
1194		✗	for (i = 0; i < desc->nb_layers; ++i) {
1195		✗	prime_desc.layers[i].drm_format = desc->layers[i].format;
1196		✗	prime_desc.layers[i].num_planes = desc->layers[i].nb_planes;
1197		✗	for (j = 0; j < desc->layers[i].nb_planes; ++j) {
1198		✗	prime_desc.layers[i].object_index[j] =
1199		✗	desc->layers[i].planes[j].object_index;
1200		✗	prime_desc.layers[i].offset[j] = desc->layers[i].planes[j].offset;
1201		✗	prime_desc.layers[i].pitch[j] = desc->layers[i].planes[j].pitch;
1202			}
1203
1204		✗	if (format_desc->chroma_planes_swapped &&
1205		✗	desc->layers[i].nb_planes == 3) {
1206		✗	FFSWAP(uint32_t, prime_desc.layers[i].pitch[1],
1207			prime_desc.layers[i].pitch[2]);
1208		✗	FFSWAP(uint32_t, prime_desc.layers[i].offset[1],
1209			prime_desc.layers[i].offset[2]);
1210			}
1211			}
1212
1213			/*
1214			* We can query for PRIME_2 support with vaQuerySurfaceAttributes, but that
1215			* that needs the config_id which we don't have here . Both Intel and
1216			* Gallium seem to do the correct error checks, so lets just try the
1217			* PRIME_2 import first.
1218			*/
1219		✗	vas = vaCreateSurfaces(dst_dev->display, format_desc->rt_format,
1220		✗	src->width, src->height, &surface_id, 1,
1221			prime_attrs, FF_ARRAY_ELEMS(prime_attrs));
1222		✗	if (vas != VA_STATUS_SUCCESS)
1223		✗	src_vafc->prime_2_import_unsupported = 1;
1224			}
1225
1226		✗	if (!use_prime2 || vas != VA_STATUS_SUCCESS) {
1227			int k;
1228			uintptr_t buffer_handle;
1229			VASurfaceAttribExternalBuffers buffer_desc;
1230		✗	VASurfaceAttrib buffer_attrs[2] = {
1231			{
1232			.type = VASurfaceAttribMemoryType,
1233			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1234			.value.type = VAGenericValueTypeInteger,
1235			.value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
1236			},
1237			{
1238			.type = VASurfaceAttribExternalBufferDescriptor,
1239			.flags = VA_SURFACE_ATTRIB_SETTABLE,
1240			.value.type = VAGenericValueTypePointer,
1241			.value.value.p = &buffer_desc,
1242			}
1243			};
1244
1245		✗	buffer_handle = desc->objects[0].fd;
1246		✗	buffer_desc.pixel_format = va_fourcc;
1247		✗	buffer_desc.width = src_fc->width;
1248		✗	buffer_desc.height = src_fc->height;
1249		✗	buffer_desc.data_size = desc->objects[0].size;
1250		✗	buffer_desc.buffers = &buffer_handle;
1251		✗	buffer_desc.num_buffers = 1;
1252		✗	buffer_desc.flags = 0;
1253
1254		✗	k = 0;
1255		✗	for (i = 0; i < desc->nb_layers; i++) {
1256		✗	for (j = 0; j < desc->layers[i].nb_planes; j++) {
1257		✗	buffer_desc.pitches[k] = desc->layers[i].planes[j].pitch;
1258		✗	buffer_desc.offsets[k] = desc->layers[i].planes[j].offset;
1259		✗	++k;
1260			}
1261			}
1262		✗	buffer_desc.num_planes = k;
1263
1264		✗	if (format_desc->chroma_planes_swapped &&
1265		✗	buffer_desc.num_planes == 3) {
1266		✗	FFSWAP(uint32_t, buffer_desc.pitches[1], buffer_desc.pitches[2]);
1267		✗	FFSWAP(uint32_t, buffer_desc.offsets[1], buffer_desc.offsets[2]);
1268			}
1269
1270		✗	vas = vaCreateSurfaces(dst_dev->display, format_desc->rt_format,
1271		✗	src->width, src->height,
1272			&surface_id, 1,
1273			buffer_attrs, FF_ARRAY_ELEMS(buffer_attrs));
1274			}
1275			#else
1276			buffer_handle = desc->objects[0].fd;
1277			buffer_desc.pixel_format = va_fourcc;
1278			buffer_desc.width = src_fc->width;
1279			buffer_desc.height = src_fc->height;
1280			buffer_desc.data_size = desc->objects[0].size;
1281			buffer_desc.buffers = &buffer_handle;
1282			buffer_desc.num_buffers = 1;
1283			buffer_desc.flags = 0;
1284
1285			k = 0;
1286			for (i = 0; i < desc->nb_layers; i++) {
1287			for (j = 0; j < desc->layers[i].nb_planes; j++) {
1288			buffer_desc.pitches[k] = desc->layers[i].planes[j].pitch;
1289			buffer_desc.offsets[k] = desc->layers[i].planes[j].offset;
1290			++k;
1291			}
1292			}
1293			buffer_desc.num_planes = k;
1294
1295			if (format_desc->chroma_planes_swapped &&
1296			buffer_desc.num_planes == 3) {
1297			FFSWAP(uint32_t, buffer_desc.pitches[1], buffer_desc.pitches[2]);
1298			FFSWAP(uint32_t, buffer_desc.offsets[1], buffer_desc.offsets[2]);
1299			}
1300
1301			vas = vaCreateSurfaces(dst_dev->display, format_desc->rt_format,
1302			src->width, src->height,
1303			&surface_id, 1,
1304			attrs, FF_ARRAY_ELEMS(attrs));
1305			#endif
1306		✗	if (vas != VA_STATUS_SUCCESS) {
1307		✗	av_log(dst_fc, AV_LOG_ERROR, "Failed to create surface from DRM "
1308			"object: %d (%s).\n", vas, vaErrorStr(vas));
1309		✗	return AVERROR(EIO);
1310			}
1311		✗	av_log(dst_fc, AV_LOG_DEBUG, "Create surface %#x.\n", surface_id);
1312
1313		✗	err = ff_hwframe_map_create(dst->hw_frames_ctx, dst, src,
1314			&vaapi_unmap_from_drm,
1315		✗	(void*)(uintptr_t)surface_id);
1316		✗	if (err < 0)
1317		✗	return err;
1318
1319		✗	dst->width = src->width;
1320		✗	dst->height = src->height;
1321		✗	dst->data[3] = (uint8_t*)(uintptr_t)surface_id;
1322
1323		✗	av_log(dst_fc, AV_LOG_DEBUG, "Mapped DRM object %d to "
1324		✗	"surface %#x.\n", desc->objects[0].fd, surface_id);
1325
1326		✗	return 0;
1327			}
1328
1329			#if VA_CHECK_VERSION(1, 1, 0)
1330		✗	static void vaapi_unmap_to_drm_esh(AVHWFramesContext *hwfc,
1331			HWMapDescriptor *hwmap)
1332			{
1333		✗	AVDRMFrameDescriptor *drm_desc = hwmap->priv;
1334			int i;
1335
1336		✗	for (i = 0; i < drm_desc->nb_objects; i++)
1337		✗	close(drm_desc->objects[i].fd);
1338
1339		✗	av_freep(&drm_desc);
1340		✗	}
1341
1342		✗	static int vaapi_map_to_drm_esh(AVHWFramesContext *hwfc, AVFrame *dst,
1343			const AVFrame *src, int flags)
1344			{
1345		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
1346			VASurfaceID surface_id;
1347			VAStatus vas;
1348			VADRMPRIMESurfaceDescriptor va_desc;
1349		✗	AVDRMFrameDescriptor *drm_desc = NULL;
1350			uint32_t export_flags;
1351			int err, i, j;
1352
1353		✗	surface_id = (VASurfaceID)(uintptr_t)src->data[3];
1354
1355		✗	export_flags = VA_EXPORT_SURFACE_SEPARATE_LAYERS;
1356		✗	if (flags & AV_HWFRAME_MAP_READ) {
1357		✗	export_flags |= VA_EXPORT_SURFACE_READ_ONLY;
1358
1359		✗	vas = vaSyncSurface(hwctx->display, surface_id);
1360		✗	if (vas != VA_STATUS_SUCCESS) {
1361		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to sync surface "
1362			"%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
1363		✗	return AVERROR(EIO);
1364			}
1365			}
1366
1367		✗	if (flags & AV_HWFRAME_MAP_WRITE)
1368		✗	export_flags |= VA_EXPORT_SURFACE_WRITE_ONLY;
1369
1370		✗	vas = vaExportSurfaceHandle(hwctx->display, surface_id,
1371			VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2,
1372			export_flags, &va_desc);
1373		✗	if (vas != VA_STATUS_SUCCESS) {
1374		✗	if (vas == VA_STATUS_ERROR_UNIMPLEMENTED)
1375		✗	return AVERROR(ENOSYS);
1376		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to export surface %#x: "
1377			"%d (%s).\n", surface_id, vas, vaErrorStr(vas));
1378		✗	return AVERROR(EIO);
1379			}
1380
1381		✗	drm_desc = av_mallocz(sizeof(*drm_desc));
1382		✗	if (!drm_desc) {
1383		✗	err = AVERROR(ENOMEM);
1384		✗	goto fail;
1385			}
1386
1387			// By some bizarre coincidence, these structures are very similar...
1388		✗	drm_desc->nb_objects = va_desc.num_objects;
1389		✗	for (i = 0; i < va_desc.num_objects; i++) {
1390		✗	drm_desc->objects[i].fd = va_desc.objects[i].fd;
1391		✗	drm_desc->objects[i].size = va_desc.objects[i].size;
1392		✗	drm_desc->objects[i].format_modifier =
1393		✗	va_desc.objects[i].drm_format_modifier;
1394			}
1395		✗	drm_desc->nb_layers = va_desc.num_layers;
1396		✗	for (i = 0; i < va_desc.num_layers; i++) {
1397		✗	drm_desc->layers[i].format = va_desc.layers[i].drm_format;
1398		✗	drm_desc->layers[i].nb_planes = va_desc.layers[i].num_planes;
1399		✗	for (j = 0; j < va_desc.layers[i].num_planes; j++) {
1400		✗	drm_desc->layers[i].planes[j].object_index =
1401		✗	va_desc.layers[i].object_index[j];
1402		✗	drm_desc->layers[i].planes[j].offset =
1403		✗	va_desc.layers[i].offset[j];
1404		✗	drm_desc->layers[i].planes[j].pitch =
1405		✗	va_desc.layers[i].pitch[j];
1406			}
1407			}
1408
1409		✗	err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,
1410			&vaapi_unmap_to_drm_esh, drm_desc);
1411		✗	if (err < 0)
1412		✗	goto fail;
1413
1414		✗	dst->width = src->width;
1415		✗	dst->height = src->height;
1416		✗	dst->data[0] = (uint8_t*)drm_desc;
1417
1418		✗	return 0;
1419
1420		✗	fail:
1421		✗	for (i = 0; i < va_desc.num_objects; i++)
1422		✗	close(va_desc.objects[i].fd);
1423		✗	av_freep(&drm_desc);
1424		✗	return err;
1425			}
1426			#endif
1427
1428			#if VA_CHECK_VERSION(0, 36, 0)
1429			typedef struct VAAPIDRMImageBufferMapping {
1430			VAImage image;
1431			VABufferInfo buffer_info;
1432
1433			AVDRMFrameDescriptor drm_desc;
1434			} VAAPIDRMImageBufferMapping;
1435
1436		✗	static void vaapi_unmap_to_drm_abh(AVHWFramesContext *hwfc,
1437			HWMapDescriptor *hwmap)
1438			{
1439		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
1440		✗	VAAPIDRMImageBufferMapping *mapping = hwmap->priv;
1441			VASurfaceID surface_id;
1442			VAStatus vas;
1443
1444		✗	surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];
1445		✗	av_log(hwfc, AV_LOG_DEBUG, "Unmap VAAPI surface %#x from DRM.\n",
1446			surface_id);
1447
1448			// DRM PRIME file descriptors are closed by vaReleaseBufferHandle(),
1449			// so we shouldn't close them separately.
1450
1451		✗	vas = vaReleaseBufferHandle(hwctx->display, mapping->image.buf);
1452		✗	if (vas != VA_STATUS_SUCCESS) {
1453		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to release buffer "
1454			"handle of image %#x (derived from surface %#x): "
1455			"%d (%s).\n", mapping->image.buf, surface_id,
1456			vas, vaErrorStr(vas));
1457			}
1458
1459		✗	vas = vaDestroyImage(hwctx->display, mapping->image.image_id);
1460		✗	if (vas != VA_STATUS_SUCCESS) {
1461		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to destroy image "
1462			"derived from surface %#x: %d (%s).\n",
1463			surface_id, vas, vaErrorStr(vas));
1464			}
1465
1466		✗	av_free(mapping);
1467		✗	}
1468
1469		✗	static int vaapi_map_to_drm_abh(AVHWFramesContext *hwfc, AVFrame *dst,
1470			const AVFrame *src, int flags)
1471			{
1472		✗	AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
1473		✗	VAAPIDRMImageBufferMapping *mapping = NULL;
1474			VASurfaceID surface_id;
1475			VAStatus vas;
1476			int err, i, p;
1477
1478		✗	surface_id = (VASurfaceID)(uintptr_t)src->data[3];
1479		✗	av_log(hwfc, AV_LOG_DEBUG, "Map VAAPI surface %#x to DRM.\n",
1480			surface_id);
1481
1482		✗	mapping = av_mallocz(sizeof(*mapping));
1483		✗	if (!mapping)
1484		✗	return AVERROR(ENOMEM);
1485
1486		✗	vas = vaDeriveImage(hwctx->display, surface_id,
1487		✗	&mapping->image);
1488		✗	if (vas != VA_STATUS_SUCCESS) {
1489		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
1490			"surface %#x: %d (%s).\n",
1491			surface_id, vas, vaErrorStr(vas));
1492		✗	err = AVERROR(EIO);
1493		✗	goto fail;
1494			}
1495
1496		✗	for (i = 0; i < FF_ARRAY_ELEMS(vaapi_drm_format_map); i++) {
1497		✗	if (vaapi_drm_format_map[i].va_fourcc ==
1498		✗	mapping->image.format.fourcc)
1499		✗	break;
1500			}
1501		✗	if (i >= FF_ARRAY_ELEMS(vaapi_drm_format_map)) {
1502		✗	av_log(hwfc, AV_LOG_ERROR, "No matching DRM format for "
1503		✗	"VAAPI format %#x.\n", mapping->image.format.fourcc);
1504		✗	err = AVERROR(EINVAL);
1505		✗	goto fail_derived;
1506			}
1507
1508		✗	mapping->buffer_info.mem_type =
1509			VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
1510
1511		✗	mapping->drm_desc.nb_layers =
1512		✗	vaapi_drm_format_map[i].nb_layer_formats;
1513		✗	if (mapping->drm_desc.nb_layers > 1) {
1514		✗	if (mapping->drm_desc.nb_layers != mapping->image.num_planes) {
1515		✗	av_log(hwfc, AV_LOG_ERROR, "Image properties do not match "
1516			"expected format: got %d planes, but expected %d.\n",
1517		✗	mapping->image.num_planes, mapping->drm_desc.nb_layers);
1518		✗	err = AVERROR(EINVAL);
1519		✗	goto fail_derived;
1520			}
1521
1522		✗	for(p = 0; p < mapping->drm_desc.nb_layers; p++) {
1523		✗	mapping->drm_desc.layers[p] = (AVDRMLayerDescriptor) {
1524		✗	.format = vaapi_drm_format_map[i].layer_formats[p],
1525			.nb_planes = 1,
1526			.planes[0] = {
1527			.object_index = 0,
1528		✗	.offset = mapping->image.offsets[p],
1529		✗	.pitch = mapping->image.pitches[p],
1530			},
1531			};
1532			}
1533			} else {
1534		✗	mapping->drm_desc.layers[0].format =
1535		✗	vaapi_drm_format_map[i].layer_formats[0];
1536		✗	mapping->drm_desc.layers[0].nb_planes = mapping->image.num_planes;
1537		✗	for (p = 0; p < mapping->image.num_planes; p++) {
1538		✗	mapping->drm_desc.layers[0].planes[p] = (AVDRMPlaneDescriptor) {
1539			.object_index = 0,
1540		✗	.offset = mapping->image.offsets[p],
1541		✗	.pitch = mapping->image.pitches[p],
1542			};
1543			}
1544			}
1545
1546		✗	vas = vaAcquireBufferHandle(hwctx->display, mapping->image.buf,
1547		✗	&mapping->buffer_info);
1548		✗	if (vas != VA_STATUS_SUCCESS) {
1549		✗	av_log(hwfc, AV_LOG_ERROR, "Failed to get buffer "
1550			"handle from image %#x (derived from surface %#x): "
1551		✗	"%d (%s).\n", mapping->image.buf, surface_id,
1552			vas, vaErrorStr(vas));
1553		✗	err = AVERROR(EIO);
1554		✗	goto fail_derived;
1555			}
1556
1557		✗	av_log(hwfc, AV_LOG_DEBUG, "DRM PRIME fd is %"PRIdPTR".\n",
1558		✗	mapping->buffer_info.handle);
1559
1560		✗	mapping->drm_desc.nb_objects = 1;
1561		✗	mapping->drm_desc.objects[0] = (AVDRMObjectDescriptor) {
1562		✗	.fd = mapping->buffer_info.handle,
1563		✗	.size = mapping->image.data_size,
1564			// There is no way to get the format modifier with this API.
1565			.format_modifier = DRM_FORMAT_MOD_INVALID,
1566			};
1567
1568		✗	err = ff_hwframe_map_create(src->hw_frames_ctx,
1569			dst, src, &vaapi_unmap_to_drm_abh,
1570			mapping);
1571		✗	if (err < 0)
1572		✗	goto fail_mapped;
1573
1574		✗	dst->data[0] = (uint8_t*)&mapping->drm_desc;
1575		✗	dst->width = src->width;
1576		✗	dst->height = src->height;
1577
1578		✗	return 0;
1579
1580		✗	fail_mapped:
1581		✗	vaReleaseBufferHandle(hwctx->display, mapping->image.buf);
1582		✗	fail_derived:
1583		✗	vaDestroyImage(hwctx->display, mapping->image.image_id);
1584		✗	fail:
1585		✗	av_freep(&mapping);
1586		✗	return err;
1587			}
1588			#endif
1589
1590		✗	static int vaapi_map_to_drm(AVHWFramesContext *hwfc, AVFrame *dst,
1591			const AVFrame *src, int flags)
1592			{
1593			#if VA_CHECK_VERSION(1, 1, 0)
1594			int err;
1595		✗	err = vaapi_map_to_drm_esh(hwfc, dst, src, flags);
1596		✗	if (err != AVERROR(ENOSYS))
1597		✗	return err;
1598			#endif
1599			#if VA_CHECK_VERSION(0, 36, 0)
1600		✗	return vaapi_map_to_drm_abh(hwfc, dst, src, flags);
1601			#endif
1602			return AVERROR(ENOSYS);
1603			}
1604
1605			#endif /* CONFIG_LIBDRM */
1606
1607		✗	static int vaapi_map_to(AVHWFramesContext *hwfc, AVFrame *dst,
1608			const AVFrame *src, int flags)
1609			{
1610		✗	switch (src->format) {
1611			#if CONFIG_LIBDRM
1612		✗	case AV_PIX_FMT_DRM_PRIME:
1613		✗	return vaapi_map_from_drm(hwfc, dst, src, flags);
1614			#endif
1615		✗	default:
1616		✗	return AVERROR(ENOSYS);
1617			}
1618			}
1619
1620		✗	static int vaapi_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
1621			const AVFrame *src, int flags)
1622			{
1623		✗	switch (dst->format) {
1624			#if CONFIG_LIBDRM
1625		✗	case AV_PIX_FMT_DRM_PRIME:
1626		✗	return vaapi_map_to_drm(hwfc, dst, src, flags);
1627			#endif
1628		✗	default:
1629		✗	return vaapi_map_to_memory(hwfc, dst, src, flags);
1630			}
1631			}
1632
1633		✗	static void vaapi_device_free(AVHWDeviceContext *ctx)
1634			{
1635		✗	AVVAAPIDeviceContext *hwctx = ctx->hwctx;
1636		✗	VAAPIDevicePriv *priv = ctx->user_opaque;
1637
1638		✗	if (hwctx->display)
1639		✗	vaTerminate(hwctx->display);
1640
1641			#if HAVE_VAAPI_X11
1642		✗	if (priv->x11_display)
1643		✗	XCloseDisplay(priv->x11_display);
1644			#endif
1645
1646		✗	if (priv->drm_fd >= 0)
1647		✗	close(priv->drm_fd);
1648
1649		✗	av_freep(&priv);
1650		✗	}
1651
1652			#if CONFIG_VAAPI_1
1653		✗	static void vaapi_device_log_error(void *context, const char *message)
1654			{
1655		✗	AVHWDeviceContext *ctx = context;
1656
1657		✗	av_log(ctx, AV_LOG_ERROR, "libva: %s", message);
1658		✗	}
1659
1660		✗	static void vaapi_device_log_info(void *context, const char *message)
1661			{
1662		✗	AVHWDeviceContext *ctx = context;
1663
1664		✗	av_log(ctx, AV_LOG_VERBOSE, "libva: %s", message);
1665		✗	}
1666			#endif
1667
1668		✗	static int vaapi_device_connect(AVHWDeviceContext *ctx,
1669			VADisplay display)
1670			{
1671		✗	AVVAAPIDeviceContext *hwctx = ctx->hwctx;
1672			int major, minor;
1673			VAStatus vas;
1674
1675			#if CONFIG_VAAPI_1
1676		✗	vaSetErrorCallback(display, &vaapi_device_log_error, ctx);
1677		✗	vaSetInfoCallback (display, &vaapi_device_log_info, ctx);
1678			#endif
1679
1680		✗	hwctx->display = display;
1681
1682		✗	vas = vaInitialize(display, &major, &minor);
1683		✗	if (vas != VA_STATUS_SUCCESS) {
1684		✗	av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI "
1685			"connection: %d (%s).\n", vas, vaErrorStr(vas));
1686		✗	return AVERROR(EIO);
1687			}
1688		✗	av_log(ctx, AV_LOG_VERBOSE, "Initialised VAAPI connection: "
1689			"version %d.%d\n", major, minor);
1690
1691		✗	return 0;
1692			}
1693
1694		✗	static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
1695			AVDictionary *opts, int flags)
1696			{
1697			VAAPIDevicePriv *priv;
1698		✗	VADisplay display = NULL;
1699			const AVDictionaryEntry *ent;
1700			int try_drm, try_x11, try_win32, try_all;
1701
1702		✗	priv = av_mallocz(sizeof(*priv));
1703		✗	if (!priv)
1704		✗	return AVERROR(ENOMEM);
1705
1706		✗	priv->drm_fd = -1;
1707
1708		✗	ctx->user_opaque = priv;
1709		✗	ctx->free = vaapi_device_free;
1710
1711		✗	ent = av_dict_get(opts, "connection_type", NULL, 0);
1712		✗	if (ent) {
1713		✗	try_all = try_drm = try_x11 = try_win32 = 0;
1714		✗	if (!strcmp(ent->value, "drm")) {
1715		✗	try_drm = 1;
1716		✗	} else if (!strcmp(ent->value, "x11")) {
1717		✗	try_x11 = 1;
1718		✗	} else if (!strcmp(ent->value, "win32")) {
1719		✗	try_win32 = 1;
1720			} else {
1721		✗	av_log(ctx, AV_LOG_ERROR, "Invalid connection type %s.\n",
1722		✗	ent->value);
1723		✗	return AVERROR(EINVAL);
1724			}
1725			} else {
1726		✗	try_all = 1;
1727		✗	try_drm = HAVE_VAAPI_DRM;
1728		✗	try_x11 = HAVE_VAAPI_X11;
1729		✗	try_win32 = HAVE_VAAPI_WIN32;
1730			}
1731
1732			#if HAVE_VAAPI_DRM
1733		✗	while (!display && try_drm) {
1734			// If the device is specified, try to open it as a DRM device node.
1735			// If not, look for a usable render node, possibly restricted to those
1736			// using a specified kernel driver.
1737		✗	int loglevel = try_all ? AV_LOG_VERBOSE : AV_LOG_ERROR;
1738		✗	if (device) {
1739		✗	priv->drm_fd = open(device, O_RDWR);
1740		✗	if (priv->drm_fd < 0) {
1741		✗	av_log(ctx, loglevel, "Failed to open %s as "
1742			"DRM device node.\n", device);
1743		✗	break;
1744			}
1745			} else {
1746			char path[64];
1747		✗	int n, max_devices = 8;
1748			#if CONFIG_LIBDRM
1749			drmVersion *info;
1750			const AVDictionaryEntry *kernel_driver;
1751			const AVDictionaryEntry *vendor_id;
1752		✗	kernel_driver = av_dict_get(opts, "kernel_driver", NULL, 0);
1753		✗	vendor_id = av_dict_get(opts, "vendor_id", NULL, 0);
1754			#endif
1755		✗	for (n = 0; n < max_devices; n++) {
1756		✗	snprintf(path, sizeof(path),
1757			"/dev/dri/renderD%d", 128 + n);
1758		✗	priv->drm_fd = open(path, O_RDWR);
1759		✗	if (priv->drm_fd < 0) {
1760		✗	if (errno == ENOENT) {
1761		✗	if (n != max_devices - 1) {
1762		✗	av_log(ctx, AV_LOG_VERBOSE,
1763			"No render device %s, try next device for "
1764			"DRM render node.\n", path);
1765		✗	continue;
1766			}
1767
1768		✗	av_log(ctx, AV_LOG_VERBOSE, "No available render device "
1769			"for DRM render node.\n");
1770			} else
1771		✗	av_log(ctx, AV_LOG_VERBOSE, "Cannot open "
1772			"DRM render node for device %d.\n", n);
1773		✗	break;
1774			}
1775			#if CONFIG_LIBDRM
1776		✗	info = drmGetVersion(priv->drm_fd);
1777		✗	if (!info) {
1778		✗	av_log(ctx, AV_LOG_VERBOSE,
1779			"Failed to get DRM version for device %d.\n", n);
1780		✗	close(priv->drm_fd);
1781		✗	priv->drm_fd = -1;
1782		✗	continue;
1783			}
1784		✗	if (kernel_driver) {
1785		✗	if (strcmp(kernel_driver->value, info->name)) {
1786		✗	av_log(ctx, AV_LOG_VERBOSE, "Ignoring device %d "
1787			"with non-matching kernel driver (%s).\n",
1788			n, info->name);
1789		✗	drmFreeVersion(info);
1790		✗	close(priv->drm_fd);
1791		✗	priv->drm_fd = -1;
1792		✗	continue;
1793			}
1794		✗	av_log(ctx, AV_LOG_VERBOSE, "Trying to use "
1795			"DRM render node for device %d, "
1796			"with matching kernel driver (%s).\n",
1797			n, info->name);
1798		✗	drmFreeVersion(info);
1799		✗	break;
1800			// drmGetVersion() ensures |info->name| is 0-terminated.
1801		✗	} else if (!strcmp(info->name, "vgem")) {
1802		✗	av_log(ctx, AV_LOG_VERBOSE,
1803			"Skipping vgem node for device %d.\n", n);
1804		✗	drmFreeVersion(info);
1805		✗	close(priv->drm_fd);
1806		✗	priv->drm_fd = -1;
1807		✗	continue;
1808		✗	} else if (vendor_id) {
1809			drmDevicePtr device;
1810			char drm_vendor[8];
1811		✗	if (drmGetDevice(priv->drm_fd, &device)) {
1812		✗	av_log(ctx, AV_LOG_VERBOSE,
1813			"Failed to get DRM device info for device %d.\n", n);
1814		✗	close(priv->drm_fd);
1815		✗	priv->drm_fd = -1;
1816		✗	continue;
1817			}
1818
1819		✗	snprintf(drm_vendor, sizeof(drm_vendor), "0x%x", device->deviceinfo.pci->vendor_id);
1820		✗	if (strcmp(vendor_id->value, drm_vendor)) {
1821		✗	av_log(ctx, AV_LOG_VERBOSE, "Ignoring device %d "
1822			"with non-matching vendor id (%s).\n",
1823		✗	n, vendor_id->value);
1824		✗	drmFreeDevice(&device);
1825		✗	close(priv->drm_fd);
1826		✗	priv->drm_fd = -1;
1827		✗	continue;
1828			}
1829		✗	av_log(ctx, AV_LOG_VERBOSE, "Trying to use "
1830			"DRM render node for device %d, "
1831			"with matching vendor id (%s).\n",
1832		✗	n, vendor_id->value);
1833		✗	drmFreeDevice(&device);
1834		✗	break;
1835			}
1836		✗	drmFreeVersion(info);
1837			#endif
1838		✗	av_log(ctx, AV_LOG_VERBOSE, "Trying to use "
1839			"DRM render node for device %d.\n", n);
1840		✗	break;
1841			}
1842		✗	if (n >= max_devices)
1843		✗	break;
1844			}
1845
1846		✗	display = vaGetDisplayDRM(priv->drm_fd);
1847		✗	if (!display) {
1848		✗	av_log(ctx, AV_LOG_VERBOSE, "Cannot open a VA display "
1849			"from DRM device %s.\n", device);
1850		✗	return AVERROR_EXTERNAL;
1851			}
1852		✗	break;
1853			}
1854			#endif
1855
1856			#if HAVE_VAAPI_X11
1857		✗	if (!display && try_x11) {
1858			// Try to open the device as an X11 display.
1859		✗	priv->x11_display = XOpenDisplay(device);
1860		✗	if (!priv->x11_display) {
1861		✗	av_log(ctx, AV_LOG_VERBOSE, "Cannot open X11 display "
1862			"%s.\n", XDisplayName(device));
1863			} else {
1864		✗	display = vaGetDisplay(priv->x11_display);
1865		✗	if (!display) {
1866		✗	av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
1867			"from X11 display %s.\n", XDisplayName(device));
1868		✗	return AVERROR_UNKNOWN;
1869			}
1870
1871		✗	av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
1872			"X11 display %s.\n", XDisplayName(device));
1873			}
1874			}
1875			#endif
1876
1877			#if HAVE_VAAPI_WIN32
1878			if (!display && try_win32) {
1879			// Try to create a display from the specified device, if any.
1880			if (!device) {
1881			display = vaGetDisplayWin32(NULL);
1882			} else {
1883			IDXGIFactory2 *pDXGIFactory = NULL;
1884			IDXGIAdapter *pAdapter = NULL;
1885			#if !HAVE_UWP
1886			HANDLE dxgi = dlopen("dxgi.dll", 0);
1887			if (!dxgi) {
1888			av_log(ctx, AV_LOG_ERROR, "Failed to load dxgi.dll\n");
1889			return AVERROR_UNKNOWN;
1890			}
1891			PFN_CREATE_DXGI_FACTORY pfnCreateDXGIFactory =
1892			(PFN_CREATE_DXGI_FACTORY)dlsym(dxgi, "CreateDXGIFactory");
1893			if (!pfnCreateDXGIFactory) {
1894			av_log(ctx, AV_LOG_ERROR, "CreateDXGIFactory load failed\n");
1895			dlclose(dxgi);
1896			return AVERROR_UNKNOWN;
1897			}
1898			#else
1899			// In UWP (which lacks LoadLibrary), CreateDXGIFactory isn't
1900			// available, only CreateDXGIFactory1
1901			PFN_CREATE_DXGI_FACTORY pfnCreateDXGIFactory =
1902			(PFN_CREATE_DXGI_FACTORY)CreateDXGIFactory1;
1903			#endif
1904			if (SUCCEEDED(pfnCreateDXGIFactory(&IID_IDXGIFactory2,
1905			(void **)&pDXGIFactory))) {
1906			int adapter = atoi(device);
1907			if (SUCCEEDED(IDXGIFactory2_EnumAdapters(pDXGIFactory,
1908			adapter,
1909			&pAdapter))) {
1910			DXGI_ADAPTER_DESC desc;
1911			if (SUCCEEDED(IDXGIAdapter2_GetDesc(pAdapter, &desc))) {
1912			av_log(ctx, AV_LOG_INFO,
1913			"Using device %04x:%04x (%ls) - LUID %lu %ld.\n",
1914			desc.VendorId, desc.DeviceId, desc.Description,
1915			desc.AdapterLuid.LowPart,
1916			desc.AdapterLuid.HighPart);
1917			display = vaGetDisplayWin32(&desc.AdapterLuid);
1918			}
1919			IDXGIAdapter_Release(pAdapter);
1920			}
1921			IDXGIFactory2_Release(pDXGIFactory);
1922			}
1923			#if !HAVE_UWP
1924			dlclose(dxgi);
1925			#endif
1926			}
1927
1928			if (!display) {
1929			av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
1930			"from Win32 display.\n");
1931			return AVERROR_UNKNOWN;
1932			}
1933
1934			av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
1935			"Win32 display.\n");
1936			}
1937			#endif
1938
1939		✗	if (!display) {
1940		✗	if (device)
1941		✗	av_log(ctx, AV_LOG_ERROR, "No VA display found for "
1942			"device %s.\n", device);
1943			else
1944		✗	av_log(ctx, AV_LOG_ERROR, "No VA display found for "
1945			"any default device.\n");
1946		✗	return AVERROR(EINVAL);
1947			}
1948
1949		✗	ent = av_dict_get(opts, "driver", NULL, 0);
1950		✗	if (ent) {
1951			#if VA_CHECK_VERSION(0, 38, 0)
1952			VAStatus vas;
1953		✗	vas = vaSetDriverName(display, ent->value);
1954		✗	if (vas != VA_STATUS_SUCCESS) {
1955		✗	av_log(ctx, AV_LOG_ERROR, "Failed to set driver name to "
1956		✗	"%s: %d (%s).\n", ent->value, vas, vaErrorStr(vas));
1957		✗	vaTerminate(display);
1958		✗	return AVERROR_EXTERNAL;
1959			}
1960			#else
1961			av_log(ctx, AV_LOG_WARNING, "Driver name setting is not "
1962			"supported with this VAAPI version.\n");
1963			#endif
1964			}
1965
1966		✗	return vaapi_device_connect(ctx, display);
1967			}
1968
1969		✗	static int vaapi_device_derive(AVHWDeviceContext *ctx,
1970			AVHWDeviceContext *src_ctx,
1971			AVDictionary *opts, int flags)
1972			{
1973			#if HAVE_VAAPI_DRM
1974		✗	if (src_ctx->type == AV_HWDEVICE_TYPE_DRM) {
1975		✗	AVDRMDeviceContext *src_hwctx = src_ctx->hwctx;
1976			VADisplay *display;
1977			VAAPIDevicePriv *priv;
1978			int fd;
1979
1980		✗	if (src_hwctx->fd < 0) {
1981		✗	av_log(ctx, AV_LOG_ERROR, "DRM instance requires an associated "
1982			"device to derive a VA display from.\n");
1983		✗	return AVERROR(EINVAL);
1984			}
1985
1986			#if CONFIG_LIBDRM
1987			{
1988		✗	int node_type = drmGetNodeTypeFromFd(src_hwctx->fd);
1989			char *render_node;
1990		✗	if (node_type < 0) {
1991		✗	av_log(ctx, AV_LOG_ERROR, "DRM instance fd does not appear "
1992			"to refer to a DRM device.\n");
1993		✗	return AVERROR(EINVAL);
1994			}
1995		✗	if (node_type == DRM_NODE_RENDER) {
1996		✗	fd = src_hwctx->fd;
1997			} else {
1998		✗	render_node = drmGetRenderDeviceNameFromFd(src_hwctx->fd);
1999		✗	if (!render_node) {
2000		✗	av_log(ctx, AV_LOG_VERBOSE, "Using non-render node "
2001			"because the device does not have an "
2002			"associated render node.\n");
2003		✗	fd = src_hwctx->fd;
2004			} else {
2005		✗	fd = open(render_node, O_RDWR);
2006		✗	if (fd < 0) {
2007		✗	av_log(ctx, AV_LOG_VERBOSE, "Using non-render node "
2008			"because the associated render node "
2009			"could not be opened.\n");
2010		✗	fd = src_hwctx->fd;
2011			} else {
2012		✗	av_log(ctx, AV_LOG_VERBOSE, "Using render node %s "
2013			"in place of non-render DRM device.\n",
2014			render_node);
2015			}
2016		✗	free(render_node);
2017			}
2018			}
2019			}
2020			#else
2021			fd = src_hwctx->fd;
2022			#endif
2023
2024		✗	priv = av_mallocz(sizeof(*priv));
2025		✗	if (!priv) {
2026		✗	if (fd != src_hwctx->fd) {
2027			// The fd was opened in this function.
2028		✗	close(fd);
2029			}
2030		✗	return AVERROR(ENOMEM);
2031			}
2032
2033		✗	if (fd == src_hwctx->fd) {
2034			// The fd is inherited from the source context and we are holding
2035			// a reference to that, we don't want to close it from here.
2036		✗	priv->drm_fd = -1;
2037			} else {
2038		✗	priv->drm_fd = fd;
2039			}
2040
2041		✗	ctx->user_opaque = priv;
2042		✗	ctx->free = &vaapi_device_free;
2043
2044		✗	display = vaGetDisplayDRM(fd);
2045		✗	if (!display) {
2046		✗	av_log(ctx, AV_LOG_ERROR, "Failed to open a VA display from "
2047			"DRM device.\n");
2048		✗	return AVERROR(EIO);
2049			}
2050
2051		✗	return vaapi_device_connect(ctx, display);
2052			}
2053			#endif
2054		✗	return AVERROR(ENOSYS);
2055			}
2056
2057			const HWContextType ff_hwcontext_type_vaapi = {
2058			.type = AV_HWDEVICE_TYPE_VAAPI,
2059			.name = "VAAPI",
2060
2061			.device_hwctx_size = sizeof(VAAPIDeviceContext),
2062			.device_hwconfig_size = sizeof(AVVAAPIHWConfig),
2063			.frames_hwctx_size = sizeof(VAAPIFramesContext),
2064
2065			.device_create = &vaapi_device_create,
2066			.device_derive = &vaapi_device_derive,
2067			.device_init = &vaapi_device_init,
2068			.device_uninit = &vaapi_device_uninit,
2069			.frames_get_constraints = &vaapi_frames_get_constraints,
2070			.frames_init = &vaapi_frames_init,
2071			.frames_uninit = &vaapi_frames_uninit,
2072			.frames_get_buffer = &vaapi_get_buffer,
2073			.transfer_get_formats = &vaapi_transfer_get_formats,
2074			.transfer_data_to = &vaapi_transfer_data_to,
2075			.transfer_data_from = &vaapi_transfer_data_from,
2076			.map_to = &vaapi_map_to,
2077			.map_from = &vaapi_map_from,
2078
2079			.pix_fmts = (const enum AVPixelFormat[]) {
2080			AV_PIX_FMT_VAAPI,
2081			AV_PIX_FMT_NONE
2082			},
2083			};
2084