va/wayland/va_wayland_linux_dmabuf.c - third_party/github.com/intel/libva - Git at Google

 /*
  * va_wayland_drm.c - Wayland/linux-dmabuf helpers
  *
  * Copyright (c) 2024 Simon Ser
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  * IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 #include "sysdeps.h"
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <dlfcn.h>
 #include <sys/stat.h>
 #include <xf86drm.h>
 #include "va_drmcommon.h"
 #include "drm/va_drm_utils.h"
 #include "va_wayland_linux_dmabuf.h"
 #include "va_wayland_private.h"
 #include "linux-dmabuf-v1-client-protocol.h"

 typedef struct va_wayland_linux_dmabuf_context {
     struct va_wayland_context base;
     bool                      has_linux_dmabuf;
     bool                      default_feedback_done;
 } VADisplayContextWaylandLinuxDmabuf;

 static void
 feedback_handle_done(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback
 )
 {
     VADisplayContextP const pDisplayContext = data;
     struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx = pDisplayContext->opaque;

     wl_linux_dmabuf_ctx->default_feedback_done = true;

     zwp_linux_dmabuf_feedback_v1_destroy(feedback);
 }

 static void
 feedback_handle_format_table(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback,
     int                                  fd,
     uint32_t                             size
 )
 {
     close(fd);
 }

 /* XXX: replace with drmGetDeviceFromDevId() */
 static drmDevice *
 get_drm_device_from_dev_id(dev_t dev_id)
 {
     uint32_t flags = 0;
     int devices_len, i, node_type;
     drmDevice *match = NULL, *dev;
     struct stat statbuf;

     devices_len = drmGetDevices2(flags, NULL, 0);
     if (devices_len < 0) {
         return NULL;
     }
     drmDevice **devices = calloc(devices_len, sizeof(*devices));
     if (devices == NULL) {
         return NULL;
     }
     devices_len = drmGetDevices2(flags, devices, devices_len);
     if (devices_len < 0) {
         free(devices);
         return NULL;
     }

     for (i = 0; i < devices_len; i++) {
         dev = devices[i];
         for (node_type = 0; node_type < DRM_NODE_MAX; node_type++) {
             if (!(dev->available_nodes & (1 << node_type)))
                 continue;

             if (stat(dev->nodes[node_type], &statbuf) != 0) {
                 va_wayland_error("stat() failed for %s", dev->nodes[node_type]);
                 continue;
             }

             if (statbuf.st_rdev == dev_id) {
                 match = dev;
                 break;
             }
         }
     }

     for (i = 0; i < devices_len; i++) {
         dev = devices[i];
         if (dev != match)
             drmFreeDevice(&dev);
     }
     free(devices);

     return match;
 }

 static void
 feedback_handle_main_device(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback,
     struct wl_array                     *device_array
 )
 {
     dev_t dev_id;
     drmDevice *dev;
     const char *dev_path;
     VADisplayContextP const pDisplayContext = data;
     VADriverContextP const ctx = pDisplayContext->pDriverContext;
     struct drm_state * const drm_state = ctx->drm_state;

     assert(device_array->size == sizeof(dev_id));
     memcpy(&dev_id, device_array->data, sizeof(dev_id));

     dev = get_drm_device_from_dev_id(dev_id);
     if (!dev) {
         va_wayland_error("failed to get DRM device from device ID");
         return;
     }

     if (!(dev->available_nodes & (1 << DRM_NODE_RENDER)))
         goto end;

     dev_path = dev->nodes[DRM_NODE_RENDER];
     drm_state->fd = open(dev_path, O_RDWR | O_CLOEXEC);
     if (drm_state->fd < 0) {
         va_wayland_error("failed to open %s", dev_path);
         goto end;
     }

     drm_state->auth_type = VA_DRM_AUTH_CUSTOM;

 end:
     drmFreeDevice(&dev);
 }

 static void
 feedback_handle_tranche_done(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback
 )
 {
 }

 static void
 feedback_handle_tranche_target_device(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback,
     struct wl_array                     *device_array
 )
 {
 }

 static void
 feedback_handle_tranche_formats(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback,
     struct wl_array                     *indices_array
 )
 {
 }

 static void
 feedback_handle_tranche_flags(
     void                                *data,
     struct zwp_linux_dmabuf_feedback_v1 *feedback,
     uint32_t                             flags
 )
 {
 }

 static const struct zwp_linux_dmabuf_feedback_v1_listener feedback_listener = {
     .done = feedback_handle_done,
     .format_table = feedback_handle_format_table,
     .main_device = feedback_handle_main_device,
     .tranche_done = feedback_handle_tranche_done,
     .tranche_target_device = feedback_handle_tranche_target_device,
     .tranche_formats = feedback_handle_tranche_formats,
     .tranche_flags = feedback_handle_tranche_flags,
 };

 static void
 registry_handle_global(
     void               *data,
     struct wl_registry *registry,
     uint32_t            name,
     const char         *interface,
     uint32_t            version
 )
 {
     VADisplayContextP const pDisplayContext = data;
     struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx = pDisplayContext->opaque;
     struct zwp_linux_dmabuf_v1 *linux_dmabuf;
     struct zwp_linux_dmabuf_feedback_v1 *feedback;

     if (strcmp(interface, zwp_linux_dmabuf_v1_interface.name) == 0 &&
         version >= 4) {
         wl_linux_dmabuf_ctx->has_linux_dmabuf = true;
         linux_dmabuf =
             wl_registry_bind(registry, name, &zwp_linux_dmabuf_v1_interface, 4);
         feedback = zwp_linux_dmabuf_v1_get_default_feedback(linux_dmabuf);
         zwp_linux_dmabuf_feedback_v1_add_listener(feedback, &feedback_listener, data);
         zwp_linux_dmabuf_v1_destroy(linux_dmabuf);
     }
 }

 static void
 registry_handle_global_remove(
     void               *data,
     struct wl_registry *registry,
     uint32_t            name
 )
 {
 }

 static const struct wl_registry_listener registry_listener = {
     .global        = registry_handle_global,
     .global_remove = registry_handle_global_remove,
 };

 static VAStatus
 va_DisplayContextGetDriverNames(
     VADisplayContextP pDisplayContext,
     char            **drivers,
     unsigned         *num_drivers
 )
 {
     VADriverContextP const ctx = pDisplayContext->pDriverContext;

     return VA_DRM_GetDriverNames(ctx, drivers, num_drivers);
 }

 bool
 va_wayland_linux_dmabuf_create(VADisplayContextP pDisplayContext)
 {
     bool result = false;
     VADriverContextP const ctx = pDisplayContext->pDriverContext;
     struct VADriverVTableWayland *vtable = ctx->vtable_wayland;
     struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx;
     struct drm_state *drm_state;
     struct wl_event_queue *queue = NULL;
     struct wl_display *display = NULL;
     struct wl_registry *registry = NULL;

     wl_linux_dmabuf_ctx = calloc(1, sizeof(*wl_linux_dmabuf_ctx));
     if (!wl_linux_dmabuf_ctx) {
         va_wayland_error("could not allocate wl_linux_dmabuf_ctx");
         goto end;
     }
     wl_linux_dmabuf_ctx->base.destroy = va_wayland_linux_dmabuf_destroy;
     pDisplayContext->opaque           = wl_linux_dmabuf_ctx;
     pDisplayContext->vaGetDriverNames = va_DisplayContextGetDriverNames;

     drm_state = calloc(1, sizeof(*drm_state));
     if (!drm_state) {
         va_wayland_error("could not allocate drm_state");
         goto end;
     }
     drm_state->fd        = -1;
     drm_state->auth_type = 0;
     ctx->drm_state       = drm_state;

     vtable->has_prime_sharing = 0;

     /* Use wrapped wl_display with private event queue to prevent
      * thread safety issues with applications that e.g. run an event pump
      * parallel to libva initialization.
      * Using the default queue, events might get lost and crashes occur
      * because wl_display_roundtrip is not thread-safe with respect to the
      * same queue.
      */
     queue = wl_display_create_queue(ctx->native_dpy);
     if (!queue) {
         va_wayland_error("could not create Wayland event queue");
         goto end;
     }

     display = wl_proxy_create_wrapper(ctx->native_dpy);
     if (!display) {
         va_wayland_error("could not create Wayland proxy wrapper");
         goto end;
     }
     wl_proxy_set_queue((struct wl_proxy *) display, queue);

     registry = wl_display_get_registry(display);
     if (!registry) {
         va_wayland_error("could not create wl_registry");
         goto end;
     }
     wl_registry_add_listener(registry, &registry_listener, pDisplayContext);

     if (wl_display_roundtrip_queue(ctx->native_dpy, queue) < 0) {
         va_wayland_error("failed to roundtrip Wayland queue");
         goto end;
     }

     if (!wl_linux_dmabuf_ctx->has_linux_dmabuf)
         goto end;

     while (!wl_linux_dmabuf_ctx->default_feedback_done) {
         if (wl_display_dispatch_queue(ctx->native_dpy, queue) < 0) {
             va_wayland_error("failed to dispatch Wayland queue");
             goto end;
         }
     }

     if (drm_state->fd < 0)
         goto end;

     result = true;
     vtable->has_prime_sharing = true;

 end:
     if (registry)
         wl_registry_destroy(registry);
     if (display)
         wl_proxy_wrapper_destroy(display);
     if (queue)
         wl_event_queue_destroy(queue);
     return result;
 }

 void
 va_wayland_linux_dmabuf_destroy(VADisplayContextP pDisplayContext)
 {
     VADriverContextP const ctx = pDisplayContext->pDriverContext;
     struct drm_state * const drm_state = ctx->drm_state;
     struct VADriverVTableWayland *vtable = ctx->vtable_wayland;

     vtable->has_prime_sharing = 0;

     if (drm_state) {
         if (drm_state->fd >= 0) {
             close(drm_state->fd);
             drm_state->fd = -1;
         }
         free(ctx->drm_state);
         ctx->drm_state = NULL;
     }
 }
	/*
	* va_wayland_drm.c - Wayland/linux-dmabuf helpers
	*
	* Copyright (c) 2024 Simon Ser
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sub license, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice (including the
	* next paragraph) shall be included in all copies or substantial portions
	* of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
	* IN NO EVENT SHALL INTEL AND/OR ITS SUPPLIERS BE LIABLE FOR
	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#include "sysdeps.h"
	#include <unistd.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <dlfcn.h>
	#include <sys/stat.h>
	#include <xf86drm.h>
	#include "va_drmcommon.h"
	#include "drm/va_drm_utils.h"
	#include "va_wayland_linux_dmabuf.h"
	#include "va_wayland_private.h"
	#include "linux-dmabuf-v1-client-protocol.h"

	typedef struct va_wayland_linux_dmabuf_context {
	struct va_wayland_context base;
	bool has_linux_dmabuf;
	bool default_feedback_done;
	} VADisplayContextWaylandLinuxDmabuf;

	static void
	feedback_handle_done(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback
	)
	{
	VADisplayContextP const pDisplayContext = data;
	struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx = pDisplayContext->opaque;

	wl_linux_dmabuf_ctx->default_feedback_done = true;

	zwp_linux_dmabuf_feedback_v1_destroy(feedback);
	}

	static void
	feedback_handle_format_table(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback,
	int fd,
	uint32_t size
	)
	{
	close(fd);
	}

	/* XXX: replace with drmGetDeviceFromDevId() */
	static drmDevice *
	get_drm_device_from_dev_id(dev_t dev_id)
	{
	uint32_t flags = 0;
	int devices_len, i, node_type;
	drmDevice match = NULL, dev;
	struct stat statbuf;

	devices_len = drmGetDevices2(flags, NULL, 0);
	if (devices_len < 0) {
	return NULL;
	}
	drmDevice *devices = calloc(devices_len, sizeof(devices));
	if (devices == NULL) {
	return NULL;
	}
	devices_len = drmGetDevices2(flags, devices, devices_len);
	if (devices_len < 0) {
	free(devices);
	return NULL;
	}

	for (i = 0; i < devices_len; i++) {
	dev = devices[i];
	for (node_type = 0; node_type < DRM_NODE_MAX; node_type++) {
	if (!(dev->available_nodes & (1 << node_type)))
	continue;

	if (stat(dev->nodes[node_type], &statbuf) != 0) {
	va_wayland_error("stat() failed for %s", dev->nodes[node_type]);
	continue;
	}

	if (statbuf.st_rdev == dev_id) {
	match = dev;
	break;
	}
	}
	}

	for (i = 0; i < devices_len; i++) {
	dev = devices[i];
	if (dev != match)
	drmFreeDevice(&dev);
	}
	free(devices);

	return match;
	}

	static void
	feedback_handle_main_device(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback,
	struct wl_array *device_array
	)
	{
	dev_t dev_id;
	drmDevice *dev;
	const char *dev_path;
	VADisplayContextP const pDisplayContext = data;
	VADriverContextP const ctx = pDisplayContext->pDriverContext;
	struct drm_state * const drm_state = ctx->drm_state;

	assert(device_array->size == sizeof(dev_id));
	memcpy(&dev_id, device_array->data, sizeof(dev_id));

	dev = get_drm_device_from_dev_id(dev_id);
	if (!dev) {
	va_wayland_error("failed to get DRM device from device ID");
	return;
	}

	if (!(dev->available_nodes & (1 << DRM_NODE_RENDER)))
	goto end;

	dev_path = dev->nodes[DRM_NODE_RENDER];
	drm_state->fd = open(dev_path, O_RDWR \| O_CLOEXEC);
	if (drm_state->fd < 0) {
	va_wayland_error("failed to open %s", dev_path);
	goto end;
	}

	drm_state->auth_type = VA_DRM_AUTH_CUSTOM;

	end:
	drmFreeDevice(&dev);
	}

	static void
	feedback_handle_tranche_done(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback
	)
	{
	}

	static void
	feedback_handle_tranche_target_device(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback,
	struct wl_array *device_array
	)
	{
	}

	static void
	feedback_handle_tranche_formats(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback,
	struct wl_array *indices_array
	)
	{
	}

	static void
	feedback_handle_tranche_flags(
	void *data,
	struct zwp_linux_dmabuf_feedback_v1 *feedback,
	uint32_t flags
	)
	{
	}

	static const struct zwp_linux_dmabuf_feedback_v1_listener feedback_listener = {
	.done = feedback_handle_done,
	.format_table = feedback_handle_format_table,
	.main_device = feedback_handle_main_device,
	.tranche_done = feedback_handle_tranche_done,
	.tranche_target_device = feedback_handle_tranche_target_device,
	.tranche_formats = feedback_handle_tranche_formats,
	.tranche_flags = feedback_handle_tranche_flags,
	};

	static void
	registry_handle_global(
	void *data,
	struct wl_registry *registry,
	uint32_t name,
	const char *interface,
	uint32_t version
	)
	{
	VADisplayContextP const pDisplayContext = data;
	struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx = pDisplayContext->opaque;
	struct zwp_linux_dmabuf_v1 *linux_dmabuf;
	struct zwp_linux_dmabuf_feedback_v1 *feedback;

	if (strcmp(interface, zwp_linux_dmabuf_v1_interface.name) == 0 &&
	version >= 4) {
	wl_linux_dmabuf_ctx->has_linux_dmabuf = true;
	linux_dmabuf =
	wl_registry_bind(registry, name, &zwp_linux_dmabuf_v1_interface, 4);
	feedback = zwp_linux_dmabuf_v1_get_default_feedback(linux_dmabuf);
	zwp_linux_dmabuf_feedback_v1_add_listener(feedback, &feedback_listener, data);
	zwp_linux_dmabuf_v1_destroy(linux_dmabuf);
	}
	}

	static void
	registry_handle_global_remove(
	void *data,
	struct wl_registry *registry,
	uint32_t name
	)
	{
	}

	static const struct wl_registry_listener registry_listener = {
	.global = registry_handle_global,
	.global_remove = registry_handle_global_remove,
	};

	static VAStatus
	va_DisplayContextGetDriverNames(
	VADisplayContextP pDisplayContext,
	char **drivers,
	unsigned *num_drivers
	)
	{
	VADriverContextP const ctx = pDisplayContext->pDriverContext;

	return VA_DRM_GetDriverNames(ctx, drivers, num_drivers);
	}

	bool
	va_wayland_linux_dmabuf_create(VADisplayContextP pDisplayContext)
	{
	bool result = false;
	VADriverContextP const ctx = pDisplayContext->pDriverContext;
	struct VADriverVTableWayland *vtable = ctx->vtable_wayland;
	struct va_wayland_linux_dmabuf_context *wl_linux_dmabuf_ctx;
	struct drm_state *drm_state;
	struct wl_event_queue *queue = NULL;
	struct wl_display *display = NULL;
	struct wl_registry *registry = NULL;

	wl_linux_dmabuf_ctx = calloc(1, sizeof(*wl_linux_dmabuf_ctx));
	if (!wl_linux_dmabuf_ctx) {
	va_wayland_error("could not allocate wl_linux_dmabuf_ctx");
	goto end;
	}
	wl_linux_dmabuf_ctx->base.destroy = va_wayland_linux_dmabuf_destroy;
	pDisplayContext->opaque = wl_linux_dmabuf_ctx;
	pDisplayContext->vaGetDriverNames = va_DisplayContextGetDriverNames;

	drm_state = calloc(1, sizeof(*drm_state));
	if (!drm_state) {
	va_wayland_error("could not allocate drm_state");
	goto end;
	}
	drm_state->fd = -1;
	drm_state->auth_type = 0;
	ctx->drm_state = drm_state;

	vtable->has_prime_sharing = 0;

	/* Use wrapped wl_display with private event queue to prevent
	* thread safety issues with applications that e.g. run an event pump
	* parallel to libva initialization.
	* Using the default queue, events might get lost and crashes occur
	* because wl_display_roundtrip is not thread-safe with respect to the
	* same queue.
	*/
	queue = wl_display_create_queue(ctx->native_dpy);
	if (!queue) {
	va_wayland_error("could not create Wayland event queue");
	goto end;
	}

	display = wl_proxy_create_wrapper(ctx->native_dpy);
	if (!display) {
	va_wayland_error("could not create Wayland proxy wrapper");
	goto end;
	}
	wl_proxy_set_queue((struct wl_proxy *) display, queue);

	registry = wl_display_get_registry(display);
	if (!registry) {
	va_wayland_error("could not create wl_registry");
	goto end;
	}
	wl_registry_add_listener(registry, &registry_listener, pDisplayContext);

	if (wl_display_roundtrip_queue(ctx->native_dpy, queue) < 0) {
	va_wayland_error("failed to roundtrip Wayland queue");
	goto end;
	}

	if (!wl_linux_dmabuf_ctx->has_linux_dmabuf)
	goto end;

	while (!wl_linux_dmabuf_ctx->default_feedback_done) {
	if (wl_display_dispatch_queue(ctx->native_dpy, queue) < 0) {
	va_wayland_error("failed to dispatch Wayland queue");
	goto end;
	}
	}

	if (drm_state->fd < 0)
	goto end;

	result = true;
	vtable->has_prime_sharing = true;

	end:
	if (registry)
	wl_registry_destroy(registry);
	if (display)
	wl_proxy_wrapper_destroy(display);
	if (queue)
	wl_event_queue_destroy(queue);
	return result;
	}

	void
	va_wayland_linux_dmabuf_destroy(VADisplayContextP pDisplayContext)
	{
	VADriverContextP const ctx = pDisplayContext->pDriverContext;
	struct drm_state * const drm_state = ctx->drm_state;
	struct VADriverVTableWayland *vtable = ctx->vtable_wayland;

	vtable->has_prime_sharing = 0;

	if (drm_state) {
	if (drm_state->fd >= 0) {
	close(drm_state->fd);
	drm_state->fd = -1;
	}
	free(ctx->drm_state);
	ctx->drm_state = NULL;
	}
	}