xrt/compositor: use int64_t for timestamps

Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2298>

src/xrt/compositor/client/comp_d3d11_client.cpp

···
 struct client_d3d11_swapchain;
 
 static inline DWORD
-convertTimeoutToWindowsMilliseconds(uint64_t timeout_ns)
+convertTimeoutToWindowsMilliseconds(int64_t timeout_ns)
 {
-	return (timeout_ns == XRT_INFINITE_DURATION) ? INFINITE : (DWORD)(timeout_ns / (uint64_t)U_TIME_1MS_IN_NS);
+	return (timeout_ns == XRT_INFINITE_DURATION) ? INFINITE : (DWORD)(timeout_ns / (int64_t)U_TIME_1MS_IN_NS);
 }
 
 /*!
···
 }
 
 static xrt_result_t
-client_d3d11_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+client_d3d11_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	struct client_d3d11_swapchain *sc = as_client_d3d11_swapchain(xsc);
 
···
 static xrt_result_t
 client_d3d11_compositor_wait_frame(struct xrt_compositor *xc,
                                    int64_t *out_frame_id,
-                                   uint64_t *predicted_display_time,
-                                   uint64_t *predicted_display_period)
+                                   int64_t *predicted_display_time,
+                                   int64_t *predicted_display_period)
 {
 	struct client_d3d11_compositor *c = as_client_d3d11_compositor(xc);
 

src/xrt/compositor/client/comp_d3d12_client.cpp

···
 struct client_d3d12_swapchain;
 
 static inline DWORD
-convertTimeoutToWindowsMilliseconds(uint64_t timeout_ns)
+convertTimeoutToWindowsMilliseconds(int64_t timeout_ns)
 {
-	return (timeout_ns == XRT_INFINITE_DURATION) ? INFINITE : (DWORD)(timeout_ns / (uint64_t)U_TIME_1MS_IN_NS);
+	return (timeout_ns == XRT_INFINITE_DURATION) ? INFINITE : (DWORD)(timeout_ns / (int64_t)U_TIME_1MS_IN_NS);
 }
 
 static inline bool
···
 }
 
 static xrt_result_t
-client_d3d12_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+client_d3d12_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	struct client_d3d12_swapchain *sc = as_client_d3d12_swapchain(xsc);
 
···
 static xrt_result_t
 client_d3d12_compositor_wait_frame(struct xrt_compositor *xc,
                                    int64_t *out_frame_id,
-                                   uint64_t *predicted_display_time,
-                                   uint64_t *predicted_display_period)
+                                   int64_t *predicted_display_time,
+                                   int64_t *predicted_display_period)
 {
 	struct client_d3d12_compositor *c = as_client_d3d12_compositor(xc);
 

src/xrt/compositor/client/comp_gl_client.c

···
 }
 
 static xrt_result_t
-client_gl_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+client_gl_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	// Pipe down call into native swapchain.
 	return xrt_swapchain_wait_image(to_native_swapchain(xsc), timeout_ns, index);
···
 static xrt_result_t
 client_gl_compositor_wait_frame(struct xrt_compositor *xc,
                                 int64_t *out_frame_id,
-                                uint64_t *predicted_display_time,
-                                uint64_t *predicted_display_period)
+                                int64_t *predicted_display_time,
+                                int64_t *predicted_display_period)
 {
 	// Pipe down call into native compositor.
 	return xrt_comp_wait_frame(    //

src/xrt/compositor/client/comp_vk_client.c

···
 }
 
 static xrt_result_t
-client_vk_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+client_vk_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	COMP_TRACE_MARKER();
 
···
 static xrt_result_t
 client_vk_compositor_wait_frame(struct xrt_compositor *xc,
                                 int64_t *out_frame_id,
-                                uint64_t *predicted_display_time,
-                                uint64_t *predicted_display_period)
+                                int64_t *predicted_display_time,
+                                int64_t *predicted_display_period)
 {
 	COMP_TRACE_MARKER();
 

src/xrt/compositor/main/comp_compositor.c

···
 static xrt_result_t
 compositor_predict_frame(struct xrt_compositor *xc,
                          int64_t *out_frame_id,
-                         uint64_t *out_wake_time_ns,
-                         uint64_t *out_predicted_gpu_time_ns,
-                         uint64_t *out_predicted_display_time_ns,
-                         uint64_t *out_predicted_display_period_ns)
+                         int64_t *out_wake_time_ns,
+                         int64_t *out_predicted_gpu_time_ns,
+                         int64_t *out_predicted_display_time_ns,
+                         int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 	COMP_SPEW(c, "PREDICT_FRAME");
 
 	// A little bit easier to read.
-	uint64_t interval_ns = (int64_t)c->settings.nominal_frame_interval_ns;
+	int64_t interval_ns = (int64_t)c->settings.nominal_frame_interval_ns;
 
 	comp_target_update_timings(c->target);
 
 	assert(comp_frame_is_invalid_locked(&c->frame.waited));
 
 	int64_t frame_id = -1;
-	uint64_t wake_up_time_ns = 0;
-	uint64_t present_slop_ns = 0;
-	uint64_t desired_present_time_ns = 0;
-	uint64_t predicted_display_time_ns = 0;
+	int64_t wake_up_time_ns = 0;
+	int64_t present_slop_ns = 0;
+	int64_t desired_present_time_ns = 0;
+	int64_t predicted_display_time_ns = 0;
 	comp_target_calc_frame_pacing(   //
 	    c->target,                   //
 	    &frame_id,                   //
···
 compositor_mark_frame(struct xrt_compositor *xc,
                       int64_t frame_id,
                       enum xrt_compositor_frame_point point,
-                      uint64_t when_ns)
+                      int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 

src/xrt/compositor/main/comp_settings.h

···
 	bool print_modes;
 
 	//! Nominal frame interval
-	uint64_t nominal_frame_interval_ns;
+	int64_t nominal_frame_interval_ns;
 
 	//! Vulkan physical device selected by comp_settings_check_vulkan_caps
 	//! may be forced by user

src/xrt/compositor/main/comp_target.h

···
 	                    VkQueue queue,
 	                    uint32_t index,
 	                    uint64_t timeline_semaphore_value,
-	                    uint64_t desired_present_time_ns,
-	                    uint64_t present_slop_ns);
+	                    int64_t desired_present_time_ns,
+	                    int64_t present_slop_ns);
 
 	/*!
 	 * Flush any WSI state before rendering.
···
 	 */
 	void (*calc_frame_pacing)(struct comp_target *ct,
 	                          int64_t *out_frame_id,
-	                          uint64_t *out_wake_up_time_ns,
-	                          uint64_t *out_desired_present_time_ns,
-	                          uint64_t *out_present_slop_ns,
-	                          uint64_t *out_predicted_display_time_ns);
+	                          int64_t *out_wake_up_time_ns,
+	                          int64_t *out_desired_present_time_ns,
+	                          int64_t *out_present_slop_ns,
+	                          int64_t *out_predicted_display_time_ns);
 
 	/*!
 	 * The compositor tells the target a timing information about a single
···
 	void (*mark_timing_point)(struct comp_target *ct,
 	                          enum comp_target_timing_point point,
 	                          int64_t frame_id,
-	                          uint64_t when_ns);
+	                          int64_t when_ns);
 
 	/*!
 	 * Update timing information for this target, this function should be
···
 	 * @see @ref frame-pacing.
 	 */
 	void (*info_gpu)(
-	    struct comp_target *ct, int64_t frame_id, uint64_t gpu_start_ns, uint64_t gpu_end_ns, uint64_t when_ns);
+	    struct comp_target *ct, int64_t frame_id, int64_t gpu_start_ns, int64_t gpu_end_ns, int64_t when_ns);
 
 	/*
 	 *
···
                     VkQueue queue,
                     uint32_t index,
                     uint64_t timeline_semaphore_value,
-                    uint64_t desired_present_time_ns,
-                    uint64_t present_slop_ns)
+                    int64_t desired_present_time_ns,
+                    int64_t present_slop_ns)
 
 {
 	COMP_TRACE_MARKER();
···
 static inline void
 comp_target_calc_frame_pacing(struct comp_target *ct,
                               int64_t *out_frame_id,
-                              uint64_t *out_wake_up_time_ns,
-                              uint64_t *out_desired_present_time_ns,
-                              uint64_t *out_present_slop_ns,
-                              uint64_t *out_predicted_display_time_ns)
+                              int64_t *out_wake_up_time_ns,
+                              int64_t *out_desired_present_time_ns,
+                              int64_t *out_present_slop_ns,
+                              int64_t *out_predicted_display_time_ns)
 {
 	COMP_TRACE_MARKER();
 
···
  * @ingroup comp_main
  */
 static inline void
