mirrors/monado
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/monado/monado.git synced 2025-01-04 06:06:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

xrt: Introduce xrt_layer_frame_data

Browse source
This commit is contained in:
Jakob Bornecrantz 2023-04-04 11:35:26 +01:00
parent bec9a30bfe
commit 50838f5801
18 changed files with 124 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
src/xrt/compositor/client/comp_d3d11_client.cpp
View file

@ -506,15 +506,12 @@ client_d3d11_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_i
} }
static xrt_result_t static xrt_result_t
client_d3d11_compositor_layer_begin(struct xrt_compositor *xc, client_d3d11_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc); struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc);
// Pipe down call into native compositor. // Pipe down call into native compositor.
return xrt_comp_layer_begin(&c->xcn->base, frame_id, display_time_ns, env_blend_mode); return xrt_comp_layer_begin(&c->xcn->base, data);
} }
static xrt_result_t static xrt_result_t
@ -638,9 +635,7 @@ client_d3d11_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
client_d3d11_compositor_layer_commit(struct xrt_compositor *xc, client_d3d11_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
int64_t frame_id,
xrt_graphics_sync_handle_t sync_handle)
{ {
struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc); struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc);
@ -655,19 +650,25 @@ client_d3d11_compositor_layer_commit(struct xrt_compositor *xc,
char buf[kErrorBufSize]; char buf[kErrorBufSize];
formatMessage(hr, buf); formatMessage(hr, buf);
D3D_ERROR(c, "Error signaling fence: %s", buf); D3D_ERROR(c, "Error signaling fence: %s", buf);
return xrt_comp_layer_commit(&c->xcn->base, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); return xrt_comp_layer_commit(&c->xcn->base, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
} }
} }
if (c->timeline_semaphore) { if (c->timeline_semaphore) {
// We got this from the native compositor, so we can pass it back // We got this from the native compositor, so we can pass it back
return xrt_comp_layer_commit_with_semaphore(&c->xcn->base, frame_id, c->timeline_semaphore.get(), return xrt_comp_layer_commit_with_semaphore( //
c->timeline_semaphore_value); &c->xcn->base, //
c->timeline_semaphore.get(), //
c->timeline_semaphore_value); //
} }
if (c->fence) { if (c->fence) {
// Wait on it ourselves, if we have it and didn't tell the native compositor to wait on it. // Wait on it ourselves, if we have it and didn't tell the native compositor to wait on it.
xret = xrt::auxiliary::d3d::d3d11::waitOnFenceWithTimeout(c->fence, c->local_wait_event, xret = xrt::auxiliary::d3d::d3d11::waitOnFenceWithTimeout( //
c->timeline_semaphore_value, kFenceTimeout); c->fence, //
c->local_wait_event, //
c->timeline_semaphore_value, //
kFenceTimeout); //
if (xret != XRT_SUCCESS) { if (xret != XRT_SUCCESS) {
struct u_pp_sink_stack_only sink; // Not inited, very large. struct u_pp_sink_stack_only sink; // Not inited, very large.
u_pp_delegate_t dg = u_pp_sink_stack_only_init(&sink); u_pp_delegate_t dg = u_pp_sink_stack_only_init(&sink);
@ -679,7 +680,7 @@ client_d3d11_compositor_layer_commit(struct xrt_compositor *xc,
} }
} }
return xrt_comp_layer_commit(&c->xcn->base, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); return xrt_comp_layer_commit(&c->xcn->base, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
} }

28
src/xrt/compositor/client/comp_d3d12_client.cpp
View file

