Monado OpenXR Runtime: Utilities

Add to target c file to enable tracing, see Tracing support.

◆ U_TYPED_ARRAY_CALLOC

#define U_TYPED_ARRAY_CALLOC	(	TYPE,
		COUNT
	)	((TYPE *)calloc((COUNT), sizeof(TYPE)))

#include <auxiliary/util/u_misc.h>

Allocate and zero the space required for some type, and cast the return type appropriately.

Use instead of a bare calloc when allocating an array of a type. This includes allocating C strings: pass char as the type.

◆ U_TYPED_CALLOC

#define U_TYPED_CALLOC ( TYPE ) ((TYPE *)calloc(1, sizeof(TYPE)))

#include <auxiliary/util/u_misc.h>

Allocate and zero the space required for some type, and cast the return type appropriately.

Use instead of a bare calloc when allocating a single structure.

◆ U_VAR_NAME_STRING_SIZE

#define U_VAR_NAME_STRING_SIZE 256

#include <auxiliary/util/u_var.h>

Maximum string length for a tracked variable.

◆ U_WAIT_MEASURED_SCHEDULER_LATENCY_NS

#define U_WAIT_MEASURED_SCHEDULER_LATENCY_NS (uint64_t)(0)

#include <auxiliary/util/u_wait.h>

OS specific tweak to wait time.

Todo:: Measure on Windows.

◆ U_ZERO

#define U_ZERO ( PTR ) memset((PTR), 0, sizeof(*(PTR)))

#include <auxiliary/util/u_misc.h>

Zeroes the correct amount of memory based on the type pointed-to by the argument.

Use instead of memset(..., 0, ...) on a structure or pointer to structure.

◆ U_ZERO_ARRAY

#define U_ZERO_ARRAY ( ARRAY ) memset((ARRAY), 0, sizeof(ARRAY))

#include <auxiliary/util/u_misc.h>

Zeroes the correct amount of memory based on the type and size of the static array named in the argument.

Use instead of memset(..., 0, ...) on an array.

Typedef Documentation

◆ time_duration_ns

typedef int64_t time_duration_ns

#include <auxiliary/util/u_time.h>

Integer duration type in nanoseconds.

Logical type of timepoint differences.

See also: time_state; timepoint_ns

◆ timepoint_ns

typedef int64_t timepoint_ns

#include <auxiliary/util/u_time.h>

Integer timestamp type.

See also: time_state; time_duration_ns

◆ u_builder_open_system_fn

typedef xrt_result_t(* u_builder_open_system_fn) (struct xrt_builder *xb, cJSON *config, struct xrt_prober *xp, struct xrt_tracking_origin *origin, struct xrt_system_devices *xsysd, struct xrt_frame_context *xfctx, struct u_builder_roles_helper *ubrh)

#include <auxiliary/util/u_builders.h>

Argument to u_builder_roles_helper_open_system and implemented by u_builder::open_system_static_roles function.

A builder implement this function is free to focus on only creating the devices and assigning them initial roles. With this implementation details of the xrt_system_devices and xrt_space_overseer is taken care of by the caller of this function.

◆ u_var_button_cb

typedef void(* u_var_button_cb) (void *)

#include <auxiliary/util/u_var.h>

Callback for a button action.

◆ u_var_curve_getter

typedef struct u_var_curve_point(* u_var_curve_getter) (void *data, int i)

#include <auxiliary/util/u_var.h>

Callback for getting points on a curve.

◆ u_var_elm_cb

typedef void(* u_var_elm_cb) (struct u_var_info *info, void *)

#include <auxiliary/util/u_var.h>

Callback on each variable a root node has.

◆ u_var_root_cb

typedef void(* u_var_root_cb) (struct u_var_root_info *info, void *)

#include <auxiliary/util/u_var.h>

Callback for entering and leaving root nodes.

◆ u_worker_group_func_t

typedef void(* u_worker_group_func_t) (void *)

#include <auxiliary/util/u_worker.h>

Function typedef for tasks.

Enumeration Type Documentation

◆ u_trace_which

enum u_trace_which

References xrt_system_devices::hand_tracking, xrt_system_devices::head, u_system_devices::origin, xrt_system_devices::static_roles, u_builder_create_space_overseer_legacy(), u_system_devices_static_allocate(), u_system_devices_static_finalize(), xrt_system_devices::xdev_count, xrt_system_devices::xdevs, u_system_devices::xfctx, XRT_STRUCT_INIT, XRT_SUCCESS, and xrt_system_devices::xrt_system_devices_destroy().

Should the extra tracks be enabled, see Tracing support.

◆ u_var_kind

enum u_var_kind

#include <auxiliary/util/u_var.h>

What kind of variable is this tracking.

Function Documentation

◆ time_is_greater_then_or_within_half_ms()