-comp_target_mark_wake_up(struct comp_target *ct, int64_t frame_id, uint64_t when_woke_ns)
+comp_target_mark_wake_up(struct comp_target *ct, int64_t frame_id, int64_t when_woke_ns)
 {
 	COMP_TRACE_MARKER();
 
···
  * @ingroup comp_main
  */
 static inline void
-comp_target_mark_begin(struct comp_target *ct, int64_t frame_id, uint64_t when_began_ns)
+comp_target_mark_begin(struct comp_target *ct, int64_t frame_id, int64_t when_began_ns)
 {
 	COMP_TRACE_MARKER();
 
···
  * @ingroup comp_main
  */
 static inline void
-comp_target_mark_submit_begin(struct comp_target *ct, int64_t frame_id, uint64_t when_submit_began_ns)
+comp_target_mark_submit_begin(struct comp_target *ct, int64_t frame_id, int64_t when_submit_began_ns)
 {
 	COMP_TRACE_MARKER();
 
···
  * @ingroup comp_main
  */
 static inline void
-comp_target_mark_submit_end(struct comp_target *ct, int64_t frame_id, uint64_t when_submit_end_ns)
+comp_target_mark_submit_end(struct comp_target *ct, int64_t frame_id, int64_t when_submit_end_ns)
 {
 	COMP_TRACE_MARKER();
 
···
  */
 static inline void
 comp_target_info_gpu(
-    struct comp_target *ct, int64_t frame_id, uint64_t gpu_start_ns, uint64_t gpu_end_ns, uint64_t when_ns)
+    struct comp_target *ct, int64_t frame_id, int64_t gpu_start_ns, int64_t gpu_end_ns, int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 

src/xrt/compositor/main/comp_target_swapchain.c

···
 	    cts->swapchain.handle,             //
 	    &count,                            //
 	    timings);                          //
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 	for (uint32_t i = 0; i < count; i++) {
 		u_pc_info(cts->upc,                       //
 		          timings[i].presentID,           //
···
 		return;
 	}
 
-	uint64_t last_vblank_ns;
+	int64_t last_vblank_ns;
 
 	os_thread_helper_lock(&cts->vblank.event_thread);
 	last_vblank_ns = cts->vblank.last_vblank_ns;
···
 }
 
 static bool
-vblank_event_func(struct comp_target *ct, uint64_t *out_timestamp_ns)
+vblank_event_func(struct comp_target *ct, int64_t *out_timestamp_ns)
 {
 	struct comp_target_swapchain *cts = (struct comp_target_swapchain *)ct;
 
···
 	ret = vk->vkWaitForFences(vk->device, 1, &vblank_event_fence, true, time_s_to_ns(1));
 
 	// As quickly as possible after the fence has fired.
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	bool valid = false;
 	if (ret == VK_SUCCESS) {
···
 		// Unlock while waiting.
 		os_thread_helper_unlock(&cts->vblank.event_thread);
 
-		uint64_t when_ns = 0;
+		int64_t when_ns = 0;
 		bool valid = vblank_event_func(ct, &when_ns);
 
 		// Just keep swimming.
···
 	VkBool32 supported;
 	VkResult ret;
 
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 	// Some platforms really don't like the pacing_compositor code.
 	bool use_display_timing_if_available = cts->timing_usage == COMP_TARGET_USE_DISPLAY_IF_AVAILABLE;
 	if (cts->upc == NULL && use_display_timing_if_available && vk->has_GOOGLE_display_timing) {
···
                               VkQueue queue,
                               uint32_t index,
                               uint64_t timeline_semaphore_value,
-                              uint64_t desired_present_time_ns,
-                              uint64_t present_slop_ns)
+                              int64_t desired_present_time_ns,
+                              int64_t present_slop_ns)
 {
 	struct comp_target_swapchain *cts = (struct comp_target_swapchain *)ct;
 	struct vk_bundle *vk = get_vk(cts);
···
 static void
 comp_target_swapchain_calc_frame_pacing(struct comp_target *ct,
                                         int64_t *out_frame_id,
-                                        uint64_t *out_wake_up_time_ns,
-                                        uint64_t *out_desired_present_time_ns,
-                                        uint64_t *out_present_slop_ns,
-                                        uint64_t *out_predicted_display_time_ns)
+                                        int64_t *out_wake_up_time_ns,
+                                        int64_t *out_desired_present_time_ns,
+                                        int64_t *out_present_slop_ns,
+                                        int64_t *out_predicted_display_time_ns)
 {
 	struct comp_target_swapchain *cts = (struct comp_target_swapchain *)ct;
 
 	int64_t frame_id = -1;
-	uint64_t wake_up_time_ns = 0;
-	uint64_t desired_present_time_ns = 0;
-	uint64_t present_slop_ns = 0;
-	uint64_t predicted_display_time_ns = 0;
-	uint64_t predicted_display_period_ns = 0;
-	uint64_t min_display_period_ns = 0;
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t wake_up_time_ns = 0;
+	int64_t desired_present_time_ns = 0;
+	int64_t present_slop_ns = 0;
+	int64_t predicted_display_time_ns = 0;
+	int64_t predicted_display_period_ns = 0;
+	int64_t min_display_period_ns = 0;
+	int64_t now_ns = os_monotonic_get_ns();
 
 	u_pc_predict(cts->upc,                     //
 	             now_ns,                       //
···
 comp_target_swapchain_mark_timing_point(struct comp_target *ct,
                                         enum comp_target_timing_point point,
                                         int64_t frame_id,
-                                        uint64_t when_ns)
+                                        int64_t when_ns)
 {
 	struct comp_target_swapchain *cts = (struct comp_target_swapchain *)ct;
 	assert(frame_id == cts->current_frame_id);
···
 
 static void
 comp_target_swapchain_info_gpu(
-    struct comp_target *ct, int64_t frame_id, uint64_t gpu_start_ns, uint64_t gpu_end_ns, uint64_t when_ns)
+    struct comp_target *ct, int64_t frame_id, int64_t gpu_start_ns, int64_t gpu_end_ns, int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 

src/xrt/compositor/mock/mock_compositor.cpp

···
 }
 
 static xrt_result_t
-mock_compositor_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+mock_compositor_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	struct mock_compositor_swapchain *mcsc = mock_compositor_swapchain(xsc);
 	struct mock_compositor *mc = mcsc->mc;

src/xrt/compositor/multi/comp_multi_compositor.c

···
 slot_clear_locked(struct multi_compositor *mc, struct multi_layer_slot *slot)
 {
 	if (slot->active) {
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 		u_pa_retired(mc->upa, slot->data.frame_id, now_ns);
 	}
 
···
 	xrt_result_t ret = XRT_SUCCESS;
 
 	// 100ms
-	uint64_t timeout_ns = 100 * U_TIME_1MS_IN_NS;
+	int64_t timeout_ns = 100 * U_TIME_1MS_IN_NS;
 
 	do {
 		ret = xrt_compositor_fence_wait(*xcf_ptr, timeout_ns);
···
 	xrt_result_t ret = XRT_SUCCESS;
 
 	// 100ms
-	uint64_t timeout_ns = 100 * U_TIME_1MS_IN_NS;
+	int64_t timeout_ns = 100 * U_TIME_1MS_IN_NS;
 
 	do {
 		ret = xrt_compositor_semaphore_wait(*xcsem_ptr, value, timeout_ns);
···
 		}
 
 		// Sample time outside of lock.
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 
 		os_mutex_lock(&mc->msc->list_and_timing_lock);
 		u_pa_mark_gpu_done(mc->upa, frame_id, now_ns);
···
 static xrt_result_t
 multi_compositor_predict_frame(struct xrt_compositor *xc,
                                int64_t *out_frame_id,
-                               uint64_t *out_wake_time_ns,
-                               uint64_t *out_predicted_gpu_time_ns,
-                               uint64_t *out_predicted_display_time_ns,
-                               uint64_t *out_predicted_display_period_ns)
+                               int64_t *out_wake_time_ns,
+                               int64_t *out_predicted_gpu_time_ns,
+                               int64_t *out_predicted_display_time_ns,
+                               int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
 	struct multi_compositor *mc = multi_compositor(xc);
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 	os_mutex_lock(&mc->msc->list_and_timing_lock);
 
 	u_pa_predict(                         //
···
 multi_compositor_mark_frame(struct xrt_compositor *xc,
                             int64_t frame_id,
                             enum xrt_compositor_frame_point point,
-                            uint64_t when_ns)
+                            int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 
 	struct multi_compositor *mc = multi_compositor(xc);
 
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	switch (point) {
 	case XRT_COMPOSITOR_FRAME_POINT_WOKE:
···
 static xrt_result_t
 multi_compositor_wait_frame(struct xrt_compositor *xc,
                             int64_t *out_frame_id,
-                            uint64_t *out_predicted_display_time_ns,
-                            uint64_t *out_predicted_display_period_ns)
+                            int64_t *out_predicted_display_time_ns,
+                            int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
 	struct multi_compositor *mc = multi_compositor(xc);
 
 	int64_t frame_id = -1;
-	uint64_t wake_up_time_ns = 0;
-	uint64_t predicted_gpu_time_ns = 0;
+	int64_t wake_up_time_ns = 0;
+	int64_t predicted_gpu_time_ns = 0;
 
 	xrt_comp_predict_frame(               //
 	    xc,                               //
···
 	// Wait until the given wake up time.
 	u_wait_until(&mc->frame_sleeper, wake_up_time_ns);
 
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	// Signal that we woke up.
 	xrt_comp_mark_frame(xc, frame_id, XRT_COMPOSITOR_FRAME_POINT_WOKE, now_ns);
···
 	struct multi_compositor *mc = multi_compositor(xc);
 
 	os_mutex_lock(&mc->msc->list_and_timing_lock);
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 	u_pa_mark_point(mc->upa, frame_id, U_TIMING_POINT_BEGIN, now_ns);
 	os_mutex_unlock(&mc->msc->list_and_timing_lock);
 
···
 	COMP_TRACE_MARKER();
 
 	struct multi_compositor *mc = multi_compositor(xc);
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	os_mutex_lock(&mc->msc->list_and_timing_lock);
 	u_pa_mark_discarded(mc->upa, frame_id, now_ns);
···
 	struct multi_compositor *mc = multi_compositor(xc);
 
 	// As early as possible.
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 	os_mutex_lock(&mc->msc->list_and_timing_lock);
 	u_pa_mark_delivered(mc->upa, data->frame_id, now_ns, data->display_time_ns);
 	os_mutex_unlock(&mc->msc->list_and_timing_lock);
···
 		push_fence_to_wait_thread(mc, frame_id, xcf);
 	} else {
 		// Assume that the app side compositor waited.
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 
 		os_mutex_lock(&mc->msc->list_and_timing_lock);
 		u_pa_mark_gpu_done(mc->upa, frame_id, now_ns);
···
 }
 
 static void
-log_frame_time_diff(uint64_t frame_time_ns, uint64_t display_time_ns)
+log_frame_time_diff(int64_t frame_time_ns, int64_t display_time_ns)
 {
 	int64_t diff_ns = (int64_t)frame_time_ns - (int64_t)display_time_ns;
 	bool late = false;
···
 }
 
 void
-multi_compositor_deliver_any_frames(struct multi_compositor *mc, uint64_t display_time_ns)
+multi_compositor_deliver_any_frames(struct multi_compositor *mc, int64_t display_time_ns)
 {
 	os_mutex_lock(&mc->slot_lock);
 
···
 	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);
 
-		uint64_t frame_time_ns = mc->delivered.data.display_time_ns;
+		int64_t frame_time_ns = mc->delivered.data.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);
 		}
···
 }
 
 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, int64_t when_ns, int64_t system_frame_id)
 {
 	u_pa_latched(mc->upa, mc->delivered.data.frame_id, when_ns, system_frame_id);
 }
 
 void
-multi_compositor_retire_delivered_locked(struct multi_compositor *mc, uint64_t when_ns)
+multi_compositor_retire_delivered_locked(struct multi_compositor *mc, int64_t when_ns)
 {
 	slot_clear_locked(mc, &mc->delivered);
 }

src/xrt/compositor/multi/comp_multi_private.h

···
 	/*!
 	 * The next which the next frames to be picked up will be displayed.
 	 */
-	uint64_t slot_next_frame_display;
+	int64_t slot_next_frame_display;
 
 	/*!
 	 * Currently being transferred or waited on.
···
  * @private @memberof multi_compositor
  */
 void
-multi_compositor_deliver_any_frames(struct multi_compositor *mc, uint64_t display_time_ns);
+multi_compositor_deliver_any_frames(struct multi_compositor *mc, int64_t display_time_ns);
 
 /*!
  * Makes the current delivered frame as latched, called by the render thread.
···
  * @private @memberof multi_compositor
  */
 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, int64_t when_ns, int64_t system_frame_id);
 
 /*!
  * Clears and retires the delivered frame, called by the render thread.
···
  * @private @memberof multi_compositor
  */
 void
-multi_compositor_retire_delivered_locked(struct multi_compositor *mc, uint64_t when_ns);
+multi_compositor_retire_delivered_locked(struct multi_compositor *mc, int64_t when_ns);
 
 
 /*
···
 
 	struct
 	{
-		uint64_t predicted_display_time_ns;
-		uint64_t predicted_display_period_ns;
-		uint64_t diff_ns;
+		int64_t predicted_display_time_ns;
+		int64_t predicted_display_period_ns;
+		int64_t diff_ns;
 	} last_timings;
 
 	//! List of active clients.

src/xrt/compositor/multi/comp_multi_system.c

···
 }
 
 static void
-transfer_layers_locked(struct multi_system_compositor *msc, uint64_t display_time_ns, int64_t system_frame_id)
+transfer_layers_locked(struct multi_system_compositor *msc, int64_t display_time_ns, int64_t system_frame_id)
 {
 	COMP_TRACE_MARKER();
 
···
 	struct multi_compositor *array[MULTI_MAX_CLIENTS] = {0};
 
 	// To mark latching.
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	size_t count = 0;
 	for (size_t k = 0; k < ARRAY_SIZE(array); k++) {
···
 }
 
 static void
-broadcast_timings_to_clients(struct multi_system_compositor *msc, uint64_t predicted_display_time_ns)
+broadcast_timings_to_clients(struct multi_system_compositor *msc, int64_t predicted_display_time_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 
 static void
 broadcast_timings_to_pacers(struct multi_system_compositor *msc,
-                            uint64_t predicted_display_time_ns,
-                            uint64_t predicted_display_period_ns,
-                            uint64_t diff_ns)
+                            int64_t predicted_display_time_ns,
+                            int64_t predicted_display_period_ns,
+                            int64_t diff_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 }
 
 static void
-wait_frame(struct os_precise_sleeper *sleeper, struct xrt_compositor *xc, int64_t frame_id, uint64_t wake_up_time_ns)
+wait_frame(struct os_precise_sleeper *sleeper, struct xrt_compositor *xc, int64_t frame_id, int64_t wake_up_time_ns)
 {
 	COMP_TRACE_MARKER();
 
 	// Wait until the given wake up time.
 	u_wait_until(sleeper, wake_up_time_ns);
 
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	// Signal that we woke up.
 	xrt_comp_mark_frame(xc, frame_id, XRT_COMPOSITOR_FRAME_POINT_WOKE, now_ns);
···
 		os_thread_helper_unlock(&msc->oth);
 
 		int64_t frame_id = -1;
-		uint64_t wake_up_time_ns = 0;
-		uint64_t predicted_gpu_time_ns = 0;
-		uint64_t predicted_display_time_ns = 0;
-		uint64_t predicted_display_period_ns = 0;
+		int64_t wake_up_time_ns = 0;
+		int64_t predicted_gpu_time_ns = 0;
+		int64_t predicted_display_time_ns = 0;
+		int64_t predicted_display_period_ns = 0;
 
 		// Get the information for the next frame.
 		xrt_comp_predict_frame(            //
···
 		// Now we can wait.
 		wait_frame(&sleeper, xc, frame_id, wake_up_time_ns);
 
-		uint64_t now_ns = os_monotonic_get_ns();
-		uint64_t diff_ns = predicted_display_time_ns - now_ns;
+		int64_t now_ns = os_monotonic_get_ns();
+		int64_t diff_ns = predicted_display_time_ns - now_ns;
 
 		// Now we know the diff, broadcast to pacers.
 		broadcast_timings_to_pacers(msc, predicted_display_time_ns, predicted_display_period_ns, diff_ns);
···
 static xrt_result_t
 system_compositor_notify_loss_pending(struct xrt_system_compositor *xsc,
                                       struct xrt_compositor *xc,
-                                      uint64_t loss_time_ns)
+                                      int64_t loss_time_ns)
 {
 	struct multi_system_compositor *msc = multi_system_compositor(xsc);
 	struct multi_compositor *mc = multi_compositor(xc);

src/xrt/compositor/null/null_compositor.c

···
 static xrt_result_t
 null_compositor_predict_frame(struct xrt_compositor *xc,
                               int64_t *out_frame_id,
-                              uint64_t *out_wake_time_ns,
-                              uint64_t *out_predicted_gpu_time_ns,
-                              uint64_t *out_predicted_display_time_ns,
-                              uint64_t *out_predicted_display_period_ns)
+                              int64_t *out_wake_time_ns,
+                              int64_t *out_predicted_gpu_time_ns,
+                              int64_t *out_predicted_display_time_ns,
+                              int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
 	struct null_compositor *c = null_compositor(xc);
 	NULL_TRACE(c, "PREDICT_FRAME");
 
-	uint64_t now_ns = os_monotonic_get_ns();
-	uint64_t null_desired_present_time_ns = 0;
-	uint64_t null_present_slop_ns = 0;
-	uint64_t null_min_display_period_ns = 0;
+	int64_t now_ns = os_monotonic_get_ns();
+	int64_t null_desired_present_time_ns = 0;
+	int64_t null_present_slop_ns = 0;
+	int64_t null_min_display_period_ns = 0;
 
 	u_pc_predict(                        //
 	    c->upc,                          // upc
···
 null_compositor_mark_frame(struct xrt_compositor *xc,
                            int64_t frame_id,
                            enum xrt_compositor_frame_point point,
-                           uint64_t when_ns)
+                           int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 
 	// When we begin rendering.
 	{
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 		u_pc_mark_point(c->upc, U_TIMING_POINT_BEGIN, frame_id, now_ns);
 	}
 
 	// When we are submitting to the GPU.
 	{
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 		u_pc_mark_point(c->upc, U_TIMING_POINT_SUBMIT_BEGIN, frame_id, now_ns);
 
 		now_ns = os_monotonic_get_ns();

src/xrt/compositor/util/comp_base.c

···
 static xrt_result_t
 base_wait_frame(struct xrt_compositor *xc,
                 int64_t *out_frame_id,
-                uint64_t *out_predicted_display_time_ns,
-                uint64_t *out_predicted_display_period_ns)
+                int64_t *out_predicted_display_time_ns,
+                int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
 	struct comp_base *cb = comp_base(xc);
 
 	int64_t frame_id = -1;
-	uint64_t wake_up_time_ns = 0;
-	uint64_t predicted_gpu_time_ns = 0;
+	int64_t wake_up_time_ns = 0;
+	int64_t predicted_gpu_time_ns = 0;
 
 	xrt_comp_predict_frame(               //
 	    xc,                               //
···
 	// Wait until the given wake up time.
 	u_wait_until(&cb->sleeper, wake_up_time_ns);
 
-	uint64_t now_ns = os_monotonic_get_ns();
+	int64_t now_ns = os_monotonic_get_ns();
 
 	// Signal that we woke up.
 	xrt_comp_mark_frame(xc, frame_id, XRT_COMPOSITOR_FRAME_POINT_WOKE, now_ns);

src/xrt/compositor/util/comp_swapchain.c

···
 }
 
 static xrt_result_t
-swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	struct comp_swapchain *sc = comp_swapchain(xsc);
 
···
 	}
 
 	// on windows pthread_cond_timedwait can not be used with monotonic time
-	uint64_t start_wait_rt = os_realtime_get_ns();
+	int64_t start_wait_rt = os_realtime_get_ns();
 
-	uint64_t end_wait_rt;
+	int64_t end_wait_rt;
 	// don't wrap on big or indefinite timeout
-	if (start_wait_rt > UINT64_MAX - timeout_ns) {
-		end_wait_rt = UINT64_MAX;
+	if (start_wait_rt > INT64_MAX - timeout_ns) {
+		end_wait_rt = INT64_MAX;
 	} else {
 		end_wait_rt = start_wait_rt + timeout_ns;
 	}
···
 		// use pthread_cond_timedwait to implement timeout behavior
 		ret = pthread_cond_timedwait(&sc->images[index].use_cond, &sc->images[index].use_mutex.mutex, &spec);
 
-		uint64_t now_rt = os_realtime_get_ns();
+		int64_t now_rt = os_realtime_get_ns();
 		double diff = time_ns_to_ms_f(now_rt - start_wait_rt);
 
 		if (ret == 0) {

src/xrt/include/xrt/xrt_compositor.h

···
 	 * @param timeout_ns Timeout in nanoseconds,
 	 * @param index Image index to wait for.
 	 */
-	xrt_result_t (*wait_image)(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index);
+	xrt_result_t (*wait_image)(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index);
 
 	/*!
 	 * Do any barrier transitions to and from the application.
···
  * @public @memberof xrt_swapchain
  */
 static inline xrt_result_t
-xrt_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+xrt_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	return xsc->wait_image(xsc, timeout_ns, index);
 }
···
  */
 
 /*!
- * Compositor fence used for syncornization.
+ * Compositor fence used for synchronization.
  */
 struct xrt_compositor_fence
 {
···
 	 */
 	xrt_result_t (*predict_frame)(struct xrt_compositor *xc,
 	                              int64_t *out_frame_id,
-	                              uint64_t *out_wake_time_ns,
-	                              uint64_t *out_predicted_gpu_time_ns,
-	                              uint64_t *out_predicted_display_time_ns,
-	                              uint64_t *out_predicted_display_period_ns);
+	                              int64_t *out_wake_time_ns,
+	                              int64_t *out_predicted_gpu_time_ns,
+	                              int64_t *out_predicted_display_time_ns,
+	                              int64_t *out_predicted_display_period_ns);
 
 	/*!
 	 * This function and @ref predict_frame function calls are a alternative to
···
 	xrt_result_t (*mark_frame)(struct xrt_compositor *xc,
 	                           int64_t frame_id,
 	                           enum xrt_compositor_frame_point point,
-	                           uint64_t when_ns);
+	                           int64_t when_ns);
 
 	/*!
 	 * See xrWaitFrame.
···
 	 */
 	xrt_result_t (*wait_frame)(struct xrt_compositor *xc,
 	                           int64_t *out_frame_id,
-	                           uint64_t *out_predicted_display_time,
-	                           uint64_t *out_predicted_display_period);
+	                           int64_t *out_predicted_display_time,
+	                           int64_t *out_predicted_display_period);
 
 	/*!
 	 * See xrBeginFrame.
···
 static inline xrt_result_t
 xrt_comp_predict_frame(struct xrt_compositor *xc,
                        int64_t *out_frame_id,
-                       uint64_t *out_wake_time_ns,
-                       uint64_t *out_predicted_gpu_time_ns,
-                       uint64_t *out_predicted_display_time_ns,
-                       uint64_t *out_predicted_display_period_ns)
+                       int64_t *out_wake_time_ns,
+                       int64_t *out_predicted_gpu_time_ns,
+                       int64_t *out_predicted_display_time_ns,
+                       int64_t *out_predicted_display_period_ns)
 {
 	return xc->predict_frame(             //
 	    xc,                               //
···
  * @public @memberof xrt_compositor
  */
 static inline xrt_result_t
-xrt_comp_mark_frame(struct xrt_compositor *xc,
-                    int64_t frame_id,
-                    enum xrt_compositor_frame_point point,
-                    uint64_t when_ns)
+xrt_comp_mark_frame(struct xrt_compositor *xc, int64_t frame_id, enum xrt_compositor_frame_point point, int64_t when_ns)
 {
 	return xc->mark_frame(xc, frame_id, point, when_ns);
 }
···
 static inline xrt_result_t
 xrt_comp_wait_frame(struct xrt_compositor *xc,
                     int64_t *out_frame_id,
-                    uint64_t *out_predicted_display_time,
-                    uint64_t *out_predicted_display_period)
+                    int64_t *out_predicted_display_time,
+                    int64_t *out_predicted_display_period)
 {
 	return xc->wait_frame(xc, out_frame_id, out_predicted_display_time, out_predicted_display_period);
 }
···
 	 */
 	xrt_result_t (*notify_loss_pending)(struct xrt_system_compositor *xsc,
 	                                    struct xrt_compositor *xc,
-	                                    uint64_t loss_time_ns);
+	                                    int64_t loss_time_ns);
 
 	/*!
 	 * Notify this client/session if the compositor lost the ability of rendering.
···
  * @public @memberof xrt_system_compositor
  */
 static inline xrt_result_t