@ -607,15 +607,12 @@ client_d3d12_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_i
} }
static xrt_result_t static xrt_result_t
client_d3d12_compositor_layer_begin(struct xrt_compositor *xc, client_d3d12_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc); struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc);
// Pipe down call into native compositor. // Pipe down call into native compositor.
return xrt_comp_layer_begin(&c->xcn->base, frame_id, display_time_ns, env_blend_mode); return xrt_comp_layer_begin(&c->xcn->base, data);
} }
static xrt_result_t static xrt_result_t
@ -739,9 +736,7 @@ client_d3d12_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
client_d3d12_compositor_layer_commit(struct xrt_compositor *xc, client_d3d12_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
int64_t frame_id,
xrt_graphics_sync_handle_t sync_handle)
{ {
struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc); struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc);
@ -756,19 +751,24 @@ client_d3d12_compositor_layer_commit(struct xrt_compositor *xc,
char buf[kErrorBufSize]; char buf[kErrorBufSize];
formatMessage(hr, buf); formatMessage(hr, buf);
D3D_ERROR(c, "Error signaling fence: %s", buf); D3D_ERROR(c, "Error signaling fence: %s", buf);
return xrt_comp_layer_commit(&c->xcn->base, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); return xrt_comp_layer_commit(&c->xcn->base, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
} }
} }
if (c->timeline_semaphore) { if (c->timeline_semaphore) {
// We got this from the native compositor, so we can pass it back // We got this from the native compositor, so we can pass it back
return xrt_comp_layer_commit_with_semaphore(&c->xcn->base, frame_id, c->timeline_semaphore.get(), return xrt_comp_layer_commit_with_semaphore( //
c->timeline_semaphore_value); &c->xcn->base, //
c->timeline_semaphore.get(), //
c->timeline_semaphore_value); //
} }
if (c->fence) { if (c->fence) {
// Wait on it ourselves, if we have it and didn't tell the native compositor to wait on it. // Wait on it ourselves, if we have it and didn't tell the native compositor to wait on it.
xret = xrt::auxiliary::d3d::d3d12::waitOnFenceWithTimeout(c->fence, c->local_wait_event, xret = xrt::auxiliary::d3d::d3d12::waitOnFenceWithTimeout( //
c->timeline_semaphore_value, kFenceTimeout); c->fence, //
c->local_wait_event, //
c->timeline_semaphore_value, //
kFenceTimeout); //
if (xret != XRT_SUCCESS) { if (xret != XRT_SUCCESS) {
struct u_pp_sink_stack_only sink; // Not inited, very large. struct u_pp_sink_stack_only sink; // Not inited, very large.
u_pp_delegate_t dg = u_pp_sink_stack_only_init(&sink); u_pp_delegate_t dg = u_pp_sink_stack_only_init(&sink);
@ -780,7 +780,7 @@ client_d3d12_compositor_layer_commit(struct xrt_compositor *xc,
} }
} }
return xrt_comp_layer_commit(&c->xcn->base, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); return xrt_comp_layer_commit(&c->xcn->base, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
} }

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

@ -215,14 +215,11 @@ client_gl_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
client_gl_compositor_layer_begin(struct xrt_compositor *xc, client_gl_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct client_gl_compositor *c = client_gl_compositor(xc); struct client_gl_compositor *c = client_gl_compositor(xc);
return xrt_comp_layer_begin(&c->xcn->base, frame_id, display_time_ns, env_blend_mode); return xrt_comp_layer_begin(&c->xcn->base, data);
} }
static xrt_result_t static xrt_result_t
@ -371,7 +368,7 @@ client_gl_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
client_gl_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) client_gl_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
@ -390,7 +387,7 @@ client_gl_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, x
COMP_TRACE_IDENT(layer_commit); COMP_TRACE_IDENT(layer_commit);
return xrt_comp_layer_commit(&c->xcn->base, frame_id, sync_handle); return xrt_comp_layer_commit(&c->xcn->base, sync_handle);
} }
static xrt_result_t static xrt_result_t

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