static bool time_is_greater_then_or_within_half_ms	(	timepoint_ns	a,
		timepoint_ns	b
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Fuzzy comparisons.

See also: timepoint_ns

References time_is_greater_then_or_within_range(), and U_TIME_HALF_MS_IN_NS.

◆ time_is_greater_then_or_within_range()

static bool time_is_greater_then_or_within_range	(	timepoint_ns	a,
		timepoint_ns	b,
		uint64_t	range
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Fuzzy comparisons.

See also: timepoint_ns

References time_is_within_range_of_each_other().

Referenced by time_is_greater_then_or_within_half_ms().

◆ time_is_less_then_or_within_half_ms()

static bool time_is_less_then_or_within_half_ms	(	timepoint_ns	a,
		timepoint_ns	b
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Fuzzy comparisons.

See also: timepoint_ns

References time_is_less_then_or_within_range(), and U_TIME_HALF_MS_IN_NS.

◆ time_is_less_then_or_within_range()

static bool time_is_less_then_or_within_range	(	timepoint_ns	a,
		timepoint_ns	b,
		uint64_t	range
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Fuzzy comparisons.

See also: timepoint_ns

References time_is_within_range_of_each_other().

Referenced by time_is_less_then_or_within_half_ms(), and u_wait_until().

◆ time_is_within_half_ms()

static bool time_is_within_half_ms	(	timepoint_ns	a,
		timepoint_ns	b
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Checks if two timepoints are with half a millisecond of each other.

See also: timepoint_ns

References time_is_within_range_of_each_other(), and U_TIME_HALF_MS_IN_NS.

◆ time_is_within_range_of_each_other()

static bool time_is_within_range_of_each_other	(	timepoint_ns	a,
		timepoint_ns	b,
		uint64_t	range
	)

inlinestatic

#include <auxiliary/util/u_time.h>

Checks if two timepoints are with a certain range of each other.

See also: timepoint_ns

Referenced by time_is_greater_then_or_within_range(), time_is_less_then_or_within_range(), and time_is_within_half_ms().

◆ time_ms_f_to_ns()

static timepoint_ns time_ms_f_to_ns ( double ms_f )

inlinestatic

#include <auxiliary/util/u_time.h>

Convert double float milliseconds to nanoseconds, human comprehensible config inputs.

Recommended to keep the absolute value of the input relitively small.

See also: timepoint_ns

References U_TIME_1MS_IN_NS.

◆ time_ns_to_ms_f()

static double time_ns_to_ms_f ( time_duration_ns ns )

inlinestatic

#include <auxiliary/util/u_time.h>

Convert nanoseconds to double float milliseconds, useful for printing.

See also: timepoint_ns

References U_TIME_1MS_IN_NS.

Referenced by comp_mirror_to_debug_gui::comp_mirror_fixup_ui_state().

◆ time_ns_to_s()

static double time_ns_to_s ( time_duration_ns ns )

inlinestatic

#include <auxiliary/util/u_time.h>

Convert nanoseconds duration to double seconds.

See also: timepoint_ns

References U_TIME_1S_IN_NS.

Referenced by compositor_get_display_refresh_rate().

◆ time_s_to_ns()

static time_duration_ns time_s_to_ns ( double duration )

inlinestatic

#include <auxiliary/util/u_time.h>

Convert float seconds to nanoseconds.

See also: timepoint_ns

◆ time_state_create()

struct time_state * time_state_create ( uint64_t offset )

Create a struct time_state.

◆ time_state_destroy()

void time_state_destroy ( struct time_state ** state )

Destroy a struct time_state.

Should not be called simultaneously with any other time_state function.

◆ time_state_from_timespec()

timepoint_ns time_state_from_timespec	(	struct time_state const *	state,
		const struct timespec *	timespecTime
	)

Convert a struct timespec (system time) to an integer timestamp.

Should not be called simultaneously with time_state_get_now_and_update.

References time_state::time_state_monotonic_to_ts_ns(), and U_1_000_000_000.

◆ time_state_from_win32perfcounter()

timepoint_ns time_state_from_win32perfcounter	(	struct time_state const *	state,
		const LARGE_INTEGER *	qpc_ticks
	)

Converts from Win32 "QPC" ticks to timestamp.

Should not be called simultaneously with time_state_get_now_and_update.

◆ time_state_get_now()

timepoint_ns time_state_get_now ( struct time_state const * state )

Get the current time as an integer timestamp.

Does not update internal state for timekeeping. Should not be called simultaneously with time_state_get_now_and_update.

References os_monotonic_get_ns(), and time_state::time_state_monotonic_to_ts_ns().

Referenced by time_state::time_state_get_now_and_update().

◆ time_state_get_now_and_update()

timepoint_ns time_state_get_now_and_update ( struct time_state * state )

Get the current time as an integer timestamp and update internal state.

This should be called regularly, but only from one thread. It updates the association between the timing sources.

Should not be called simultaneously with any other time_state function.

References time_state::time_state_get_now().

◆ time_state_monotonic_to_ts_ns()

timepoint_ns time_state_monotonic_to_ts_ns	(	struct time_state const *	state,
		uint64_t	monotonic_ns
	)

Convert a monotonic system time (such as from Portable Timekeeping) to an adjusted integer timestamp.

Adjustments may need to be applied to achieve the other guarantees that e.g. CLOCK_MONOTONIC does not provide: this function performs those adjustments.

Should not be called simultaneously with time_state_get_now_and_update.

Referenced by time_state::time_state_from_timespec(), and time_state::time_state_get_now().

◆ time_state_to_timespec()

void time_state_to_timespec	(	struct time_state const *	state,
		timepoint_ns	timestamp,
		struct timespec *	out
	)

Convert an integer timestamp to a struct timespec (system time).

Should not be called simultaneously with time_state_get_now_and_update.

◆ time_state_to_win32perfcounter()

void time_state_to_win32perfcounter	(	struct time_state const *	state,
		timepoint_ns	timestamp,
		LARGE_INTEGER *	out_qpc_ticks
	)

Converts a timestamp to Win32 "QPC" ticks.

Should not be called simultaneously with time_state_get_now_and_update.

◆ time_state_ts_to_monotonic_ns()

uint64_t time_state_ts_to_monotonic_ns	(	struct time_state const *	state,
		timepoint_ns	timestamp
	)

Convert a adjusted integer timestamp to an monotonic system time (such as from Portable Timekeeping).

Should not be called simultaneously with time_state_get_now_and_update.

Referenced by oxr_session_frame_end(), and oxr_xdev_get_hand_tracking_at().

◆ u_builder_create_space_overseer_legacy()

void u_builder_create_space_overseer_legacy	(	struct xrt_session_event_sink *	broadcast,
		struct xrt_device *	head,
		struct xrt_device *	left,
		struct xrt_device *	right,
		struct xrt_device **	xdevs,
		uint32_t	xdev_count,
		bool	root_is_unbounded,
		struct xrt_space_overseer **	out_xso
	)

#include <auxiliary/util/u_builders.h>

Create a legacy space overseer, most builders probably want to have a more advanced setup then this, especially stand alone ones.

Uses u_builder_setup_tracking_origins internally and u_space_overseer_legacy_setup.

References u_space_overseer::broadcast, u_builder_setup_tracking_origins(), u_space_overseer_create(), u_space_overseer_legacy_setup(), and xrt_pose::XRT_POSE_IDENTITY.

Referenced by u_builder_roles_helper_open_system().

◆ u_builder_find_prober_device()

struct xrt_prober_device* u_builder_find_prober_device	(	struct xrt_prober_device const	xpdevs,
		size_t	xpdev_count,
		uint16_t	vendor_id,
		uint16_t	product_id,
		enum xrt_bus_type	bus_type
	)

#include <auxiliary/util/u_builders.h>

Find the first xrt_prober_device in the prober list.

References xrt_prober_device::bus, xrt_prober_device::product_id, and xrt_prober_device::vendor_id.

◆ u_builder_open_system_static_roles()

xrt_result_t u_builder_open_system_static_roles	(	struct xrt_builder *	xb,
		cJSON *	config,
		struct xrt_prober *	xp,
		struct xrt_session_event_sink *	broadcast,
		struct xrt_system_devices **	out_xsysd,
		struct xrt_space_overseer **	out_xso
	)

#include <auxiliary/util/u_builders.h>

Implementation for xrt_builder::open_system to be used with u_builder.

Uses u_builder_roles_helper_open_system internally, a builder that uses the u_builder should use this function for xrt_builder::open_system.

When using this function the builder must have u_builder and implement the u_builder::open_static_roles function, see documentation for u_builder_open_system_fn about requirements.

References u_builder::open_system_static_roles, and u_builder_roles_helper_open_system().

◆ u_builder_roles_helper_open_system()

xrt_result_t u_builder_roles_helper_open_system	(	struct xrt_builder *	xb,
		cJSON *	config,
		struct xrt_prober *	xp,
		struct xrt_session_event_sink *	broadcast,
		struct xrt_system_devices **	out_xsysd,
		struct xrt_space_overseer **	out_xso,
		u_builder_open_system_fn	fn
	)

#include <auxiliary/util/u_builders.h>

Helper to create a system devices that has static roles and a appropriate space overseer.

Currently uses the functions below to create a full system with the help of fn argument. But this might change in the future.

Referenced by u_builder_open_system_static_roles().

◆ u_builder_search()

void u_builder_search	(	struct xrt_prober *	xp,
		struct xrt_prober_device const	xpdevs,
		size_t	xpdev_count,
		const struct u_builder_search_filter *	filters,
		size_t	filter_count,
		struct u_builder_search_results *	results
	)

#include <auxiliary/util/u_builders.h>

Find all of the xrt_prober_device that matches any in the given list of u_builder_search_filter filters.

References ARRAY_SIZE, xrt_prober_device::bus, xrt_prober_device::product_id, xrt_prober_device::vendor_id, u_builder_search_results::xpdev_count, and u_builder_search_results::xpdevs.

◆ u_builder_setup_tracking_origins()

void u_builder_setup_tracking_origins	(	struct xrt_device *	head,
		struct xrt_device *	left,
		struct xrt_device *	right,
		struct xrt_vec3 *	global_tracking_origin_offset
	)

#include <auxiliary/util/u_builders.h>

Helper function for setting up tracking origins.

Applies 3dof offsets for devices with XRT_TRACKING_TYPE_NONE.

References xrt_device::tracking_origin, and xrt_tracking_origin::type.

Referenced by u_builder_create_space_overseer_legacy().

◆ u_config_json_get_active()

void u_config_json_get_active	(	struct u_config_json *	json,
		enum u_config_json_active_config *	out_active
	)

#include <auxiliary/util/u_config_json.h>

Read from the JSON loaded json config file and returns the active config, can be overridden by P_OVERRIDE_ACTIVE_CONFIG envirmental variable.

◆ u_config_json_get_remote_settings()

bool u_config_json_get_remote_settings	(	struct u_config_json *	json,
		int *	out_port,
		uint32_t *	out_view_count
	)

#include <auxiliary/util/u_config_json.h>

Extract remote settings from the JSON.

References U_LOG_E.

◆ u_config_json_get_tracking_overrides() [1/2]

bool u_config_json_get_tracking_overrides	(	struct u_config_json *	json,
		struct xrt_tracking_override *	out_overrides,
		size_t *	out_override_count
	)

#include <auxiliary/util/u_config_json.h>

Extract tracking override settings from the JSON.

Caller allocates an array of XRT_MAX_TRACKING_OVERRIDES tracking_override.

◆ u_config_json_get_tracking_overrides() [2/2]

bool u_config_json_get_tracking_overrides	(	struct u_config_json *	json,
		struct xrt_tracking_override *	out_overrides,
		size_t *	out_override_count
	)

Caller allocates an array of XRT_MAX_TRACKING_OVERRIDES tracking_override.

◆ u_config_json_get_tracking_settings() [1/2]

bool u_config_json_get_tracking_settings	(	struct u_config_json *	json,
		struct xrt_settings_tracking *	s
	)

#include <auxiliary/util/u_config_json.h>

Extract tracking settings from the JSON.

◆ u_config_json_get_tracking_settings() [2/2]

bool u_config_json_get_tracking_settings	(	struct u_config_json *	json,
		struct xrt_settings_tracking *	s
	)

◆ u_config_json_open_or_create_main_file()

void u_config_json_open_or_create_main_file ( struct u_config_json * json )

#include <auxiliary/util/u_config_json.h>

Load the JSON config file.

◆ u_config_json_save_calibration()

void u_config_json_save_calibration	(	struct u_config_json *	json,
		struct xrt_settings_tracking *	settings
	)

#include <auxiliary/util/u_config_json.h>

Writes back calibration settings to the main config file.

References u_config_json::file_loaded.

◆ u_config_json_save_overrides()

void u_config_json_save_overrides	(	struct u_config_json *	json,
		struct xrt_tracking_override *	overrides,
		size_t	override_count
	)

#include <auxiliary/util/u_config_json.h>

Writes back tracking override settings to the main config file.

References u_config_json::file_loaded.

◆ u_device_allocate()

void* u_device_allocate	(	enum u_device_alloc_flags	flags,
		size_t	size,
		size_t	input_count,
		size_t	output_count
	)

#include <auxiliary/util/u_device.h>

Helper function to allocate a device plus inputs in the same allocation placed after the device in memory.

Will setup any pointers and num values.

◆ u_device_assign_xdev_roles()

void u_device_assign_xdev_roles	(	struct xrt_device **	xdevs,
		size_t	xdev_count,
		int *	head,
		int *	left,
		int *	right
	)

#include <auxiliary/util/u_device.h>

Helper function to assign head, left hand and right hand roles.

Todo:: : do something with unassigned devices?

◆ u_device_dump_config()

void u_device_dump_config	(	struct xrt_device *	xdev,
		const char *	prefix,
		const char *	prod
	)

#include <auxiliary/util/u_device.h>

Dump the device config to stderr.

References U_LOG_RAW.

◆ u_device_free()

void u_device_free ( struct xrt_device * xdev )

#include <auxiliary/util/u_device.h>

Helper function to free a device and any data hanging of it.

References xrt_hmd_parts::distortion, and xrt_device::hmd.

◆ u_device_ni_compute_distortion()

bool u_device_ni_compute_distortion	(	struct xrt_device *	xdev,
		uint32_t	view,
		float	u,
		float	v,
		struct xrt_uv_triplet *	out_result
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::compute_distortion.

◆ u_device_ni_get_hand_tracking()

void u_device_ni_get_hand_tracking	(	struct xrt_device *	xdev,
		enum xrt_input_name	name,
		uint64_t	desired_timestamp_ns,
		struct xrt_hand_joint_set *	out_value,
		uint64_t *	out_timestamp_ns
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::get_hand_tracking.

◆ u_device_ni_get_view_poses()

void u_device_ni_get_view_poses	(	struct xrt_device *	xdev,
		const struct xrt_vec3 *	default_eye_relation,
		uint64_t	at_timestamp_ns,
		uint32_t	view_count,
		struct xrt_space_relation *	out_head_relation,
		struct xrt_fov *	out_fovs,
		struct xrt_pose *	out_poses
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::get_view_poses.

◆ u_device_ni_get_visibility_mask()

xrt_result_t u_device_ni_get_visibility_mask	(	struct xrt_device *	xdev,
		enum xrt_visibility_mask_type	type,
		uint32_t	view_index,
		struct xrt_visibility_mask **	out_mask
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::get_visibility_mask.

◆ u_device_ni_is_form_factor_available()

bool u_device_ni_is_form_factor_available	(	struct xrt_device *	xdev,
		enum xrt_form_factor	form_factor
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::is_form_factor_available.

◆ u_device_ni_set_output()

void u_device_ni_set_output	(	struct xrt_device *	xdev,
		enum xrt_output_name	name,
		const union xrt_output_value *	value
	)

#include <auxiliary/util/u_device.h>

Not implemented function for xrt_device::set_output.

◆ u_device_noop_update_inputs()

void u_device_noop_update_inputs ( struct xrt_device * xdev )

#include <auxiliary/util/u_device.h>

Noop function for xrt_device::update_inputs, should only be used from a device with any inputs.

◆ u_device_setup_one_eye()

bool u_device_setup_one_eye	(	struct xrt_device *	xdev,
		const struct u_device_simple_info *	info
	)

#include <auxiliary/util/u_device.h>

Setup the device information given a very simple info struct.

Returns: true on success.

References xrt_hmd_parts::blend_modes, and xrt_device::hmd.

◆ u_device_setup_split_side_by_side()

bool u_device_setup_split_side_by_side	(	struct xrt_device *	xdev,
		const struct u_device_simple_info *	info
	)

#include <auxiliary/util/u_device.h>

Setup the device information given a very simple info struct.

Returns: true on success.

References xrt_hmd_parts::blend_modes, and xrt_device::hmd.

◆ u_extents_2d_split_side_by_side()

bool u_extents_2d_split_side_by_side	(	struct xrt_device *	xdev,
		const struct u_extents_2d *	extents
	)

#include <auxiliary/util/u_device.h>

Setup the device's display's 2D extents.

Good for headsets without traditional VR optics.

Returns: true on success.

References xrt_view::display, xrt_device::hmd, xrt_view::rot, xrt_hmd_parts::screens, xrt_view::viewport, and xrt_hmd_parts::views.

◆ u_format_block_height()

uint32_t u_format_block_height ( enum xrt_format f )

#include <auxiliary/util/u_format.h>

Returns the height of the block for the given format.

Referenced by u_format_size_for_dimensions(), and u_frame_create_roi().

◆ u_format_block_size()

size_t u_format_block_size ( enum xrt_format f )

#include <auxiliary/util/u_format.h>

Returns the size of the block for the given format.

Referenced by get_score(), u_format_size_for_dimensions(), and u_frame_create_roi().

◆ u_format_block_width()

uint32_t u_format_block_width ( enum xrt_format f )

#include <auxiliary/util/u_format.h>

Returns the width of the block for the given format.

Referenced by u_format_size_for_dimensions(), and u_frame_create_roi().

◆ u_format_is_blocks()

bool u_format_is_blocks ( enum xrt_format f )

#include <auxiliary/util/u_format.h>

Is this format block based, also returns true for formats that 1x1 blocks.

Referenced by u_frame_create_one_off().

◆ u_format_size_for_dimensions()

void u_format_size_for_dimensions	(	enum xrt_format	f,
		uint32_t	width,
		uint32_t	height,
		size_t *	out_stride,
		size_t *	out_size
	)

#include <auxiliary/util/u_format.h>

Calculate stride and size for the format and given width and height.

References u_format_block_height(), u_format_block_size(), and u_format_block_width().

◆ u_format_str()

const char* u_format_str ( enum xrt_format f )

#include <auxiliary/util/u_format.h>

Return string for this format.

◆ u_hand_joints_apply_joint_width()

void u_hand_joints_apply_joint_width ( struct xrt_hand_joint_set * set )

#include <auxiliary/util/u_hand_tracking.h>

Applies joint width to set.

◆ u_hashmap_int_clear_and_call_for_each()

void u_hashmap_int_clear_and_call_for_each	(	struct u_hashmap_int *	hmi,
		u_hashmap_int_callback	cb,
		void *	priv
	)

#include <auxiliary/util/u_hashmap.h>

First clear the hashmap and then call the given callback with each item that was in the hashmap.

◆ u_hashmap_int_for_each()

void u_hashmap_int_for_each	(	const struct u_hashmap_int *	hmi,
		u_hashmap_int_foreach_callback	cb,
		void *	priv_ctx
	)

#include <auxiliary/util/u_hashmap.h>

iterators through each [key,item] pairs of hash map

Parameters

hmi	hash map to iterate
cb	callback invoked for each [key,item] pair + a user context.
priv_ctx	user provided context, passed into `cb`

◆ u_hashset_clear_and_call_for_each()

void u_hashset_clear_and_call_for_each	(	struct u_hashset *	hs,
		u_hashset_callback	cb,
		void *	priv
	)

#include <auxiliary/util/u_hashset.h>

First clear the hashset and then call the given callback with each item that was in the hashset.

◆ u_limited_unique_id_get()

xrt_limited_unique_id_t u_limited_unique_id_get ( void )

#include <auxiliary/util/u_limited_unique_id.h>

This function returns a unsigned 64 bit value that is guaranteed to be unique within the current running process, and not zero.

There is of course the limit of running out of those ID once all values has been returned, but the value is 64 bit so that should not be a practical limit. The value is useful when needing to implement caching of a complex object, this lets us not use memory addresses as keys which may be reused by underlying alloc implementation and could lead to false hits.

The current implementation is naive and is a simple monotonic counter.

◆ u_linux_try_to_set_realtime_priority_on_thread()

void u_linux_try_to_set_realtime_priority_on_thread	(	enum u_logging_level	log_level,
		const char *	name
	)

#include <auxiliary/util/u_linux.h>

Try to set realtime priority on this thread.

Passing in log_level to control how chatty this function is, the name is to make the logging pretty, can be NULL and the code will try to figure out the name itself.

Parameters

name	Thread name to be used in logging.
log_level	Logging level to control chattiness.

◆ u_ls_ns_add()

static bool u_ls_ns_add	(	struct u_live_stats_ns *	uls,
		uint64_t	value
	)

inline

Add a value to the live stats struct, returns true if the struct is full either before or after adding the value.

References ARRAY_SIZE, u_live_stats_ns::value_count, and u_live_stats_ns::values.

◆ u_native_images_debug_clear()

static void u_native_images_debug_clear ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Clear all variables atomically by holding the lock, still valid to use.

References u_native_images_debug_clear_locked(), u_native_images_debug_lock(), and u_native_images_debug_unlock().

Referenced by comp_scratch_single_images_clear_debug(), and comp_scratch_single_images_free().

◆ u_native_images_debug_clear_locked()

static void u_native_images_debug_clear_locked ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Clear all variables, must be called with the lock held.

References u_native_images_debug::active_index, u_native_images_debug::limited_unique_id, u_native_images_debug::native_image_count, u_native_images_debug::native_images, and u_native_images_debug::xscci.

Referenced by u_native_images_debug_clear(), and u_swapchain_debug_clear().

◆ u_native_images_debug_destroy()

static void u_native_images_debug_destroy ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Must not be called while variable longer tracked, after u_var_remove_root.

References u_native_images_debug::active_index, u_native_images_debug::flip_y, u_native_images_debug::mutex, u_native_images_debug::native_image_count, u_native_images_debug::native_images, os_mutex::os_mutex_destroy(), and u_native_images_debug::xscci.

Referenced by comp_scratch_single_images_destroy().

◆ u_native_images_debug_init()

static void u_native_images_debug_init ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Must be called before variable is tracked.

References u_native_images_debug::mutex, and os_mutex::os_mutex_init().

Referenced by u_swapchain_debug_init().

◆ u_native_images_debug_lock()

static void u_native_images_debug_lock ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Simple lock helper.

References u_native_images_debug::mutex, and os_mutex::os_mutex_lock().

Referenced by gui_widget_native_images_update(), u_native_images_debug_clear(), u_native_images_debug_set(), u_swapchain_debug_clear(), u_swapchain_debug_lock(), and u_swapchain_debug_set().

◆ u_native_images_debug_set()

static void u_native_images_debug_set	(	struct u_native_images_debug *	unid,
		xrt_limited_unique_id_t	limited_unique_id,
		struct xrt_image_native *	native_images,
		uint32_t	native_image_count,
		const struct xrt_swapchain_create_info *	xscci,
		uint32_t	active_index,
		bool	flip_y
	)

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Updates all variables atomically by holding the lock.

References u_native_images_debug_lock(), u_native_images_debug_set_locked(), and u_native_images_debug_unlock().

◆ u_native_images_debug_set_locked()

static void u_native_images_debug_set_locked	(	struct u_native_images_debug *	unid,
		xrt_limited_unique_id_t	limited_unique_id,
		struct xrt_image_native *	native_images,
		uint32_t	native_image_count,
		const struct xrt_swapchain_create_info *	xscci,
		uint32_t	active_index,
		bool	flip_y
	)

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Helper function to update all variables, must be called with the lock held.

References u_native_images_debug::active_index, u_native_images_debug::flip_y, u_native_images_debug::limited_unique_id, u_native_images_debug::native_image_count, u_native_images_debug::native_images, and u_native_images_debug::xscci.

Referenced by u_native_images_debug_set(), and u_swapchain_debug_set().

◆ u_native_images_debug_unlock()

static void u_native_images_debug_unlock ( struct u_native_images_debug * unid )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Simple lock helper.

References u_native_images_debug::mutex, and os_mutex::os_mutex_unlock().

Referenced by u_native_images_debug_clear(), u_native_images_debug_set(), u_swapchain_debug_clear(), and u_swapchain_debug_set().

◆ u_process_create_if_not_running()

struct u_process* u_process_create_if_not_running ( void )

#include <auxiliary/util/u_process.h>

Creates a handle for this process that is unique to the operating system user.

Returns NULL if another process holding a handle is already running.

Todo:: If built without libbsd support, a placeholder value is returned that needs to be handled by the caller.

Returns: a new u_process handle if no monado instance is running, NULL if another instance is already running.

Todo:: alternative implementation

◆ u_process_destroy()

void u_process_destroy ( struct u_process * proc )

#include <auxiliary/util/u_process.h>

Releases the unique handle of the operating system user.

◆ u_realloc_or_free()

static void* u_realloc_or_free	(	void *	ptr,
		size_t	new_size
	)

inlinestatic

#include <auxiliary/util/u_misc.h>

Reallocates or frees dynamically-allocated memory.

Wraps realloc with a return value check, freeing the provided memory if it is NULL, to avoid leaks. Use U_ARRAY_REALLOC_OR_FREE() instead.

◆ u_session_create()

struct u_session * u_session_create ( struct u_system * usys )

Create a session, optionally pass in a u_system.

If usys is not NULL the call register this session on that system. This function is exposed so that code can re-use u_session as a base class.

References xrt_session::poll_events, and U_TYPED_CALLOC.

◆ u_session_event_pop()

void u_session_event_pop	(	struct u_session *	us,
		union xrt_session_event *	out_xse
	)

Pop a single event from this session, if no event is available then the type of the event will be XRT_SESSION_EVENT_NONE.

References os_mutex::os_mutex_lock(), os_mutex::os_mutex_unlock(), U_ZERO, and XRT_SESSION_EVENT_NONE.

◆ u_session_event_push()

void u_session_event_push	(	struct u_session *	us,
		const union xrt_session_event *	xse
	)

Push an event to this session.

This function is exposed so that code can re-use u_session as a base class.

References os_mutex::os_mutex_lock(), os_mutex::os_mutex_unlock(), and U_TYPED_CALLOC.

◆ u_space_overseer_create()

struct u_space_overseer* u_space_overseer_create ( struct xrt_session_event_sink * broadcast )

Create a default implementation of a space overseer.

Parameters

[in] broadcast Event sink that broadcasts events to all sessions.

References xrt_space_overseer::create_offset_space, and U_TYPED_CALLOC.

Referenced by u_builder_create_space_overseer_legacy().

◆ u_space_overseer_create_null_space()

void u_space_overseer_create_null_space	(	struct u_space_overseer *	uso,
		struct xrt_space *	parent,
		struct xrt_space **	out_space
	)

Creates a space without any offset, this is just for optimisation over a regular offset space.

◆ u_space_overseer_legacy_setup()

void u_space_overseer_legacy_setup	(	struct u_space_overseer *	uso,
		struct xrt_device **	xdevs,
		uint32_t	xdev_count,
		struct xrt_device *	head,
		const struct xrt_pose *	local_offset,
		bool	root_is_unbounded
	)

Sets up the space overseer and all semantic spaces in a way that works with the old xrt_tracking_origin information.

Will automatically create local and stage spaces. If another setup is needed the builder should manually set the space graph up using below functions.

References xrt_space_overseer::root.

Referenced by u_builder_create_space_overseer_legacy().

◆ u_space_overseer_link_space_to_device()

void u_space_overseer_link_space_to_device	(	struct u_space_overseer *	uso,
		struct xrt_space *	xs,
		struct xrt_device *	xdev
	)

The space overseer internally keeps track the space that xrt_device is in, and then uses that mapping when creating pose spaces.

This function allows builders to create a much more bespoke setup. This function adds a reference to the space.

References u_space_overseer::lock.

◆ u_swapchain_debug_clear()

static void u_swapchain_debug_clear ( struct u_swapchain_debug * uscd )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Clear all variables atomically by holding the lock, still valid to use.

References u_swapchain_debug::base, u_native_images_debug_clear_locked(), u_native_images_debug_lock(), u_native_images_debug_unlock(), xrt_swapchain_native::xrt_swapchain_native_reference(), and u_swapchain_debug::xscn.

◆ u_swapchain_debug_destroy()

static void u_swapchain_debug_destroy ( struct u_swapchain_debug * uscd )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Must not be called while variable longer tracked, after u_var_remove_root.

References u_native_images_debug::active_index, u_swapchain_debug::base, u_native_images_debug::mutex, os_mutex::os_mutex_destroy(), xrt_swapchain_native::xrt_swapchain_native_reference(), and u_swapchain_debug::xscn.

◆ u_swapchain_debug_init()

static void u_swapchain_debug_init ( struct u_swapchain_debug * uscd )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Must be called before variable is tracked.

References u_swapchain_debug::base, and u_native_images_debug_init().

◆ u_swapchain_debug_lock()

static void u_swapchain_debug_lock ( struct u_swapchain_debug * uscd )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Simple lock helper.

References u_swapchain_debug::base, and u_native_images_debug_lock().

◆ u_swapchain_debug_set()

static void u_swapchain_debug_set	(	struct u_swapchain_debug *	uscd,
		struct xrt_swapchain_native *	xscn,
		const struct xrt_swapchain_create_info *	xscci,
		uint32_t	active_index,
		bool	flip_y
	)

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Updates all variables atomically by holding the lock.

References u_swapchain_debug::base, xrt_swapchain_native::base, xrt_swapchain::image_count, xrt_swapchain_native::limited_unique_id, u_native_images_debug_lock(), u_native_images_debug_set_locked(), u_native_images_debug_unlock(), xrt_swapchain_native::xrt_swapchain_native_reference(), and u_swapchain_debug::xscn.

◆ u_swapchain_debug_unlock()

static void u_swapchain_debug_unlock ( struct u_swapchain_debug * uscd )

inlinestatic

#include <auxiliary/util/u_native_images_debug.h>

Simple lock helper.

◆ u_system_add_session()

void u_system_add_session	(	struct u_system *	usys,
		struct xrt_session *	xs,
		struct xrt_session_event_sink *	xses
	)

Add a xrt_session to be tracked and to receive multiplexed events.

References u_system::count, os_mutex::os_mutex_lock(), os_mutex::os_mutex_unlock(), u_system::pairs, and U_ARRAY_REALLOC_OR_FREE.

◆ u_system_broadcast_event()

void u_system_broadcast_event	(	struct u_system *	usys,
		const union xrt_session_event *	xse
	)

Broadcast event to all sessions under this system.

References u_system::count, os_mutex::os_mutex_lock(), os_mutex::os_mutex_unlock(), u_system::pairs, U_LOG_W, xrt_session_event_sink::xrt_session_event_sink_push(), and XRT_SUCCESS.

◆ u_system_create()

struct u_system * u_system_create ( void )

Create a u_system.

References xrt_system::create_session, and U_TYPED_CALLOC.

Referenced by sdl_system_init().

◆ u_system_devices()

static struct u_system_devices* u_system_devices ( struct xrt_system_devices * xsysd )

inlinestatic

Small inline helper to cast from xrt_system_devices.

Referenced by u_system_devices_close().

◆ u_system_devices_allocate()

struct u_system_devices* u_system_devices_allocate ( void )

Allocates a empty u_system_devices to be filled in by the caller, only the destroy function is filled in.

References xrt_system_devices::destroy, and U_TYPED_CALLOC.

◆ u_system_devices_close()

void u_system_devices_close ( struct xrt_system_devices * xsysd )

Destroys all devices and clears out the frame context, doesn't free the struct itself, useful for code embedding the system devices struct into other objects where it's not the first member or C++ classes.

References ARRAY_SIZE, u_system_devices(), xrt_system_devices::xdevs, u_system_devices::xfctx, xrt_device::xrt_device_destroy(), and xrt_frame_context::xrt_frame_context_destroy_nodes().

◆ u_system_devices_create_from_prober()

xrt_result_t u_system_devices_create_from_prober	(	struct xrt_instance *	xinst,
		struct xrt_session_event_sink *	broadcast,
		struct xrt_system_devices **	out_xsysd,
		struct xrt_space_overseer **	out_xso
	)

Takes a xrt_instance, gets the prober from it and then uses the prober to allocate a filled in u_system_devices.

References xrt_instance::xrt_instance_get_prober(), xrt_prober::xrt_prober_create_system(), xrt_prober::xrt_prober_probe(), and XRT_SUCCESS.

◆ u_system_devices_get_ht_device()

struct xrt_device* u_system_devices_get_ht_device	(	struct xrt_system_devices *	xsysd,
		enum xrt_input_name	name
	)

Helper function.

Looks through xrt_system_devices's devices and returns the first device that supports hand tracking and the supplied input name.

Used by target_builder_lighthouse to find Knuckles controllers in the list of devices returned, the legacy builder to find hand tracking devices, etc.

References xrt_device::input_count, xrt_device::inputs, xrt_system_devices::xdev_count, and xrt_system_devices::xdevs.

Referenced by u_system_devices_get_ht_device_left().

◆ u_system_devices_get_ht_device_left()

static struct xrt_device* u_system_devices_get_ht_device_left ( struct xrt_system_devices * xsysd )

inlinestatic

Helper to get the first left hand-tracking device, uses u_system_devices_get_ht_device.

References u_system_devices_get_ht_device().

◆ u_system_devices_get_ht_device_right()

static struct xrt_device* u_system_devices_get_ht_device_right ( struct xrt_system_devices * xsysd )

inlinestatic

Helper to get the first right hand-tracking device, uses u_system_devices_get_ht_device.

◆ u_system_devices_static()

static struct u_system_devices_static* u_system_devices_static ( struct xrt_system_devices * xsysd )

inlinestatic

Small inline helper to cast from xrt_system_devices.

◆ u_system_devices_static_allocate()

struct u_system_devices_static* u_system_devices_static_allocate ( void )

Allocates a empty u_system_devices to be filled in by the caller, only the destroy function is filled in.

References xrt_system_devices::destroy, and U_TYPED_CALLOC.

Referenced by u_builder_roles_helper_open_system().

◆ u_system_devices_static_finalize()

void u_system_devices_static_finalize	(	struct u_system_devices_static *	usysds,
		struct xrt_device *	left,
		struct xrt_device *	right
	)

Finalizes the static struct with the given input devices, the system devices will always return these devices for the left and right role.

This function must be called before xrt_system_devices_get_roles is called.

Referenced by u_builder_roles_helper_open_system().

◆ u_system_fill_properties()

void u_system_fill_properties	(	struct u_system *	usys,
		const char *	name
	)

Fill system properties.

◆ u_system_remove_session()

void u_system_remove_session	(	struct u_system *	usys,
		struct xrt_session *	xs,
		struct xrt_session_event_sink *	xses
	)

Remove a xrt_session from tracking, it will no longer receive events, the given xses needs to match when it was added.

References u_system::count, os_mutex::os_mutex_lock(), u_system::pairs, and U_LOG_E.

◆ u_system_set_system_compositor()

void u_system_set_system_compositor	(	struct u_system *	usys,
		struct xrt_system_compositor *	xsysc
	)

Set the system compositor, used in the xrt_system_create_session call.

References u_system::xsysc.

◆ u_trace_marker_init()

void u_trace_marker_init ( void )

Must be called from a non-static/global constructor context.

Referenced by xrt_instance::xrt_instance_create().

◆ u_trace_marker_setup()

void u_trace_marker_setup ( enum u_trace_which which )