mirrors/monado
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/monado/monado.git synced 2024-12-29 11:06:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

xrt: Rename references to compositor/swapchain/image_fd to ..._native.

Browse source 
Reflecting that the native buffer isn't an FD on all platforms.
This commit is contained in:
Ryan Pavlik 2020-07-14 17:13:07 -05:00
parent 92e4b24b8f
commit 54f56716fd
31 changed files with 290 additions and 279 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
src/xrt/auxiliary/vk/vk_helpers.c
View file

@ -265,16 +265,16 @@ vk_create_image_simple(struct vk_bundle *vk,
}
VkResult
vk_create_image_from_fd(struct vk_bundle *vk,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
struct xrt_image_fd *image_fd,
VkImage *out_image,
VkDeviceMemory *out_mem)
vk_create_image_from_native(struct vk_bundle *vk,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
struct xrt_image_native *image_native,
VkImage *out_image,
VkDeviceMemory *out_mem)
{
VkImageUsageFlags image_usage =
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
@ -327,7 +327,7 @@ vk_create_image_from_fd(struct vk_bundle *vk,
VkImportMemoryFdInfoKHR import_memory_info = {
.sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
.fd = image_fd->fd,
.fd = image_native->fd,
};
VkMemoryDedicatedAllocateInfoKHR dedicated_memory_info = {
.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
@ -335,8 +335,9 @@ vk_create_image_from_fd(struct vk_bundle *vk,
.image = image,
.buffer = VK_NULL_HANDLE,
};
ret = vk_alloc_and_bind_image_memory(
vk, image, image_fd->size, &dedicated_memory_info, out_mem, NULL);
ret = vk_alloc_and_bind_image_memory(vk, image, image_native->size,
&dedicated_memory_info, out_mem,
NULL);
if (ret != VK_SUCCESS) {
vk->vkDestroyImage(vk->device, image, NULL);
return ret;

20
src/xrt/auxiliary/vk/vk_helpers.h
View file

@ -343,16 +343,16 @@ vk_alloc_and_bind_image_memory(struct vk_bundle *vk,
* @ingroup aux_vk
*/
VkResult
vk_create_image_from_fd(struct vk_bundle *vk,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
struct xrt_image_fd *image_fd,
VkImage *out_image,
VkDeviceMemory *out_mem);
vk_create_image_from_native(struct vk_bundle *vk,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
struct xrt_image_native *image_native,
VkImage *out_image,
VkDeviceMemory *out_mem);
/*!
* @ingroup aux_vk

8
src/xrt/compositor/client/comp_egl_glue.c
View file

@ -30,13 +30,13 @@ static void
client_egl_compositor_destroy(struct xrt_compositor *xc)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
xrt_comp_fd_destroy(&c->xcfd);
// Pipe down call into native compositor.
xrt_comp_native_destroy(&c->xcn);
free(c);
}
struct xrt_compositor_gl *
xrt_gfx_provider_create_gl_egl(struct xrt_compositor_fd *xcfd,
xrt_gfx_provider_create_gl_egl(struct xrt_compositor_native *xcn,
EGLDisplay display,
EGLConfig config,
EGLContext context,
@ -57,7 +57,7 @@ xrt_gfx_provider_create_gl_egl(struct xrt_compositor_fd *xcfd,
struct client_gl_compositor *c =
U_TYPED_CALLOC(struct client_gl_compositor);
if (!client_gl_compositor_init(c, xcfd, getProcAddress)) {
if (!client_gl_compositor_init(c, xcn, getProcAddress)) {
free(c);
fprintf(stderr, "Failed to initialize compositor\n");
return NULL;

90
src/xrt/compositor/client/comp_gl_client.c
View file

@ -49,8 +49,8 @@ client_gl_swapchain_destroy(struct xrt_swapchain *xsc)
sc->base.base.num_images = 0;
}
// Destroy the fd swapchain as well.
xrt_swapchain_destroy((struct xrt_swapchain **)&sc->xscfd);
// Destroy the native swapchain as well.
xrt_swapchain_destroy((struct xrt_swapchain **)&sc->xscn);
free(sc);
}
@ -61,8 +61,8 @@ client_gl_swapchain_acquire_image(struct xrt_swapchain *xsc,
{
struct client_gl_swapchain *sc = client_gl_swapchain(xsc);
// Pipe down call into fd swapchain.
return xrt_swapchain_acquire_image(&sc->xscfd->base, out_index);
// Pipe down call into native swapchain.
return xrt_swapchain_acquire_image(&sc->xscn->base, out_index);
}
static xrt_result_t
@ -72,8 +72,8 @@ client_gl_swapchain_wait_image(struct xrt_swapchain *xsc,
{
struct client_gl_swapchain *sc = client_gl_swapchain(xsc);
// Pipe down call into fd swapchain.
return xrt_swapchain_wait_image(&sc->xscfd->base, timeout, index);
// Pipe down call into native swapchain.
return xrt_swapchain_wait_image(&sc->xscn->base, timeout, index);
}
static xrt_result_t
@ -81,8 +81,8 @@ client_gl_swapchain_release_image(struct xrt_swapchain *xsc, uint32_t index)
{
struct client_gl_swapchain *sc = client_gl_swapchain(xsc);
// Pipe down call into fd swapchain.
return xrt_swapchain_release_image(&sc->xscfd->base, index);
// Pipe down call into native swapchain.
return xrt_swapchain_release_image(&sc->xscn->base, index);
}
@ -98,8 +98,8 @@ client_gl_compositor_prepare_session(struct xrt_compositor *xc,
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_prepare_session(&c->xcfd->base, xspi);
// Pipe down call into native compositor.
return xrt_comp_prepare_session(&c->xcn->base, xspi);
}
@ -109,8 +109,8 @@ client_gl_compositor_begin_session(struct xrt_compositor *xc,
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_begin_session(&c->xcfd->base, type);
// Pipe down call into native compositor.
return xrt_comp_begin_session(&c->xcn->base, type);
}
static xrt_result_t
@ -118,8 +118,8 @@ client_gl_compositor_end_session(struct xrt_compositor *xc)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_end_session(&c->xcfd->base);
// Pipe down call into native compositor.
return xrt_comp_end_session(&c->xcn->base);
}
static xrt_result_t
@ -130,8 +130,8 @@ client_gl_compositor_wait_frame(struct xrt_compositor *xc,
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_wait_frame(&c->xcfd->base, out_frame_id,
// Pipe down call into native compositor.
return xrt_comp_wait_frame(&c->xcn->base, out_frame_id,
predicted_display_time,
predicted_display_period);
}
@ -141,8 +141,8 @@ client_gl_compositor_begin_frame(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_begin_frame(&c->xcfd->base, frame_id);
// Pipe down call into native compositor.
return xrt_comp_begin_frame(&c->xcn->base, frame_id);
}
static xrt_result_t
@ -150,8 +150,8 @@ client_gl_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_discard_frame(&c->xcfd->base, frame_id);
// Pipe down call into native compositor.
return xrt_comp_discard_frame(&c->xcn->base, frame_id);
}
static xrt_result_t
@ -161,7 +161,7 @@ client_gl_compositor_layer_begin(struct xrt_compositor *xc,
{
struct client_gl_compositor *c = client_gl_compositor(xc);
return xrt_comp_layer_begin(&c->xcfd->base, frame_id, env_blend_mode);
return xrt_comp_layer_begin(&c->xcn->base, frame_id, env_blend_mode);
}
static xrt_result_t
@ -172,16 +172,16 @@ client_gl_compositor_layer_stereo_projection(struct xrt_compositor *xc,
struct xrt_layer_data *data)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
struct xrt_swapchain *l_xscfd, *r_xscfd;
struct xrt_swapchain *l_xscn, *r_xscn;
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
l_xscfd = &client_gl_swapchain(l_xsc)->xscfd->base;
r_xscfd = &client_gl_swapchain(r_xsc)->xscfd->base;
l_xscn = &client_gl_swapchain(l_xsc)->xscn->base;
r_xscn = &client_gl_swapchain(r_xsc)->xscn->base;
data->flip_y = true;
return xrt_comp_layer_stereo_projection(&c->xcfd->base, xdev, l_xscfd,
r_xscfd, data);
return xrt_comp_layer_stereo_projection(&c->xcn->base, xdev, l_xscn,
r_xscn, data);
}
static xrt_result_t
@ -195,10 +195,10 @@ client_gl_compositor_layer_quad(struct xrt_compositor *xc,
assert(data->type == XRT_LAYER_QUAD);
xscfb = &client_gl_swapchain(xsc)->xscfd->base;
xscfb = &client_gl_swapchain(xsc)->xscn->base;
data->flip_y = true;
return xrt_comp_layer_quad(&c->xcfd->base, xdev, xscfb, data);
return xrt_comp_layer_quad(&c->xcn->base, xdev, xscfb, data);
}
static xrt_result_t
@ -206,7 +206,7 @@ client_gl_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_gl_compositor *c = client_gl_compositor(xc);
return xrt_comp_layer_commit(&c->xcfd->base, frame_id);
return xrt_comp_layer_commit(&c->xcn->base, frame_id);
}
static int64_t
@ -264,14 +264,14 @@ client_gl_swapchain_create(struct xrt_compositor *xc,
struct xrt_swapchain_create_info vk_info = *info;
vk_info.format = vk_format;
struct xrt_swapchain_fd *xscfd =
xrt_comp_fd_create_swapchain(c->xcfd, &vk_info);
struct xrt_swapchain_native *xscn =
xrt_comp_native_create_swapchain(c->xcn, &vk_info);
if (xscfd == NULL) {
if (xscn == NULL) {
return NULL;
}
struct xrt_swapchain *xsc = &xscfd->base;
struct xrt_swapchain *xsc = &xscn->base;
struct client_gl_swapchain *sc =
U_TYPED_CALLOC(struct client_gl_swapchain);
@ -279,9 +279,9 @@ client_gl_swapchain_create(struct xrt_compositor *xc,
sc->base.base.acquire_image = client_gl_swapchain_acquire_image;
sc->base.base.wait_image = client_gl_swapchain_wait_image;
sc->base.base.release_image = client_gl_swapchain_release_image;
// Fetch the number of images from the fd swapchain.
// Fetch the number of images from the native swapchain.
sc->base.base.num_images = xsc->num_images;
sc->xscfd = xscfd;
sc->xscn = xscn;
GLuint prev_texture = 0;
glGetIntegerv(info->array_size == 1 ? GL_TEXTURE_BINDING_2D
@ -300,12 +300,12 @@ client_gl_swapchain_create(struct xrt_compositor *xc,
glMemoryObjectParameterivEXT(sc->base.memory[i],
GL_DEDICATED_MEMORY_OBJECT_EXT,
&dedicated);
glImportMemoryFdEXT(sc->base.memory[i], xscfd->images[i].size,
glImportMemoryFdEXT(sc->base.memory[i], xscn->images[i].size,
GL_HANDLE_TYPE_OPAQUE_FD_EXT,
xscfd->images[i].fd);
xscn->images[i].fd);
// We have consumed this fd now, make sure it's not freed again.
xscfd->images[i].fd = -1;
xscn->images[i].fd = -1;
if (info->array_size == 1) {
glTextureStorageMem2DEXT(
@ -333,8 +333,8 @@ client_gl_compositor_poll_events(struct xrt_compositor *xc,
{
struct client_gl_compositor *c = client_gl_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_poll_events(&c->xcfd->base, out_xce);
// Pipe down call into native compositor.
return xrt_comp_poll_events(&c->xcn->base, out_xce);
}
static void
@ -345,7 +345,7 @@ client_gl_compositor_destroy(struct xrt_compositor *xc)
bool
client_gl_compositor_init(struct client_gl_compositor *c,
struct xrt_compositor_fd *xcfd,
struct xrt_compositor_native *xcn,
client_gl_get_procaddr get_gl_procaddr)
{
c->base.base.create_swapchain = client_gl_swapchain_create;
@ -362,12 +362,12 @@ client_gl_compositor_init(struct client_gl_compositor *c,
c->base.base.layer_commit = client_gl_compositor_layer_commit;
c->base.base.destroy = client_gl_compositor_destroy;
c->base.base.poll_events = client_gl_compositor_poll_events;
c->xcfd = xcfd;
c->xcn = xcn;
// Passthrough our formats from the fd compositor to the client.
// Passthrough our formats from the native compositor to the client.
size_t count = 0;
for (uint32_t i = 0; i < xcfd->base.num_formats; i++) {
int64_t f = vk_format_to_gl(xcfd->base.formats[i]);
for (uint32_t i = 0; i < xcn->base.num_formats; i++) {
int64_t f = vk_format_to_gl(xcn->base.formats[i]);
if (f == 0) {
continue;
}

10
src/xrt/compositor/client/comp_gl_client.h
View file

@ -36,7 +36,7 @@ struct client_gl_swapchain
{
struct xrt_swapchain_gl base;
struct xrt_swapchain_fd *xscfd;
struct xrt_swapchain_native *xscn;
};
/*!
@ -51,7 +51,7 @@ struct client_gl_compositor
{
struct xrt_compositor_gl base;
struct xrt_compositor_fd *xcfd;
struct xrt_compositor_native *xcn;
};
@ -82,14 +82,14 @@ typedef client_gl_void_ptr_func (*client_gl_get_procaddr)(const char *name);
* OpenGL can have multiple backing window systems we have to interact with, so
* there isn't just one unified OpenGL client constructor.
*
* Moves owenership of provided xcfd to the client_gl_compositor.
* Moves ownership of provided xcn to the client_gl_compositor.
*
* @public @memberof client_gl_compositor
* @relatesalso xrt_compositor_fd
* @relatesalso xrt_compositor_native
*/
bool
client_gl_compositor_init(struct client_gl_compositor *c,
struct xrt_compositor_fd *xcfd,
struct xrt_compositor_native *xcn,
client_gl_get_procaddr get_gl_procaddr);

8
src/xrt/compositor/client/comp_gl_xlib_client.c
View file

@ -32,8 +32,8 @@ static void
client_gl_xlib_compositor_destroy(struct xrt_compositor *xc)
{
struct client_gl_xlib_compositor *c = client_gl_xlib_compositor(xc);
// Pipe down call into fd compositor.
xrt_comp_fd_destroy(&c->base.xcfd);
// Pipe down call into native compositor.
xrt_comp_native_destroy(&c->base.xcn);
free(c);
}
@ -46,7 +46,7 @@ extern "C"
glXGetProcAddress(const char *procName);
struct client_gl_xlib_compositor *
client_gl_xlib_compositor_create(struct xrt_compositor_fd *xcfd,
client_gl_xlib_compositor_create(struct xrt_compositor_native *xcn,
Display *xDisplay,
uint32_t visualid,
GLXFBConfig glxFBConfig,
@ -56,7 +56,7 @@ client_gl_xlib_compositor_create(struct xrt_compositor_fd *xcfd,
struct client_gl_xlib_compositor *c =
U_TYPED_CALLOC(struct client_gl_xlib_compositor);
if (!client_gl_compositor_init(&c->base, xcfd, glXGetProcAddress)) {
if (!client_gl_compositor_init(&c->base, xcn, glXGetProcAddress)) {
free(c);
return NULL;
}

4
src/xrt/compositor/client/comp_gl_xlib_client.h
View file

@ -34,10 +34,10 @@ struct client_gl_xlib_compositor
* Create a new client_gl_xlib_compositor.
*
* @public @memberof client_gl_xlib_compositor
* @relatesalso xrt_compositor_fd
* @relatesalso xrt_compositor_native
*/
struct client_gl_xlib_compositor *
client_gl_xlib_compositor_create(struct xrt_compositor_fd *xcfd,
client_gl_xlib_compositor_create(struct xrt_compositor_native *xcn,
Display *xDisplay,
uint32_t visualid,
GLXFBConfig glxFBConfig,

4
src/xrt/compositor/client/comp_gl_xlib_glue.c
View file

@ -16,7 +16,7 @@
struct xrt_compositor_gl *
xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_fd *xcfd,
xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_native *xcn,
Display *xDisplay,
uint32_t visualid,
GLXFBConfig glxFBConfig,
@ -25,7 +25,7 @@ xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_fd *xcfd,
{
struct client_gl_xlib_compositor *xcc =
client_gl_xlib_compositor_create(
xcfd, xDisplay, visualid, glxFBConfig, glxDrawable, glxContext);
xcn, xDisplay, visualid, glxFBConfig, glxDrawable, glxContext);
return &xcc->base.base;
}

96
src/xrt/compositor/client/comp_vk_client.c
View file

@ -64,8 +64,8 @@ client_vk_swapchain_destroy(struct xrt_swapchain *xsc)
}
}
// Destroy the fd swapchain as well.
xrt_swapchain_destroy((struct xrt_swapchain **)&sc->xscfd);
// Destroy the native swapchain as well.
xrt_swapchain_destroy((struct xrt_swapchain **)&sc->xscn);
free(sc);
}
@ -77,9 +77,9 @@ client_vk_swapchain_acquire_image(struct xrt_swapchain *xsc,
struct client_vk_swapchain *sc = client_vk_swapchain(xsc);
struct vk_bundle *vk = &sc->c->vk;
// Pipe down call into fd swapchain.
// Pipe down call into native swapchain.
xrt_result_t xret =
xrt_swapchain_acquire_image(&sc->xscfd->base, out_index);
xrt_swapchain_acquire_image(&sc->xscn->base, out_index);
if (xret != XRT_SUCCESS) {
return xret;
}
@ -106,8 +106,8 @@ client_vk_swapchain_wait_image(struct xrt_swapchain *xsc,
{
struct client_vk_swapchain *sc = client_vk_swapchain(xsc);
// Pipe down call into fd swapchain.
return xrt_swapchain_wait_image(&sc->xscfd->base, timeout, index);
// Pipe down call into native swapchain.
return xrt_swapchain_wait_image(&sc->xscn->base, timeout, index);
}
static xrt_result_t
@ -129,8 +129,8 @@ client_vk_swapchain_release_image(struct xrt_swapchain *xsc, uint32_t index)
return XRT_ERROR_FAILED_TO_SUBMIT_VULKAN_COMMANDS;
}
// Pipe down call into fd swapchain.
return xrt_swapchain_release_image(&sc->xscfd->base, index);
// Pipe down call into native swapchain.
return xrt_swapchain_release_image(&sc->xscn->base, index);
}
@ -146,8 +146,8 @@ client_vk_compositor_poll_events(struct xrt_compositor *xc,
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_poll_events(&c->xcfd->base, out_xce);
// Pipe down call into native compositor.
return xrt_comp_poll_events(&c->xcn->base, out_xce);
}
static void
@ -164,8 +164,8 @@ client_vk_compositor_destroy(struct xrt_compositor *xc)
c->vk.cmd_pool = VK_NULL_HANDLE;
}
// Pipe down call into fd compositor.
xrt_comp_fd_destroy(&c->xcfd);
// Pipe down call into native compositor.
xrt_comp_native_destroy(&c->xcn);
free(c);
}
@ -175,8 +175,8 @@ client_vk_compositor_prepare_session(struct xrt_compositor *xc,
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_prepare_session(&c->xcfd->base, xspi);
// Pipe down call into native compositor.
return xrt_comp_prepare_session(&c->xcn->base, xspi);
}
static xrt_result_t
@ -185,8 +185,8 @@ client_vk_compositor_begin_session(struct xrt_compositor *xc,
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_begin_session(&c->xcfd->base, type);
// Pipe down call into native compositor.
return xrt_comp_begin_session(&c->xcn->base, type);
}
static xrt_result_t
@ -194,8 +194,8 @@ client_vk_compositor_end_session(struct xrt_compositor *xc)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_end_session(&c->xcfd->base);
// Pipe down call into native compositor.
return xrt_comp_end_session(&c->xcn->base);
}
static xrt_result_t
@ -206,8 +206,8 @@ client_vk_compositor_wait_frame(struct xrt_compositor *xc,
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_wait_frame(&c->xcfd->base, out_frame_id,
// Pipe down call into native compositor.
return xrt_comp_wait_frame(&c->xcn->base, out_frame_id,
predicted_display_time,
predicted_display_period);
}
@ -217,8 +217,8 @@ client_vk_compositor_begin_frame(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_begin_frame(&c->xcfd->base, frame_id);
// Pipe down call into native compositor.
return xrt_comp_begin_frame(&c->xcn->base, frame_id);
}
static xrt_result_t
@ -226,8 +226,8 @@ client_vk_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
// Pipe down call into fd compositor.
return xrt_comp_discard_frame(&c->xcfd->base, frame_id);
// Pipe down call into native compositor.
return xrt_comp_discard_frame(&c->xcn->base, frame_id);
}
static xrt_result_t
@ -237,7 +237,7 @@ client_vk_compositor_layer_begin(struct xrt_compositor *xc,
{
struct client_vk_compositor *c = client_vk_compositor(xc);
return xrt_comp_layer_begin(&c->xcfd->base, frame_id, env_blend_mode);
return xrt_comp_layer_begin(&c->xcn->base, frame_id, env_blend_mode);
}
static xrt_result_t
@ -248,16 +248,16 @@ client_vk_compositor_layer_stereo_projection(struct xrt_compositor *xc,
struct xrt_layer_data *data)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
struct xrt_swapchain *l_xscfd, *r_xscfd;
struct xrt_swapchain *l_xscn, *r_xscn;
assert(data->type == XRT_LAYER_STEREO_PROJECTION);
l_xscfd = &client_vk_swapchain(l_xsc)->xscfd->base;
r_xscfd = &client_vk_swapchain(r_xsc)->xscfd->base;
l_xscn = &client_vk_swapchain(l_xsc)->xscn->base;
r_xscn = &client_vk_swapchain(r_xsc)->xscn->base;
data->flip_y = false;
return xrt_comp_layer_stereo_projection(&c->xcfd->base, xdev, l_xscfd,
r_xscfd, data);
return xrt_comp_layer_stereo_projection(&c->xcn->base, xdev, l_xscn,
r_xscn, data);
}
static xrt_result_t
@ -271,10 +271,10 @@ client_vk_compositor_layer_quad(struct xrt_compositor *xc,
assert(data->type == XRT_LAYER_QUAD);
xscfb = &client_vk_swapchain(xsc)->xscfd->base;
xscfb = &client_vk_swapchain(xsc)->xscn->base;
data->flip_y = false;
return xrt_comp_layer_quad(&c->xcfd->base, xdev, xscfb, data);
return xrt_comp_layer_quad(&c->xcn->base, xdev, xscfb, data);
}
static xrt_result_t
@ -282,7 +282,7 @@ client_vk_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id)
{
struct client_vk_compositor *c = client_vk_compositor(xc);
return xrt_comp_layer_commit(&c->xcfd->base, frame_id);
return xrt_comp_layer_commit(&c->xcn->base, frame_id);
}
static struct xrt_swapchain *
@ -293,13 +293,13 @@ client_vk_swapchain_create(struct xrt_compositor *xc,
VkCommandBuffer cmd_buffer;
VkResult ret;
struct xrt_swapchain_fd *xscfd =
xrt_comp_fd_create_swapchain(c->xcfd, info);
struct xrt_swapchain_native *xscn =
xrt_comp_native_create_swapchain(c->xcn, info);
if (xscfd == NULL) {
if (xscn == NULL) {
return NULL;
}
struct xrt_swapchain *xsc = &xscfd->base;
struct xrt_swapchain *xsc = &xscn->base;
ret = vk_init_cmd_buffer(&c->vk, &cmd_buffer);
if (ret != VK_SUCCESS) {
@ -320,19 +320,19 @@ client_vk_swapchain_create(struct xrt_compositor *xc,
sc->base.base.acquire_image = client_vk_swapchain_acquire_image;
sc->base.base.wait_image = client_vk_swapchain_wait_image;
sc->base.base.release_image = client_vk_swapchain_release_image;
// Fetch the number of images from the fd swapchain.
// Fetch the number of images from the native swapchain.
sc->base.base.num_images = xsc->num_images;
sc->c = c;
sc->xscfd = xscfd;
sc->xscn = xscn;
for (uint32_t i = 0; i < xsc->num_images; i++) {
ret = vk_create_image_from_fd(
ret = vk_create_image_from_native(
&c->vk, info->bits, info->format, info->width, info->height,
info->array_size, info->mip_count, &xscfd->images[i],
info->array_size, info->mip_count, &xscn->images[i],
&sc->base.images[i], &sc->base.mems[i]);
// We have consumed this fd now, make sure it's not freed again.
xscfd->images[i].fd = -1;
xscn->images[i].fd = -1;
if (ret != VK_SUCCESS) {
return NULL;
@ -443,7 +443,7 @@ client_vk_swapchain_create(struct xrt_compositor *xc,
}
struct client_vk_compositor *
client_vk_compositor_create(struct xrt_compositor_fd *xcfd,
client_vk_compositor_create(struct xrt_compositor_native *xcn,
VkInstance instance,
PFN_vkGetInstanceProcAddr getProc,
VkPhysicalDevice physicalDevice,
@ -470,13 +470,13 @@ client_vk_compositor_create(struct xrt_compositor_fd *xcfd,
c->base.base.destroy = client_vk_compositor_destroy;
c->base.base.poll_events = client_vk_compositor_poll_events;
c->xcfd = xcfd;
// passthrough our formats from the fd compositor to the client
for (uint32_t i = 0; i < xcfd->base.num_formats; i++) {
c->base.base.formats[i] = xcfd->base.formats[i];
c->xcn = xcn;
// passthrough our formats from the native compositor to the client
for (uint32_t i = 0; i < xcn->base.num_formats; i++) {
c->base.base.formats[i] = xcn->base.formats[i];
}
c->base.base.num_formats = xcfd->base.num_formats;
c->base.base.num_formats = xcn->base.num_formats;
ret = vk_init_from_given(&c->vk, getProc, instance, physicalDevice,
device, queueFamilyIndex, queueIndex);

14
src/xrt/compositor/client/comp_vk_client.h
View file

@ -38,8 +38,8 @@ struct client_vk_swapchain
{
struct xrt_swapchain_vk base;
//! Owning reference to the backing fd swapchain.
struct xrt_swapchain_fd *xscfd;
//! Owning reference to the backing native swapchain.
struct xrt_swapchain_native *xscn;
//! Non-owning reference to our parent compositor.
struct client_vk_compositor *c;
@ -57,8 +57,8 @@ struct client_vk_compositor
{
struct xrt_compositor_vk base;
//! Owning reference to the backing fd compositor
struct xrt_compositor_fd *xcfd;
//! Owning reference to the backing native compositor
struct xrt_compositor_native *xcn;
struct vk_bundle vk;
};
@ -74,13 +74,13 @@ struct client_vk_compositor
/*!
* Create a new client_vk_compositor.
*
* Takes owenership of provided xcfd.
* Takes owenership of provided xcn.
*
* @public @memberof client_vk_compositor
* @relatesalso xrt_compositor_fd
* @relatesalso xrt_compositor_native
*/
struct client_vk_compositor *
client_vk_compositor_create(struct xrt_compositor_fd *xcfd,
client_vk_compositor_create(struct xrt_compositor_native *xcn,
VkInstance instance,
PFN_vkGetInstanceProcAddr getProc,
VkPhysicalDevice physicalDevice,

4
src/xrt/compositor/client/comp_vk_glue.c
View file

@ -43,7 +43,7 @@ xrt_gfx_vk_get_versions(struct xrt_api_requirements *ver)
}
struct xrt_compositor_vk *
xrt_gfx_vk_provider_create(struct xrt_compositor_fd *xcfd,
xrt_gfx_vk_provider_create(struct xrt_compositor_native *xcn,
VkInstance instance,
PFN_vkGetInstanceProcAddr get_instance_proc_addr,
VkPhysicalDevice physical_device,
@ -52,7 +52,7 @@ xrt_gfx_vk_provider_create(struct xrt_compositor_fd *xcfd,
uint32_t queue_index)
{
struct client_vk_compositor *vcc = client_vk_compositor_create(
xcfd, instance, get_instance_proc_addr, physical_device, device,
xcn, instance, get_instance_proc_addr, physical_device, device,
queue_family_index, queue_index);
return &vcc->base;

4
src/xrt/compositor/main/comp_compositor.c
View file

@ -927,8 +927,8 @@ compositor_init_renderer(struct comp_compositor *c)
return c->r != NULL;
}
struct xrt_compositor_fd *
xrt_gfx_provider_create_fd(struct xrt_device *xdev, bool flip_y)
struct xrt_compositor_native *
xrt_gfx_provider_create_native(struct xrt_device *xdev, bool flip_y)
{
struct comp_compositor *c = U_TYPED_CALLOC(struct comp_compositor);

8
src/xrt/compositor/main/comp_compositor.h
View file

@ -64,12 +64,12 @@ struct comp_swapchain_image
* Not used by the window backend that uses the vk_swapchain to render to.
*
* @ingroup comp_main
* @implements xrt_swapchain_fd
* @implements xrt_swapchain_native
* @see comp_compositor
*/
struct comp_swapchain
{
struct xrt_swapchain_fd base;
struct xrt_swapchain_native base;
struct comp_compositor *c;
@ -136,11 +136,11 @@ enum comp_state
* Main compositor struct tying everything in the compositor together.
*
* @ingroup comp_main
* @implements xrt_compositor_fd
* @implements xrt_compositor_native
*/
struct comp_compositor
{
struct xrt_compositor_fd base;
struct xrt_compositor_native base;
//! A link back to the compositor we are presenting to the client.
struct xrt_compositor *client;

26
src/xrt/compositor/main/comp_swapchain.c
View file

@ -94,16 +94,16 @@ get_device_memory_fd(struct comp_compositor *c,
}
static VkResult
create_image_fd(struct comp_compositor *c,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
VkImage *out_image,
VkDeviceMemory *out_mem,
struct xrt_image_fd *out_image_fd)
create_image_native(struct comp_compositor *c,
enum xrt_swapchain_usage_bits swapchain_usage,
int64_t format,
uint32_t width,
uint32_t height,
uint32_t array_size,
uint32_t mip_count,
VkImage *out_image,
VkDeviceMemory *out_mem,
struct xrt_image_native *out_image_native)
{
VkImageUsageFlags image_usage =
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
@ -202,8 +202,8 @@ create_image_fd(struct comp_compositor *c,
*out_image = image;
*out_mem = device_memory;
out_image_fd->fd = fd;
out_image_fd->size = size;
out_image_native->fd = fd;
out_image_native->size = size;
return ret;
@ -251,7 +251,7 @@ comp_swapchain_create(struct xrt_compositor *xc,
}
for (uint32_t i = 0; i < num_images; i++) {
ret = create_image_fd(
ret = create_image_native(
c, info->bits, info->format, info->width, info->height,
info->array_size, info->mip_count, &sc->images[i].image,
&sc->images[i].memory, &sc->base.images[i]);

60
src/xrt/include/xrt/xrt_compositor.h
View file

@ -213,8 +213,9 @@ struct xrt_layer_data
* comp_compositor. It is overwritten by the various client
* implementations of the @ref xrt_compositor interface depending on the
* conventions of the associated graphics API. Other @ref
* xrt_compositor_fd implementations that are not the main compositor
* just pass this field along unchanged to the "real" compositor.
* xrt_compositor_native implementations that are not the main
* compositor just pass this field along unchanged to the "real"
* compositor.
*/
bool flip_y;
@ -860,17 +861,20 @@ xrt_compositor_vk(struct xrt_compositor *xc)
/*
*
* FD interface, aka DMABUF.
* Native interface.
*
* These types are supported by underlying native buffers, which are DMABUF file
* descriptors on Linux.
*
*/
/*!
* A single image of a fd based swapchain.
* A single image of a swapchain based on native buffer handles.
*
* @ingroup xrt_iface comp
* @see xrt_swapchain_fd
* @see xrt_swapchain_native
*/
struct xrt_image_fd
struct xrt_image_native
{
size_t size;
int fd;
@ -878,72 +882,72 @@ struct xrt_image_fd
};
/*!
* @interface xrt_swapchain_fd
* Base class for a swapchain that exposes fd to be imported into a client API.
* @interface xrt_swapchain_native
* Base class for a swapchain that exposes a native buffer handle to be imported
* into a client API.
*
* @ingroup xrt_iface comp
* @extends xrt_swapchain
*/
struct xrt_swapchain_fd
struct xrt_swapchain_native
{
//! @public Base
struct xrt_swapchain base;
struct xrt_image_fd images[XRT_MAX_SWAPCHAIN_IMAGES];
struct xrt_image_native images[XRT_MAX_SWAPCHAIN_IMAGES];
};
/*!
* @interface xrt_compositor_fd
* @interface xrt_compositor_native
*
* Main compositor server interface.
*
* @ingroup xrt_iface comp
* @extends xrt_compositor
*/
struct xrt_compositor_fd
struct xrt_compositor_native
{
//! @public Base
struct xrt_compositor base;
};
/*!
* @brief Create an FD swapchain with a set of images.
* @brief Create a native swapchain with a set of images.
*
* A specialized version of @ref xrt_comp_create_swapchain, for use only on @ref
* xrt_compositor_fd.
* xrt_compositor_native.
*
* Helper for calling through the base's function pointer then performing the
* known-safe downcast.
*
* @public @memberof xrt_compositor_fd
* @public @memberof xrt_compositor_native
*/
static inline struct xrt_swapchain_fd *
xrt_comp_fd_create_swapchain(struct xrt_compositor_fd *xcfd,
struct xrt_swapchain_create_info *info)
static inline struct xrt_swapchain_native *
xrt_comp_native_create_swapchain(struct xrt_compositor_native *xcn,
struct xrt_swapchain_create_info *info)
{
struct xrt_swapchain *xsc =
xrt_comp_create_swapchain(&xcfd->base, info);
return (struct xrt_swapchain_fd *)xsc;
struct xrt_swapchain *xsc = xrt_comp_create_swapchain(&xcn->base, info);
return (struct xrt_swapchain_native *)xsc;
}
/*!
* @copydoc xrt_compositor::destroy
*
* Helper for calling through the function pointer: does a null check and sets
* xcfd_ptr to null if freed.
* xcn_ptr to null if freed.
*
* @public @memberof xrt_compositor_fd
* @public @memberof xrt_compositor_native
*/
static inline void
xrt_comp_fd_destroy(struct xrt_compositor_fd **xcfd_ptr)
xrt_comp_native_destroy(struct xrt_compositor_native **xcn_ptr)
{
struct xrt_compositor_fd *xcfd = *xcfd_ptr;
if (xcfd == NULL) {
struct xrt_compositor_native *xcn = *xcn_ptr;
if (xcn == NULL) {
return;
}
xcfd->base.destroy(&xcfd->base);
*xcfd_ptr = NULL;
xcn->base.destroy(&xcn->base);
*xcn_ptr = NULL;
}

4
src/xrt/include/xrt/xrt_gfx_egl.h
View file

@ -28,10 +28,10 @@ struct time_state;
* Create an OpenGL(ES) compositor client using EGL.
*
* @ingroup xrt_iface
* @public @memberof xrt_compositor_fd
* @public @memberof xrt_compositor_native
*/
struct xrt_compositor_gl *
xrt_gfx_provider_create_gl_egl(struct xrt_compositor_fd *xcfd,
xrt_gfx_provider_create_gl_egl(struct xrt_compositor_native *xcn,
EGLDisplay display,
EGLConfig config,
EGLContext context,

8
src/xrt/include/xrt/xrt_gfx_fd.h
View file

@ -20,13 +20,13 @@ extern "C" {
struct time_state;
/*!
* Creates the main fd compositor.
* Creates the main native compositor.
*
* @ingroup xrt_iface
* @relates xrt_compositor_fd
* @relates xrt_compositor_native
*/
struct xrt_compositor_fd *
xrt_gfx_provider_create_fd(struct xrt_device *xdev, bool flip_y);
struct xrt_compositor_native *
xrt_gfx_provider_create_native(struct xrt_device *xdev, bool flip_y);
#ifdef __cplusplus

4
src/xrt/include/xrt/xrt_gfx_vk.h
View file

@ -41,10 +41,10 @@ xrt_gfx_vk_get_versions(struct xrt_api_requirements *ver);
* Create a Vulkan compositor client.
*
* @ingroup xrt_iface
* @public @memberof xrt_compositor_fd
* @public @memberof xrt_compositor_native
*/
struct xrt_compositor_vk *
xrt_gfx_vk_provider_create(struct xrt_compositor_fd *xcfd,
xrt_gfx_vk_provider_create(struct xrt_compositor_native *xcn,
VkInstance instance,
PFN_vkGetInstanceProcAddr get_instance_proc_addr,
VkPhysicalDevice physical_device,

4
src/xrt/include/xrt/xrt_gfx_xlib.h
View file

@ -27,10 +27,10 @@ struct time_state;
* Create an OpenGL compositor client using xlib.
*
* @ingroup xrt_iface
* @public @memberof xrt_compositor_fd
* @public @memberof xrt_compositor_native
*/
struct xrt_compositor_gl *
xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_fd *xcfd,
xrt_gfx_provider_create_gl_xlib(struct xrt_compositor_native *xcn,
Display *xDisplay,
uint32_t visualid,
GLXFBConfig glxFBConfig,

32
src/xrt/include/xrt/xrt_instance.h
View file

@ -20,7 +20,7 @@ extern "C" {
struct xrt_prober;
struct xrt_device;
struct xrt_compositor_fd;
struct xrt_compositor_native;
/*!
@ -86,27 +86,27 @@ struct xrt_instance
size_t num_xdevs);
/*!
* Creates a @ref xrt_compositor_fd.
* Creates a @ref xrt_compositor_native.
*
* Should only be called once.
*
* @note Code consuming this interface should use
* xrt_instance_create_fd_compositor()
* xrt_instance_create_native_compositor()
*
* @param xinst Pointer to self
* @param[in] xdev Device to use for creating the compositor
* @param[in] flip_y Whether to flip the direction of the y axis
* @param[out] out_xcfd Pointer to xrt_compositor_fd pointer, will be
* populated.
* @param[out] out_xcn Pointer to xrt_compositor_native pointer, will
* be populated.
*
* @return 0 on success, <0 on error.
*
* @see xrt_gfx_provider_create_fd
* @see xrt_gfx_provider_create_native
*/
int (*create_fd_compositor)(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd);
int (*create_native_compositor)(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_native **out_xcn);
/*!
* Get the instance @ref xrt_prober, if any.
@ -163,19 +163,19 @@ xrt_instance_select(struct xrt_instance *xinst,
}
/*!
* @copydoc xrt_instance::create_fd_compositor
* @copydoc xrt_instance::create_native_compositor
*
* Helper for calling through the function pointer.
*
* @public @memberof xrt_instance
*/
static inline int
xrt_instance_create_fd_compositor(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd)
xrt_instance_create_native_compositor(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_native **out_xcn)
{
return xinst->create_fd_compositor(xinst, xdev, flip_y, out_xcfd);
return xinst->create_native_compositor(xinst, xdev, flip_y, out_xcn);
}
/*!

4
src/xrt/ipc/ipc_client.h
View file

@ -67,7 +67,7 @@
*
*/
struct xrt_compositor_fd;
struct xrt_compositor_native;
/*!
@ -96,7 +96,7 @@ int
ipc_client_compositor_create(struct ipc_connection *ipc_c,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd);
struct xrt_compositor_native **out_xcn);
struct xrt_device *
ipc_client_hmd_create(struct ipc_connection *ipc_c,

16
src/xrt/ipc/ipc_client_compositor.c
View file

@ -35,12 +35,12 @@
*
*/
/*!
* Client proxy for an xrt_compositor_fd implementation over IPC.
* @implements xrt_compositor_fd
* Client proxy for an xrt_compositor_native implementation over IPC.
* @implements xrt_compositor_native
*/
struct ipc_client_compositor
{
struct xrt_compositor_fd base;
struct xrt_compositor_native base;
struct ipc_connection *ipc_c;
@ -56,12 +56,12 @@ struct ipc_client_compositor
};
/*!
* Client proxy for an xrt_swapchain_fd implementation over IPC.
* @implements xrt_swapchain_fd
* Client proxy for an xrt_swapchain_native implementation over IPC.
* @implements xrt_swapchain_native
*/
struct ipc_client_swapchain
{
struct xrt_swapchain_fd base;
struct xrt_swapchain_native base;
struct ipc_client_compositor *icc;
@ -456,7 +456,7 @@ int
ipc_client_compositor_create(struct ipc_connection *ipc_c,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd)
struct xrt_compositor_native **out_xcn)
{
struct ipc_client_compositor *c =
U_TYPED_CALLOC(struct ipc_client_compositor);
@ -490,7 +490,7 @@ ipc_client_compositor_create(struct ipc_connection *ipc_c,
}
}
*out_xcfd = &c->base;
*out_xcn = &c->base;
return 0;
}

21
src/xrt/ipc/ipc_client_instance.c
View file

@ -122,20 +122,21 @@ ipc_client_instance_select(struct xrt_instance *xinst,
}
static int
ipc_client_instance_create_fd_compositor(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd)
ipc_client_instance_create_native_compositor(
struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_native **out_xcn)
{
struct ipc_client_instance *ii = ipc_client_instance(xinst);
struct xrt_compositor_fd *xcfd = NULL;
struct xrt_compositor_native *xcn = NULL;
int ret = ipc_client_compositor_create(&ii->ipc_c, xdev, flip_y, &xcfd);
if (ret < 0 || xcfd == NULL) {
int ret = ipc_client_compositor_create(&ii->ipc_c, xdev, flip_y, &xcn);
if (ret < 0 || xcn == NULL) {
return -1;
}
*out_xcfd = xcfd;
*out_xcn = xcn;
return 0;
}
@ -188,8 +189,8 @@ ipc_instance_create(struct xrt_instance_info *i_info,
struct ipc_client_instance *ii =
U_TYPED_CALLOC(struct ipc_client_instance);
ii->base.select = ipc_client_instance_select;
ii->base.create_fd_compositor =
ipc_client_instance_create_fd_compositor;
ii->base.create_native_compositor =
ipc_client_instance_create_native_compositor;
ii->base.get_prober = ipc_client_instance_get_prober;
ii->base.destroy = ipc_client_instance_destroy;

4
src/xrt/ipc/ipc_server.h
View file

@ -69,7 +69,7 @@ extern "C" {
struct xrt_instance;
struct xrt_compositor;
struct xrt_compositor_fd;
struct xrt_compositor_native;
/*!
@ -160,7 +160,7 @@ struct ipc_server
struct xrt_instance *xinst;
struct xrt_compositor *xc;
struct xrt_compositor_fd *xcfd;
struct xrt_compositor_native *xcn;
struct xrt_device *xdevs[IPC_SERVER_NUM_XDEVS];
struct xrt_tracking_origin *xtracks[IPC_SERVER_NUM_XDEVS];

6
src/xrt/ipc/ipc_server_client.c
View file

@ -311,20 +311,20 @@ ipc_handle_swapchain_create(volatile struct ipc_client_state *ics,
ics->swapchain_data[index].num_images = num_images;
// return our result to the caller.
struct xrt_swapchain_fd *xcsfd = (struct xrt_swapchain_fd *)xsc;
struct xrt_swapchain_native *xscn = (struct xrt_swapchain_native *)xsc;
// Sanity checking.
assert(num_images <= IPC_MAX_SWAPCHAIN_FDS);
assert(num_images <= max_num_fds);
*out_id = index;
*out_size = xcsfd->images[0].size;
*out_size = xscn->images[0].size;
*out_num_images = num_images;
// Setup the fds.
*out_num_handles = num_images;
for (size_t i = 0; i < num_images; i++) {
out_handles[i] = xcsfd->images[i].fd;
out_handles[i] = xscn->images[i].fd;
}
return XRT_SUCCESS;

6
src/xrt/ipc/ipc_server_process.c
View file

@ -412,8 +412,8 @@ init_all(struct ipc_server *s)
return -1;
}
ret = xrt_instance_create_fd_compositor(s->xinst, s->xdevs[0], false,
&s->xcfd);
ret = xrt_instance_create_native_compositor(s->xinst, s->xdevs[0],
false, &s->xcn);
if (ret < 0) {
teardown_all(s);
return ret;
@ -449,7 +449,7 @@ init_all(struct ipc_server *s)
}
// Easier to use.
s->xc = &s->xcfd->base;
s->xc = &s->xcn->base;
u_var_add_root(s, "IPC Server", false);
u_var_add_bool(s, &s->print_debug, "print.debug");

15
src/xrt/state_trackers/oxr/oxr_session_egl.c
View file

@ -65,22 +65,23 @@ oxr_session_populate_egl(struct oxr_logger *log,
"Unsupported EGL client type");
}
struct xrt_compositor_fd *xcfd = NULL;
struct xrt_compositor_native *xcn = NULL;
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, head);
int ret = xrt_instance_create_fd_compositor(sys->inst->xinst, xdev,
true, &xcfd);
if (ret < 0 || xcfd == NULL) {
int ret = xrt_instance_create_native_compositor(sys->inst->xinst, xdev,
true, &xcn);
if (ret < 0 || xcn == NULL) {
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an fd compositor '%i'", ret);
"Failed to create a native compositor '%i'",
ret);
}
struct xrt_compositor_gl *xcgl =
xrt_gfx_provider_create_gl_egl(xcfd, next->display, next->config,
xrt_gfx_provider_create_gl_egl(xcn, next->display, next->config,
next->context, next->getProcAddress);
if (xcgl == NULL) {
xcfd->base.destroy(&xcfd->base);
xcn->base.destroy(&xcn->base);
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an egl client compositor");
}

15
src/xrt/state_trackers/oxr/oxr_session_gl.c
View file

@ -33,23 +33,24 @@ oxr_session_populate_gl_xlib(struct oxr_logger *log,
XrGraphicsBindingOpenGLXlibKHR const *next,
struct oxr_session *sess)
{
struct xrt_compositor_fd *xcfd = NULL;
struct xrt_compositor_native *xcn = NULL;
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, head);
int ret = xrt_instance_create_fd_compositor(sys->inst->xinst, xdev,
true, &xcfd);
if (ret < 0 || xcfd == NULL) {
int ret = xrt_instance_create_native_compositor(sys->inst->xinst, xdev,
true, &xcn);
if (ret < 0 || xcn == NULL) {
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an fd compositor '%i'", ret);
"Failed to create a native compositor '%i'",
ret);
}
struct xrt_compositor_gl *xcgl = xrt_gfx_provider_create_gl_xlib(
xcfd, next->xDisplay, next->visualid, next->glxFBConfig,
xcn, next->xDisplay, next->visualid, next->glxFBConfig,
next->glxDrawable, next->glxContext);
if (xcgl == NULL) {
xcfd->base.destroy(&xcfd->base);
xcn->base.destroy(&xcn->base);
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an xlib client compositor");
}

15
src/xrt/state_trackers/oxr/oxr_session_vk.c
View file

@ -27,22 +27,23 @@ oxr_session_populate_vk(struct oxr_logger *log,
XrGraphicsBindingVulkanKHR const *next,
struct oxr_session *sess)
{
struct xrt_compositor_fd *xcfd = NULL;
struct xrt_compositor_native *xcn = NULL;
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, head);
int ret = xrt_instance_create_fd_compositor(sys->inst->xinst, xdev,
false, &xcfd);
if (ret < 0 || xcfd == NULL) {
int ret = xrt_instance_create_native_compositor(sys->inst->xinst, xdev,
false, &xcn);
if (ret < 0 || xcn == NULL) {
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an fd compositor '%i'", ret);
"Failed to create a native compositor '%i'",
ret);
}
struct xrt_compositor_vk *xcvk = xrt_gfx_vk_provider_create(
xcfd, next->instance, vkGetInstanceProcAddr, next->physicalDevice,
xcn, next->instance, vkGetInstanceProcAddr, next->physicalDevice,
next->device, next->queueFamilyIndex, next->queueIndex);
if (xcvk == NULL) {
xcfd->base.destroy(&xcfd->base);
xcn->base.destroy(&xcn->base);
return oxr_error(log, XR_ERROR_INITIALIZATION_FAILED,
"Failed to create an vk client compositor");
}

19
src/xrt/targets/common/target_instance.c
View file

@ -11,19 +11,19 @@
#include "xrt/xrt_gfx_fd.h"
static int
t_instance_create_fd_compositor(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd)
t_instance_create_native_compositor(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_native **out_xcn)
{
struct xrt_compositor_fd *xcfd =
xrt_gfx_provider_create_fd(xdev, flip_y);
struct xrt_compositor_native *xcn =
xrt_gfx_provider_create_native(xdev, flip_y);
if (xcfd == NULL) {
if (xcn == NULL) {
return -1;
}
*out_xcfd = xcfd;
*out_xcn = xcn;
return 0;
}
@ -47,7 +47,8 @@ xrt_instance_create(struct xrt_instance_info *i_info,
struct t_instance *tinst = U_TYPED_CALLOC(struct t_instance);
tinst->base.select = t_instance_select;
tinst->base.create_fd_compositor = t_instance_create_fd_compositor;
tinst->base.create_native_compositor =
t_instance_create_native_compositor;
tinst->base.get_prober = t_instance_get_prober;
tinst->base.destroy = t_instance_destroy;
tinst->xp = xp;

13
src/xrt/targets/common/target_instance_no_comp.c
View file

@ -11,12 +11,12 @@
static int
t_instance_create_fd_compositor_stub(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_fd **out_xcfd)
t_instance_create_native_compositor_stub(struct xrt_instance *xinst,
struct xrt_device *xdev,
bool flip_y,
struct xrt_compositor_native **out_xcn)
{
*out_xcfd = NULL;
*out_xcn = NULL;
return -1;
}
@ -41,7 +41,8 @@ xrt_instance_create(struct xrt_instance_info *i_info,
struct t_instance *tinst = U_TYPED_CALLOC(struct t_instance);
tinst->base.select = t_instance_select;
tinst->base.create_fd_compositor = t_instance_create_fd_compositor_stub;
tinst->base.create_native_compositor =
t_instance_create_native_compositor_stub;
tinst->base.get_prober = t_instance_get_prober;
tinst->base.destroy = t_instance_destroy;
tinst->xp = xp;