@ -84,10 +84,7 @@ setup_semaphore(struct client_vk_compositor *c)
*/ */
static bool static bool
submit_handle(struct client_vk_compositor *c, submit_handle(struct client_vk_compositor *c, xrt_graphics_sync_handle_t sync_handle, xrt_result_t *out_xret)
int64_t frame_id,
xrt_graphics_sync_handle_t sync_handle,
xrt_result_t *out_xret)
{ {
// Did we get a ready made handle, assume it's in the command stream and call commit directly. // Did we get a ready made handle, assume it's in the command stream and call commit directly.
if (!xrt_graphics_sync_handle_is_valid(sync_handle)) { if (!xrt_graphics_sync_handle_is_valid(sync_handle)) {
@ -95,12 +92,12 @@ submit_handle(struct client_vk_compositor *c,
} }
// Commit consumes the sync_handle. // Commit consumes the sync_handle.
*out_xret = xrt_comp_layer_commit(&c->xcn->base, frame_id, sync_handle); *out_xret = xrt_comp_layer_commit(&c->xcn->base, sync_handle);
return true; return true;
} }
static bool static bool
submit_semaphore(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t *out_xret) submit_semaphore(struct client_vk_compositor *c, xrt_result_t *out_xret)
{ {
#ifdef VK_KHR_timeline_semaphore #ifdef VK_KHR_timeline_semaphore
if (c->sync.xcsem == NULL) { if (c->sync.xcsem == NULL) {
@ -144,7 +141,6 @@ submit_semaphore(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t
*out_xret = xrt_comp_layer_commit_with_semaphore( // *out_xret = xrt_comp_layer_commit_with_semaphore( //
&c->xcn->base, // xc &c->xcn->base, // xc
frame_id, // frame_id
c->sync.xcsem, // xcsem c->sync.xcsem, // xcsem
values[0]); // value values[0]); // value
@ -155,7 +151,7 @@ submit_semaphore(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t
} }
static bool static bool
submit_fence(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t *out_xret) submit_fence(struct client_vk_compositor *c, xrt_result_t *out_xret)
{ {
xrt_graphics_sync_handle_t sync_handle = XRT_GRAPHICS_SYNC_HANDLE_INVALID; xrt_graphics_sync_handle_t sync_handle = XRT_GRAPHICS_SYNC_HANDLE_INVALID;
struct vk_bundle *vk = &c->vk; struct vk_bundle *vk = &c->vk;
@ -186,12 +182,12 @@ submit_fence(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t *out
} }
} }
*out_xret = xrt_comp_layer_commit(&c->xcn->base, frame_id, sync_handle); *out_xret = xrt_comp_layer_commit(&c->xcn->base, sync_handle);
return true; return true;
} }
static bool static bool
submit_fallback(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t *out_xret) submit_fallback(struct client_vk_compositor *c, xrt_result_t *out_xret)
{ {
struct vk_bundle *vk = &c->vk; struct vk_bundle *vk = &c->vk;
@ -202,7 +198,7 @@ submit_fallback(struct client_vk_compositor *c, int64_t frame_id, xrt_result_t *
vk->vkDeviceWaitIdle(vk->device); vk->vkDeviceWaitIdle(vk->device);
} }
*out_xret = xrt_comp_layer_commit(&c->xcn->base, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); *out_xret = xrt_comp_layer_commit(&c->xcn->base, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
return true; return true;
} }
@ -431,16 +427,13 @@ client_vk_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
client_vk_compositor_layer_begin(struct xrt_compositor *xc, client_vk_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct client_vk_compositor *c = client_vk_compositor(xc); struct client_vk_compositor *c = client_vk_compositor(xc);
return xrt_comp_layer_begin(&c->xcn->base, frame_id, display_time_ns, env_blend_mode); return xrt_comp_layer_begin(&c->xcn->base, data);
} }
static xrt_result_t static xrt_result_t
@ -569,20 +562,20 @@ client_vk_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
client_vk_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) client_vk_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct client_vk_compositor *c = client_vk_compositor(xc); struct client_vk_compositor *c = client_vk_compositor(xc);
xrt_result_t xret = XRT_SUCCESS; xrt_result_t xret = XRT_SUCCESS;
if (submit_handle(c, frame_id, sync_handle, &xret)) { if (submit_handle(c, sync_handle, &xret)) {
return xret; return xret;
} else if (submit_semaphore(c, frame_id, &xret)) { } else if (submit_semaphore(c, &xret)) {
return xret; return xret;
} else if (submit_fence(c, frame_id, &xret)) { } else if (submit_fence(c, &xret)) {
return xret; return xret;
} else if (submit_fallback(c, frame_id, &xret)) { } else if (submit_fallback(c, &xret)) {
return xret; return xret;
} else { } else {
// Really bad state. // Really bad state.

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

@ -370,7 +370,7 @@ can_do_one_projection_layer_fast_path(struct comp_compositor *c)
} }
static xrt_result_t static xrt_result_t
compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();

40
src/xrt/compositor/multi/comp_multi_compositor.c
View file