-xrt_syscomp_notify_loss_pending(struct xrt_system_compositor *xsc, struct xrt_compositor *xc, uint64_t loss_time_ns)
+xrt_syscomp_notify_loss_pending(struct xrt_system_compositor *xsc, struct xrt_compositor *xc, int64_t loss_time_ns)
 {
 	if (xsc->xmcc == NULL) {
 		return XRT_ERROR_MULTI_SESSION_NOT_IMPLEMENTED;

src/xrt/ipc/client/ipc_client_compositor.c

···
 }
 
 static xrt_result_t
-ipc_compositor_swapchain_wait_image(struct xrt_swapchain *xsc, uint64_t timeout_ns, uint32_t index)
+ipc_compositor_swapchain_wait_image(struct xrt_swapchain *xsc, int64_t timeout_ns, uint32_t index)
 {
 	struct ipc_client_swapchain *ics = ipc_client_swapchain(xsc);
 	struct ipc_client_compositor *icc = ics->icc;
···
 static xrt_result_t
 ipc_compositor_wait_frame(struct xrt_compositor *xc,
                           int64_t *out_frame_id,
-                          uint64_t *out_predicted_display_time,
-                          uint64_t *out_predicted_display_period)
+                          int64_t *out_predicted_display_time,
+                          int64_t *out_predicted_display_period)
 {
 	IPC_TRACE_MARKER();
 	struct ipc_client_compositor *icc = ipc_client_compositor(xc);
 	xrt_result_t xret;
 
 	int64_t frame_id = -1;
-	uint64_t wake_up_time_ns = 0;
-	uint64_t predicted_display_time = 0;
-	uint64_t predicted_display_period = 0;
+	int64_t wake_up_time_ns = 0;
+	int64_t predicted_display_time = 0;
+	int64_t predicted_display_period = 0;
 
 	xret = ipc_call_compositor_predict_frame( //
 	    icc->ipc_c,                           // Connection

src/xrt/ipc/server/ipc_server_handler.c

···
 xrt_result_t
 ipc_handle_compositor_predict_frame(volatile struct ipc_client_state *ics,
                                     int64_t *out_frame_id,
-                                    uint64_t *out_wake_up_time_ns,
-                                    uint64_t *out_predicted_display_time_ns,
-                                    uint64_t *out_predicted_display_period_ns)
+                                    int64_t *out_wake_up_time_ns,
+                                    int64_t *out_predicted_display_time_ns,
+                                    int64_t *out_predicted_display_period_ns)
 {
 	IPC_TRACE_MARKER();
 
···
 	 */
 	ipc_server_activate_session(ics);
 
-	uint64_t gpu_time_ns = 0;
+	int64_t gpu_time_ns = 0;
 	return xrt_comp_predict_frame(        //
 	    ics->xc,                          //
 	    out_frame_id,                     //
···
 }
 
 xrt_result_t
-ipc_handle_swapchain_wait_image(volatile struct ipc_client_state *ics, uint32_t id, uint64_t timeout_ns, uint32_t index)
+ipc_handle_swapchain_wait_image(volatile struct ipc_client_state *ics, uint32_t id, int64_t timeout_ns, uint32_t index)
 {
 	if (ics->xc == NULL) {
 		return XRT_ERROR_IPC_SESSION_NOT_CREATED;

src/xrt/ipc/shared/proto.json

···
 	"compositor_predict_frame": {
 		"out": [
 			{"name": "frame_id", "type": "int64_t"},
-			{"name": "wake_up_time", "type": "uint64_t"},
-			{"name": "predicted_display_time", "type": "uint64_t"},
-			{"name": "predicted_display_period", "type": "uint64_t"}
+			{"name": "wake_up_time", "type": "int64_t"},
+			{"name": "predicted_display_time", "type": "int64_t"},
+			{"name": "predicted_display_period", "type": "int64_t"}
 		]
 	},
 
···
 	"swapchain_wait_image": {
 		"in": [
 			{"name": "id", "type": "uint32_t"},
-			{"name": "timeout_ns", "type": "uint64_t"},
+			{"name": "timeout_ns", "type": "int64_t"},
 			{"name": "index", "type": "uint32_t"}
 		]
 	},

src/xrt/state_trackers/oxr/oxr_session.c

···
 do_wait_frame_and_checks(struct oxr_logger *log,
                          struct oxr_session *sess,
                          int64_t *out_frame_id,
-                         uint64_t *out_predicted_display_time,
-                         uint64_t *out_predicted_display_period,
+                         int64_t *out_predicted_display_time,
+                         int64_t *out_predicted_display_period,
                          XrTime *out_converted_time)
 {
 	assert(sess->compositor != NULL);
 
 	int64_t frame_id = -1;
-	uint64_t predicted_display_time = 0;
-	uint64_t predicted_display_period = 0;
+	int64_t predicted_display_time = 0;
+	int64_t predicted_display_period = 0;
 
 	xrt_result_t xret = xrt_comp_wait_frame( //
 	    sess->compositor,                    // compositor
···
 	}
 
 	int64_t frame_id = -1;
-	uint64_t predicted_display_time = 0;
-	uint64_t predicted_display_period = 0;
+	int64_t predicted_display_time = 0;
+	int64_t predicted_display_period = 0;
 	XrTime converted_time = 0;
 
 	XrResult ret = do_wait_frame_and_checks( //
···
 	}
 
 	if (sess->frame_timing_wait_sleep_ms > 0) {
-		uint64_t sleep_ns = U_TIME_1MS_IN_NS * sess->frame_timing_wait_sleep_ms;
+		int64_t sleep_ns = U_TIME_1MS_IN_NS * sess->frame_timing_wait_sleep_ms;
 		os_precise_sleeper_nanosleep(&sess->sleeper, sleep_ns);
 	}
 

src/xrt/targets/sdl_test/sdl_compositor.c

···
 static xrt_result_t
 sdl_compositor_predict_frame(struct xrt_compositor *xc,
                              int64_t *out_frame_id,
-                             uint64_t *out_wake_time_ns,
-                             uint64_t *out_predicted_gpu_time_ns,
-                             uint64_t *out_predicted_display_time_ns,
-                             uint64_t *out_predicted_display_period_ns)
+                             int64_t *out_wake_time_ns,
+                             int64_t *out_predicted_gpu_time_ns,
+                             int64_t *out_predicted_display_time_ns,
+                             int64_t *out_predicted_display_period_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 
 	SC_TRACE(c, "PREDICT_FRAME");
 
-	uint64_t now_ns = os_monotonic_get_ns();
-	uint64_t null_desired_present_time_ns = 0;
-	uint64_t null_present_slop_ns = 0;
-	uint64_t null_min_display_period_ns = 0;
+	int64_t now_ns = os_monotonic_get_ns();
+	int64_t null_desired_present_time_ns = 0;
+	int64_t null_present_slop_ns = 0;
+	int64_t null_min_display_period_ns = 0;
 
 	u_pc_predict(                        //
 	    c->upc,                          // upc
···
 sdl_compositor_mark_frame(struct xrt_compositor *xc,
                           int64_t frame_id,
                           enum xrt_compositor_frame_point point,
-                          uint64_t when_ns)
+                          int64_t when_ns)
 {
 	COMP_TRACE_MARKER();
 
···
 
 	// When we begin rendering.
 	{
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 		u_pc_mark_point(c->upc, U_TIMING_POINT_BEGIN, frame_id, now_ns);
 	}
 
···
 
 	// When we are submitting to the GPU.
 	{
-		uint64_t now_ns = os_monotonic_get_ns();
+		int64_t now_ns = os_monotonic_get_ns();
 		u_pc_mark_point(c->upc, U_TIMING_POINT_SUBMIT_BEGIN, frame_id, now_ns);
 
 		now_ns = os_monotonic_get_ns();