@ -49,7 +49,7 @@ slot_clear_locked(struct multi_compositor *mc, struct multi_layer_slot *slot)
{ {
if (slot->active) { if (slot->active) {
uint64_t now_ns = os_monotonic_get_ns(); uint64_t now_ns = os_monotonic_get_ns();
u_pa_retired(mc->upa, slot->frame_id, now_ns); u_pa_retired(mc->upa, slot->data.frame_id, now_ns);
} }
for (size_t i = 0; i < slot->layer_count; i++) { for (size_t i = 0; i < slot->layer_count; i++) {
@ -59,7 +59,7 @@ slot_clear_locked(struct multi_compositor *mc, struct multi_layer_slot *slot)
} }
U_ZERO(slot); U_ZERO(slot);
slot->frame_id = -1; slot->data.frame_id = -1;
} }
/*! /*!
@ -69,13 +69,13 @@ static void
slot_move_into_cleared(struct multi_layer_slot *dst, struct multi_layer_slot *src) slot_move_into_cleared(struct multi_layer_slot *dst, struct multi_layer_slot *src)
{ {
assert(!dst->active); assert(!dst->active);
assert(dst->frame_id == -1); assert(dst->data.frame_id == -1);
// All references are kept. // All references are kept.
*dst = *src; *dst = *src;
U_ZERO(src); U_ZERO(src);
src->frame_id = -1; src->data.frame_id = -1;
} }
/*! /*!
@ -219,14 +219,14 @@ wait_for_scheduled_free(struct multi_compositor *mc)
while (v_mc->scheduled.active) { while (v_mc->scheduled.active) {
// This frame is for the next frame, drop the old one no matter what. // This frame is for the next frame, drop the old one no matter what.
if (time_is_within_half_ms(mc->progress.display_time_ns, mc->slot_next_frame_display)) { if (time_is_within_half_ms(mc->progress.data.display_time_ns, mc->slot_next_frame_display)) {
U_LOG_W("Dropping old missed frame in favour for completed new frame"); U_LOG_W("Dropping old missed frame in favour for completed new frame");
break; break;
} }
// Replace the scheduled frame if it's in the past. // Replace the scheduled frame if it's in the past.
uint64_t now_ns = os_monotonic_get_ns(); uint64_t now_ns = os_monotonic_get_ns();
if (v_mc->scheduled.display_time_ns < now_ns) { if (v_mc->scheduled.data.display_time_ns < now_ns) {
break; break;
} }
@ -239,10 +239,10 @@ wait_for_scheduled_free(struct multi_compositor *mc)
"\n\tscheduled: %fms (%" PRIu64 ") (oldest waiting frame)", "\n\tscheduled: %fms (%" PRIu64 ") (oldest waiting frame)",
time_ns_to_ms_f((int64_t)v_mc->slot_next_frame_display - now_ns), // time_ns_to_ms_f((int64_t)v_mc->slot_next_frame_display - now_ns), //
v_mc->slot_next_frame_display, // v_mc->slot_next_frame_display, //
time_ns_to_ms_f((int64_t)v_mc->progress.display_time_ns - now_ns), // time_ns_to_ms_f((int64_t)v_mc->progress.data.display_time_ns - now_ns), //
v_mc->progress.display_time_ns, // v_mc->progress.data.display_time_ns, //
time_ns_to_ms_f((int64_t)v_mc->scheduled.display_time_ns - now_ns), // time_ns_to_ms_f((int64_t)v_mc->scheduled.data.display_time_ns - now_ns), //
v_mc->scheduled.display_time_ns); // v_mc->scheduled.data.display_time_ns); //
os_mutex_unlock(&mc->slot_lock); os_mutex_unlock(&mc->slot_lock);
@ -647,17 +647,14 @@ multi_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
multi_compositor_layer_begin(struct xrt_compositor *xc, multi_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct multi_compositor *mc = multi_compositor(xc); struct multi_compositor *mc = multi_compositor(xc);
// As early as possible. // As early as possible.
uint64_t now_ns = os_monotonic_get_ns(); uint64_t now_ns = os_monotonic_get_ns();
os_mutex_lock(&mc->msc->list_and_timing_lock); os_mutex_lock(&mc->msc->list_and_timing_lock);
u_pa_mark_delivered(mc->upa, frame_id, now_ns, display_time_ns); u_pa_mark_delivered(mc->upa, data->frame_id, now_ns, data->display_time_ns);
os_mutex_unlock(&mc->msc->list_and_timing_lock); os_mutex_unlock(&mc->msc->list_and_timing_lock);
/* /*
@ -676,9 +673,7 @@ multi_compositor_layer_begin(struct xrt_compositor *xc,
U_ZERO(&mc->progress); U_ZERO(&mc->progress);
mc->progress.active = true; mc->progress.active = true;
mc->progress.frame_id = frame_id; mc->progress.data = *data;
mc->progress.display_time_ns = display_time_ns;
mc->progress.env_blend_mode = env_blend_mode;
return XRT_SUCCESS; return XRT_SUCCESS;
} }
@ -805,12 +800,13 @@ multi_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
multi_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) multi_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct multi_compositor *mc = multi_compositor(xc); struct multi_compositor *mc = multi_compositor(xc);
struct xrt_compositor_fence *xcf = NULL; struct xrt_compositor_fence *xcf = NULL;
int64_t frame_id = mc->progress.data.frame_id;
do { do {
if (!xrt_graphics_sync_handle_is_valid(sync_handle)) { if (!xrt_graphics_sync_handle_is_valid(sync_handle)) {
@ -851,13 +847,13 @@ multi_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_g
static xrt_result_t static xrt_result_t
multi_compositor_layer_commit_with_semaphore(struct xrt_compositor *xc, multi_compositor_layer_commit_with_semaphore(struct xrt_compositor *xc,
int64_t frame_id,
struct xrt_compositor_semaphore *xcsem, struct xrt_compositor_semaphore *xcsem,
uint64_t value) uint64_t value)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct multi_compositor *mc = multi_compositor(xc); struct multi_compositor *mc = multi_compositor(xc);
int64_t frame_id = mc->progress.data.frame_id;
push_semaphore_to_wait_thread(mc, frame_id, xcsem, value); push_semaphore_to_wait_thread(mc, frame_id, xcsem, value);
@ -933,7 +929,7 @@ multi_compositor_deliver_any_frames(struct multi_compositor *mc, uint64_t displa
return; return;
} }
if (time_is_greater_then_or_within_half_ms(display_time_ns, mc->scheduled.display_time_ns)) { if (time_is_greater_then_or_within_half_ms(display_time_ns, mc->scheduled.data.display_time_ns)) {
slot_move_and_clear_locked(mc, &mc->delivered, &mc->scheduled); slot_move_and_clear_locked(mc, &mc->delivered, &mc->scheduled);
} }
@ -943,7 +939,7 @@ multi_compositor_deliver_any_frames(struct multi_compositor *mc, uint64_t displa
void void
multi_compositor_latch_frame_locked(struct multi_compositor *mc, uint64_t when_ns, int64_t system_frame_id) multi_compositor_latch_frame_locked(struct multi_compositor *mc, uint64_t when_ns, int64_t system_frame_id)
{ {
u_pa_latched(mc->upa, mc->delivered.frame_id, when_ns, system_frame_id); u_pa_latched(mc->upa, mc->delivered.data.frame_id, when_ns, system_frame_id);
} }
void void

4
src/xrt/compositor/multi/comp_multi_private.h
View file

@ -68,9 +68,7 @@ struct multi_layer_entry
*/ */
struct multi_layer_slot struct multi_layer_slot
{ {
int64_t frame_id; struct xrt_layer_frame_data data;
uint64_t display_time_ns; //!< When should this be shown, @see XrFrameEndInfo::displayTime.
enum xrt_blend_mode env_blend_mode;
uint32_t layer_count; uint32_t layer_count;
struct multi_layer_entry layers[MULTI_MAX_LAYERS]; struct multi_layer_entry layers[MULTI_MAX_LAYERS];
bool active; bool active;

14
src/xrt/compositor/multi/comp_multi_system.c
View file

@ -283,7 +283,7 @@ transfer_layers_locked(struct multi_system_compositor *msc, uint64_t display_tim
struct multi_compositor *mc = array[k]; struct multi_compositor *mc = array[k];
assert(mc != NULL); assert(mc != NULL);
uint64_t frame_time_ns = mc->delivered.display_time_ns; uint64_t frame_time_ns = mc->delivered.data.display_time_ns;
if (!time_is_within_half_ms(frame_time_ns, display_time_ns)) { if (!time_is_within_half_ms(frame_time_ns, display_time_ns)) {
log_frame_time_diff(frame_time_ns, display_time_ns); log_frame_time_diff(frame_time_ns, display_time_ns);
} }
@ -493,16 +493,24 @@ multi_main_loop(struct multi_system_compositor *msc)
//! @todo Pick the blend mode from primary client. //! @todo Pick the blend mode from primary client.
enum xrt_blend_mode blend_mode = XRT_BLEND_MODE_OPAQUE; enum xrt_blend_mode blend_mode = XRT_BLEND_MODE_OPAQUE;
//! @todo Pick a good display time. //! @todo Pick a good display time.
uint64_t display_time_ns = 0; uint64_t display_time_ns = 0;
xrt_comp_layer_begin(xc, frame_id, display_time_ns, blend_mode);
// Prepare data.
struct xrt_layer_frame_data data = {
.frame_id = frame_id,
.display_time_ns = display_time_ns,
.env_blend_mode = blend_mode,
};
xrt_comp_layer_begin(xc, &data);
// Make sure that the clients doesn't go away while we transfer layers. // Make sure that the clients doesn't go away while we transfer layers.
os_mutex_lock(&msc->list_and_timing_lock); os_mutex_lock(&msc->list_and_timing_lock);
transfer_layers_locked(msc, predicted_display_time_ns, frame_id); transfer_layers_locked(msc, predicted_display_time_ns, frame_id);
os_mutex_unlock(&msc->list_and_timing_lock); os_mutex_unlock(&msc->list_and_timing_lock);
xrt_comp_layer_commit(xc, frame_id, XRT_GRAPHICS_SYNC_HANDLE_INVALID); xrt_comp_layer_commit(xc, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
// Re-lock the thread for check in while statement. // Re-lock the thread for check in while statement.
os_thread_helper_lock(&msc->oth); os_thread_helper_lock(&msc->oth);

4
src/xrt/compositor/null/null_compositor.c
View file

@ -406,13 +406,15 @@ null_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
null_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) null_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct null_compositor *c = null_compositor(xc); struct null_compositor *c = null_compositor(xc);
NULL_TRACE(c, "LAYER_COMMIT"); NULL_TRACE(c, "LAYER_COMMIT");
int64_t frame_id = c->base.slot.data.frame_id;
/* /*
* The null compositor doesn't render and frames, but needs to do * The null compositor doesn't render and frames, but needs to do
* minimal bookkeeping and handling of arguments. If using the null * minimal bookkeeping and handling of arguments. If using the null

7
src/xrt/compositor/util/comp_base.c
View file

@ -104,14 +104,11 @@ base_create_semaphore(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
base_layer_begin(struct xrt_compositor *xc, base_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct comp_base *cb = comp_base(xc); struct comp_base *cb = comp_base(xc);
cb->slot.env_blend_mode = env_blend_mode; cb->slot.data = *data;
cb->slot.layer_count = 0; cb->slot.layer_count = 0;
return XRT_SUCCESS; return XRT_SUCCESS;

4
src/xrt/compositor/util/comp_base.h
View file

@ -49,8 +49,8 @@ struct comp_layer
*/ */
struct comp_layer_slot struct comp_layer_slot
{ {
//! What environmental blend mode did the app use. //! The per frame data.
enum xrt_blend_mode env_blend_mode; struct xrt_layer_frame_data data;
//! All of the layers. //! All of the layers.
struct comp_layer layers[COMP_MAX_LAYERS]; struct comp_layer layers[COMP_MAX_LAYERS];

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

@ -334,6 +334,17 @@ struct xrt_layer_data
}; };
}; };
/*!
* Per frame data for the layer submission calls, used in
* @ref xrt_compositor::layer_begin.
*/
struct xrt_layer_frame_data
{
int64_t frame_id;
uint64_t display_time_ns;
enum xrt_blend_mode env_blend_mode;
};
/* /*
* *
@ -982,10 +993,7 @@ struct xrt_compositor
* From the point of view of the swapchain, the image is used as * From the point of view of the swapchain, the image is used as
* soon as it's given in a call. * soon as it's given in a call.
*/ */
xrt_result_t (*layer_begin)(struct xrt_compositor *xc, xrt_result_t (*layer_begin)(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data);
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode);
/*! /*!
* @brief Adds a stereo projection layer for submissions. * @brief Adds a stereo projection layer for submissions.
@ -1117,9 +1125,7 @@ struct xrt_compositor
* *
* Only after this call will the compositor actually use the layers. * Only after this call will the compositor actually use the layers.
*/ */
xrt_result_t (*layer_commit)(struct xrt_compositor *xc, xrt_result_t (*layer_commit)(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle);
int64_t frame_id,
xrt_graphics_sync_handle_t sync_handle);
/*! /*!
* @brief Commits all of the submitted layers, with a semaphore. * @brief Commits all of the submitted layers, with a semaphore.
@ -1132,7 +1138,6 @@ struct xrt_compositor
* @param value Semaphore value upone completion of GPU work. * @param value Semaphore value upone completion of GPU work.
*/ */
xrt_result_t (*layer_commit_with_semaphore)(struct xrt_compositor *xc, xrt_result_t (*layer_commit_with_semaphore)(struct xrt_compositor *xc,
int64_t frame_id,
struct xrt_compositor_semaphore *xcsem, struct xrt_compositor_semaphore *xcsem,
uint64_t value); uint64_t value);
@ -1387,12 +1392,9 @@ xrt_comp_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
* @public @memberof xrt_compositor * @public @memberof xrt_compositor
*/ */
static inline xrt_result_t static inline xrt_result_t
xrt_comp_layer_begin(struct xrt_compositor *xc, xrt_comp_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
return xc->layer_begin(xc, frame_id, display_time_ns, env_blend_mode); return xc->layer_begin(xc, data);
} }
/*! /*!
@ -1520,9 +1522,9 @@ xrt_comp_layer_equirect2(struct xrt_compositor *xc,
* @public @memberof xrt_compositor * @public @memberof xrt_compositor
*/ */
static inline xrt_result_t static inline xrt_result_t
xrt_comp_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) xrt_comp_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
return xc->layer_commit(xc, frame_id, sync_handle); return xc->layer_commit(xc, sync_handle);
} }
/*! /*!
@ -1533,12 +1535,9 @@ xrt_comp_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_
* @public @memberof xrt_compositor * @public @memberof xrt_compositor
*/ */
static inline xrt_result_t static inline xrt_result_t
xrt_comp_layer_commit_with_semaphore(struct xrt_compositor *xc, xrt_comp_layer_commit_with_semaphore(struct xrt_compositor *xc, struct xrt_compositor_semaphore *xcsem, uint64_t value)
int64_t frame_id,
struct xrt_compositor_semaphore *xcsem,
uint64_t value)
{ {
return xc->layer_commit_with_semaphore(xc, frame_id, xcsem, value); return xc->layer_commit_with_semaphore(xc, xcsem, value);
} }
/*! @} */ /*! @} */

13
src/xrt/ipc/client/ipc_client_compositor.c
View file

@ -545,18 +545,14 @@ ipc_compositor_begin_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
ipc_compositor_layer_begin(struct xrt_compositor *xc, ipc_compositor_layer_begin(struct xrt_compositor *xc, const struct xrt_layer_frame_data *data)
int64_t frame_id,
uint64_t display_time_ns,
enum xrt_blend_mode env_blend_mode)
{ {
struct ipc_client_compositor *icc = ipc_client_compositor(xc); struct ipc_client_compositor *icc = ipc_client_compositor(xc);
struct ipc_shared_memory *ism = icc->ipc_c->ism; struct ipc_shared_memory *ism = icc->ipc_c->ism;
struct ipc_layer_slot *slot = &ism->slots[icc->layers.slot_id]; struct ipc_layer_slot *slot = &ism->slots[icc->layers.slot_id];
slot->display_time_ns = display_time_ns; slot->data = *data;
slot->env_blend_mode = env_blend_mode;
return XRT_SUCCESS; return XRT_SUCCESS;
} }
@ -700,7 +696,7 @@ ipc_compositor_layer_equirect2(struct xrt_compositor *xc,
} }
static xrt_result_t static xrt_result_t
ipc_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) ipc_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
struct ipc_client_compositor *icc = ipc_client_compositor(xc); struct ipc_client_compositor *icc = ipc_client_compositor(xc);
@ -714,7 +710,6 @@ ipc_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_gra
IPC_CALL_CHK(ipc_call_compositor_layer_sync( // IPC_CALL_CHK(ipc_call_compositor_layer_sync( //
icc->ipc_c, // icc->ipc_c, //
frame_id, //
icc->layers.slot_id, // icc->layers.slot_id, //
&sync_handle, // &sync_handle, //
valid_sync ? 1 : 0, // valid_sync ? 1 : 0, //
@ -733,7 +728,6 @@ ipc_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_gra
static xrt_result_t static xrt_result_t
ipc_compositor_layer_commit_with_semaphore(struct xrt_compositor *xc, ipc_compositor_layer_commit_with_semaphore(struct xrt_compositor *xc,
int64_t frame_id,
struct xrt_compositor_semaphore *xcsem, struct xrt_compositor_semaphore *xcsem,
uint64_t value) uint64_t value)
{ {
@ -748,7 +742,6 @@ ipc_compositor_layer_commit_with_semaphore(struct xrt_compositor *xc,
IPC_CALL_CHK(ipc_call_compositor_layer_sync_with_semaphore( // IPC_CALL_CHK(ipc_call_compositor_layer_sync_with_semaphore( //
icc->ipc_c, // icc->ipc_c, //
frame_id, //
icc->layers.slot_id, // icc->layers.slot_id, //
iccs->id, // iccs->id, //
value, // value, //

10
src/xrt/ipc/server/ipc_server_handler.c
View file

@ -790,7 +790,6 @@ _update_layers(volatile struct ipc_client_state *ics, struct xrt_compositor *xc,
xrt_result_t xrt_result_t
ipc_handle_compositor_layer_sync(volatile struct ipc_client_state *ics, ipc_handle_compositor_layer_sync(volatile struct ipc_client_state *ics,
int64_t frame_id,
uint32_t slot_id, uint32_t slot_id,
uint32_t *out_free_slot_id, uint32_t *out_free_slot_id,
const xrt_graphics_sync_handle_t *handles, const xrt_graphics_sync_handle_t *handles,
@ -826,11 +825,11 @@ ipc_handle_compositor_layer_sync(volatile struct ipc_client_state *ics,
* Transfer data to underlying compositor. * Transfer data to underlying compositor.
*/ */
xrt_comp_layer_begin(ics->xc, frame_id, copy.display_time_ns, copy.env_blend_mode); xrt_comp_layer_begin(ics->xc, &copy.data);
_update_layers(ics, ics->xc, &copy); _update_layers(ics, ics->xc, &copy);
xrt_comp_layer_commit(ics->xc, frame_id, sync_handle); xrt_comp_layer_commit(ics->xc, sync_handle);
/* /*
@ -849,7 +848,6 @@ ipc_handle_compositor_layer_sync(volatile struct ipc_client_state *ics,
xrt_result_t xrt_result_t
ipc_handle_compositor_layer_sync_with_semaphore(volatile struct ipc_client_state *ics, ipc_handle_compositor_layer_sync_with_semaphore(volatile struct ipc_client_state *ics,
int64_t frame_id,
uint32_t slot_id, uint32_t slot_id,
uint32_t semaphore_id, uint32_t semaphore_id,
uint64_t semaphore_value, uint64_t semaphore_value,
@ -883,11 +881,11 @@ ipc_handle_compositor_layer_sync_with_semaphore(volatile struct ipc_client_state
* Transfer data to underlying compositor. * Transfer data to underlying compositor.
*/ */
xrt_comp_layer_begin(ics->xc, frame_id, copy.display_time_ns, copy.env_blend_mode); xrt_comp_layer_begin(ics->xc, &copy.data);
_update_layers(ics, ics->xc, &copy); _update_layers(ics, ics->xc, &copy);
xrt_comp_layer_commit_with_semaphore(ics->xc, frame_id, xcsem, semaphore_value); xrt_comp_layer_commit_with_semaphore(ics->xc, xcsem, semaphore_value);
/* /*

3
src/xrt/ipc/shared/ipc_protocol.h
View file

@ -161,8 +161,7 @@ struct ipc_layer_entry
*/ */
struct ipc_layer_slot struct ipc_layer_slot
{ {
uint64_t display_time_ns; struct xrt_layer_frame_data data;
enum xrt_blend_mode env_blend_mode;
uint32_t layer_count; uint32_t layer_count;
struct ipc_layer_entry layers[IPC_MAX_LAYERS]; struct ipc_layer_entry layers[IPC_MAX_LAYERS];
}; };

2
src/xrt/ipc/shared/proto.json
View file

@ -164,7 +164,6 @@
"compositor_layer_sync": { "compositor_layer_sync": {
"in": [ "in": [
{"name": "frame_id", "type": "int64_t"},
{"name": "slot_id", "type": "uint32_t"} {"name": "slot_id", "type": "uint32_t"}
], ],
"in_handles": {"type": "xrt_graphics_sync_handle_t"}, "in_handles": {"type": "xrt_graphics_sync_handle_t"},
@ -175,7 +174,6 @@
"compositor_layer_sync_with_semaphore": { "compositor_layer_sync_with_semaphore": {
"in": [ "in": [
{"name": "frame_id", "type": "int64_t"},
{"name": "slot_id", "type": "uint32_t"}, {"name": "slot_id", "type": "uint32_t"},
{"name": "semaphore_id", "type": "uint32_t"}, {"name": "semaphore_id", "type": "uint32_t"},
{"name": "semaphore_value", "type": "uint64_t"} {"name": "semaphore_value", "type": "uint64_t"}

10
src/xrt/state_trackers/oxr/oxr_session_frame_end.c
View file

@ -1402,8 +1402,14 @@ oxr_session_frame_end(struct oxr_logger *log, struct oxr_session *sess, const Xr
struct xrt_pose inv_offset = {0}; struct xrt_pose inv_offset = {0};
math_pose_invert(&xdev->tracking_origin->offset, &inv_offset); math_pose_invert(&xdev->tracking_origin->offset, &inv_offset);
struct xrt_layer_frame_data data = {
.frame_id = sess->frame_id.begun,
.display_time_ns = xrt_display_time_ns,
.env_blend_mode = blend_mode,
};
xrt_result_t xret; xrt_result_t xret;
xret = xrt_comp_layer_begin(xc, sess->frame_id.begun, xrt_display_time_ns, blend_mode); xret = xrt_comp_layer_begin(xc, &data);
OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_begin); OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_begin);
for (uint32_t i = 0; i < frameEndInfo->layerCount; i++) { for (uint32_t i = 0; i < frameEndInfo->layerCount; i++) {
@ -1439,7 +1445,7 @@ oxr_session_frame_end(struct oxr_logger *log, struct oxr_session *sess, const Xr
} }
} }
xret = xrt_comp_layer_commit(xc, sess->frame_id.begun, XRT_GRAPHICS_SYNC_HANDLE_INVALID); xret = xrt_comp_layer_commit(xc, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_commit); OXR_CHECK_XRET(log, sess, xret, xrt_comp_layer_commit);
sess->frame_id.begun = -1; sess->frame_id.begun = -1;

3
src/xrt/targets/sdl_test/sdl_compositor.c
View file

@ -417,12 +417,13 @@ sdl_compositor_discard_frame(struct xrt_compositor *xc, int64_t frame_id)
} }
static xrt_result_t static xrt_result_t
sdl_compositor_layer_commit(struct xrt_compositor *xc, int64_t frame_id, xrt_graphics_sync_handle_t sync_handle) sdl_compositor_layer_commit(struct xrt_compositor *xc, xrt_graphics_sync_handle_t sync_handle)
{ {
COMP_TRACE_MARKER(); COMP_TRACE_MARKER();
struct sdl_program *sp = from_comp(xc); struct sdl_program *sp = from_comp(xc);
struct sdl_compositor *c = &sp->c; struct sdl_compositor *c = &sp->c;
int64_t frame_id = c->base.slot.data.frame_id;
SC_TRACE(c, "LAYER_COMMIT"); SC_TRACE(c, "LAYER_COMMIT");