+2

src/xrt/ipc/CMakeLists.txt

··· 70 70 client/ipc_client_space_overseer.c 71 71 client/ipc_client_system.c 72 72 client/ipc_client_system_devices.c 73 73 + client/ipc_client_xdev.c 74 74 + client/ipc_client_xdev.h 73 75 ) 74 76 target_include_directories( 75 77 ipc_client PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}

-26

src/xrt/ipc/client/ipc_client.h

··· 166 166 #endif // XRT_OS_ANDROID 167 167 }; 168 168 169 169 - /*! 170 170 - * An IPC client proxy for an @ref xrt_device. 171 171 - * 172 172 - * @implements xrt_device 173 173 - * @ingroup ipc_client 174 174 - */ 175 175 - struct ipc_client_xdev 176 176 - { 177 177 - struct xrt_device base; 178 178 - 179 179 - struct ipc_connection *ipc_c; 180 180 - 181 181 - uint32_t device_id; 182 182 - }; 183 183 - 184 169 185 170 /* 186 171 * 187 172 * Internal functions. 188 173 * 189 174 */ 190 190 - 191 191 - /*! 192 192 - * Convenience helper to go from a xdev to @ref ipc_client_xdev. 193 193 - * 194 194 - * @ingroup ipc_client 195 195 - */ 196 196 - static inline struct ipc_client_xdev * 197 197 - ipc_client_xdev(struct xrt_device *xdev) 198 198 - { 199 199 - return (struct ipc_client_xdev *)xdev; 200 200 - } 201 175 202 176 /*! 203 177 * Create an IPC client system compositor.

+8 -239

src/xrt/ipc/client/ipc_client_device.c

··· 1 1 // Copyright 2020-2024, Collabora, Ltd. 2 2 + // Copyright 2025, NVIDIA CORPORATION. 2 3 // SPDX-License-Identifier: BSL-1.0 3 4 /*! 4 5 * @file ··· 21 22 22 23 #include "client/ipc_client.h" 23 24 #include "client/ipc_client_connection.h" 25 25 + #include "client/ipc_client_xdev.h" 24 26 #include "ipc_client_generated.h" 25 27 26 28 #include <math.h> ··· 66 68 // Remove the variable tracking. 67 69 u_var_remove_root(icd); 68 70 69 69 - // We do not own these, so don't free them. 70 70 - icd->base.inputs = NULL; 71 71 - icd->base.outputs = NULL; 71 71 + // Free and de-init the shared things. 72 72 + ipc_client_xdev_fini(icd); 72 73 73 74 // Free this device with the helper. 74 75 u_device_free(&icd->base); 75 76 } 76 77 77 77 - static xrt_result_t 78 78 - ipc_client_device_update_inputs(struct xrt_device *xdev) 79 79 - { 80 80 - ipc_client_device_t *icd = ipc_client_device(xdev); 81 81 - 82 82 - xrt_result_t xret = ipc_call_device_update_input(icd->ipc_c, icd->device_id); 83 83 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_update_input"); 84 84 - } 85 85 - 86 86 - static xrt_result_t 87 87 - ipc_client_device_get_tracked_pose(struct xrt_device *xdev, 88 88 - enum xrt_input_name name, 89 89 - int64_t at_timestamp_ns, 90 90 - struct xrt_space_relation *out_relation) 91 91 - { 92 92 - ipc_client_device_t *icd = ipc_client_device(xdev); 93 93 - 94 94 - xrt_result_t xret = ipc_call_device_get_tracked_pose( // 95 95 - icd->ipc_c, // 96 96 - icd->device_id, // 97 97 - name, // 98 98 - at_timestamp_ns, // 99 99 - out_relation); // 100 100 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 101 101 - } 102 102 - 103 103 - static void 104 104 - ipc_client_device_get_hand_tracking(struct xrt_device *xdev, 105 105 - enum xrt_input_name name, 106 106 - int64_t at_timestamp_ns, 107 107 - struct xrt_hand_joint_set *out_value, 108 108 - int64_t *out_timestamp_ns) 109 109 - { 110 110 - ipc_client_device_t *icd = ipc_client_device(xdev); 111 111 - 112 112 - xrt_result_t xret = ipc_call_device_get_hand_tracking( // 113 113 - icd->ipc_c, // 114 114 - icd->device_id, // 115 115 - name, // 116 116 - at_timestamp_ns, // 117 117 - out_value, // 118 118 - out_timestamp_ns); // 119 119 - IPC_CHK_ONLY_PRINT(icd->ipc_c, xret, "ipc_call_device_get_hand_tracking"); 120 120 - } 121 121 - 122 122 - static xrt_result_t 123 123 - ipc_client_device_get_face_tracking(struct xrt_device *xdev, 124 124 - enum xrt_input_name facial_expression_type, 125 125 - int64_t at_timestamp_ns, 126 126 - struct xrt_facial_expression_set *out_value) 127 127 - { 128 128 - ipc_client_device_t *icd = ipc_client_device(xdev); 129 129 - 130 130 - xrt_result_t xret = ipc_call_device_get_face_tracking( // 131 131 - icd->ipc_c, // 132 132 - icd->device_id, // 133 133 - facial_expression_type, // 134 134 - at_timestamp_ns, // 135 135 - out_value); // 136 136 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_face_tracking"); 137 137 - } 138 138 - 139 139 - static xrt_result_t 140 140 - ipc_client_device_get_body_skeleton(struct xrt_device *xdev, 141 141 - enum xrt_input_name body_tracking_type, 142 142 - struct xrt_body_skeleton *out_value) 143 143 - { 144 144 - ipc_client_device_t *icd = ipc_client_device(xdev); 145 145 - 146 146 - xrt_result_t xret = ipc_call_device_get_body_skeleton( // 147 147 - icd->ipc_c, // 148 148 - icd->device_id, // 149 149 - body_tracking_type, // 150 150 - out_value); // 151 151 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_body_skeleton"); 152 152 - } 153 153 - 154 154 - static xrt_result_t 155 155 - ipc_client_device_get_body_joints(struct xrt_device *xdev, 156 156 - enum xrt_input_name body_tracking_type, 157 157 - int64_t desired_timestamp_ns, 158 158 - struct xrt_body_joint_set *out_value) 159 159 - { 160 160 - ipc_client_device_t *icd = ipc_client_device(xdev); 161 161 - 162 162 - xrt_result_t xret = ipc_call_device_get_body_joints( // 163 163 - icd->ipc_c, // 164 164 - icd->device_id, // 165 165 - body_tracking_type, // 166 166 - desired_timestamp_ns, // 167 167 - out_value); // 168 168 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_body_joints"); 169 169 - } 170 170 - 171 171 - static void 172 172 - ipc_client_device_get_view_poses(struct xrt_device *xdev, 173 173 - const struct xrt_vec3 *default_eye_relation, 174 174 - int64_t at_timestamp_ns, 175 175 - uint32_t view_count, 176 176 - struct xrt_space_relation *out_head_relation, 177 177 - struct xrt_fov *out_fovs, 178 178 - struct xrt_pose *out_poses) 179 179 - { 180 180 - // Empty 181 181 - assert(false); 182 182 - } 183 183 - 184 184 - static void 185 185 - ipc_client_device_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value) 186 186 - { 187 187 - ipc_client_device_t *icd = ipc_client_device(xdev); 188 188 - struct ipc_connection *ipc_c = icd->ipc_c; 189 189 - 190 190 - xrt_result_t xret; 191 191 - if (value->type == XRT_OUTPUT_VALUE_TYPE_PCM_VIBRATION) { 192 192 - uint32_t samples_sent = MIN(value->pcm_vibration.sample_rate, 4000); 193 193 - 194 194 - struct ipc_pcm_haptic_buffer samples = { 195 195 - .append = value->pcm_vibration.append, 196 196 - .num_samples = samples_sent, 197 197 - .sample_rate = value->pcm_vibration.sample_rate, 198 198 - }; 199 199 - 200 200 - ipc_client_connection_lock(ipc_c); 201 201 - 202 202 - xret = ipc_send_device_set_haptic_output_locked(ipc_c, icd->device_id, name, &samples); 203 203 - IPC_CHK_WITH_RET(ipc_c, xret, "ipc_send_device_set_haptic_output_locked", ); 204 204 - 205 205 - xrt_result_t alloc_xret; 206 206 - xret = ipc_receive(&ipc_c->imc, &alloc_xret, sizeof alloc_xret); 207 207 - if (xret != XRT_SUCCESS || alloc_xret != XRT_SUCCESS) { 208 208 - goto send_haptic_output_end; 209 209 - } 210 210 - 211 211 - xret = ipc_send(&ipc_c->imc, value->pcm_vibration.buffer, sizeof(float) * samples_sent); 212 212 - if (xret != XRT_SUCCESS) { 213 213 - goto send_haptic_output_end; 214 214 - } 215 215 - 216 216 - xret = ipc_receive(&ipc_c->imc, value->pcm_vibration.samples_consumed, 217 217 - sizeof(*value->pcm_vibration.samples_consumed)); 218 218 - if (xret != XRT_SUCCESS) { 219 219 - goto send_haptic_output_end; 220 220 - } 221 221 - 222 222 - send_haptic_output_end: 223 223 - ipc_client_connection_unlock(ipc_c); 224 224 - } else { 225 225 - xret = ipc_call_device_set_output(ipc_c, icd->device_id, name, value); 226 226 - IPC_CHK_ONLY_PRINT(ipc_c, xret, "ipc_call_device_set_output"); 227 227 - } 228 228 - } 229 229 - 230 230 - xrt_result_t 231 231 - ipc_client_device_get_output_limits(struct xrt_device *xdev, struct xrt_output_limits *limits) 232 232 - { 233 233 - ipc_client_device_t *icd = ipc_client_device(xdev); 234 234 - 235 235 - xrt_result_t xret = ipc_call_device_get_output_limits(icd->ipc_c, icd->device_id, limits); 236 236 - IPC_CHK_ONLY_PRINT(icd->ipc_c, xret, "ipc_call_device_get_output_limits"); 237 237 - 238 238 - return xret; 239 239 - } 240 240 - 241 241 - static xrt_result_t 242 242 - ipc_client_device_get_visibility_mask(struct xrt_device *xdev, 243 243 - enum xrt_visibility_mask_type type, 244 244 - uint32_t view_index, 245 245 - struct xrt_visibility_mask **out_mask) 246 246 - { 247 247 - assert(false); 248 248 - return XRT_ERROR_IPC_FAILURE; 249 249 - } 250 250 - 251 78 /*! 252 79 * @public @memberof ipc_client_device 253 80 */ 254 81 struct xrt_device * 255 82 ipc_client_device_create(struct ipc_connection *ipc_c, struct xrt_tracking_origin *xtrack, uint32_t device_id) 256 83 { 257 257 - // Helpers. 258 258 - struct ipc_shared_memory *ism = ipc_c->ism; 259 259 - struct ipc_shared_device *isdev = &ism->isdevs[device_id]; 260 260 - 261 84 // Allocate and setup the basics. 262 85 enum u_device_alloc_flags flags = (enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD); 263 86 ipc_client_device_t *icd = U_DEVICE_ALLOCATE(ipc_client_device_t, flags, 0, 0); 264 264 - icd->ipc_c = ipc_c; 265 265 - icd->base.update_inputs = ipc_client_device_update_inputs; 266 266 - icd->base.get_tracked_pose = ipc_client_device_get_tracked_pose; 267 267 - icd->base.get_hand_tracking = ipc_client_device_get_hand_tracking; 268 268 - icd->base.get_face_tracking = ipc_client_device_get_face_tracking; 269 269 - icd->base.get_body_skeleton = ipc_client_device_get_body_skeleton; 270 270 - icd->base.get_body_joints = ipc_client_device_get_body_joints; 271 271 - icd->base.get_view_poses = ipc_client_device_get_view_poses; 272 272 - icd->base.set_output = ipc_client_device_set_output; 273 273 - icd->base.get_output_limits = ipc_client_device_get_output_limits; 274 274 - icd->base.get_visibility_mask = ipc_client_device_get_visibility_mask; 275 275 - icd->base.destroy = ipc_client_device_destroy; 276 87 277 277 - // Start copying the information from the isdev. 278 278 - icd->base.tracking_origin = xtrack; 279 279 - icd->base.name = isdev->name; 280 280 - icd->device_id = device_id; 88 88 + // Fills in almost everything a regular device needs. 89 89 + ipc_client_xdev_init(icd, ipc_c, xtrack, device_id); 281 90 282 282 - // Print name. 283 283 - snprintf(icd->base.str, XRT_DEVICE_NAME_LEN, "%s", isdev->str); 284 284 - snprintf(icd->base.serial, XRT_DEVICE_NAME_LEN, "%s", isdev->serial); 285 285 - 286 286 - // Setup inputs, by pointing directly to the shared memory. 287 287 - assert(isdev->input_count > 0); 288 288 - icd->base.inputs = &ism->inputs[isdev->first_input_index]; 289 289 - icd->base.input_count = isdev->input_count; 290 290 - 291 291 - // Setup outputs, if any point directly into the shared memory. 292 292 - icd->base.output_count = isdev->output_count; 293 293 - if (isdev->output_count > 0) { 294 294 - icd->base.outputs = &ism->outputs[isdev->first_output_index]; 295 295 - } else { 296 296 - icd->base.outputs = NULL; 297 297 - } 298 298 - 299 299 - if (isdev->binding_profile_count > 0) { 300 300 - icd->base.binding_profiles = 301 301 - U_TYPED_ARRAY_CALLOC(struct xrt_binding_profile, isdev->binding_profile_count); 302 302 - icd->base.binding_profile_count = isdev->binding_profile_count; 303 303 - } 304 304 - 305 305 - for (size_t i = 0; i < isdev->binding_profile_count; i++) { 306 306 - struct xrt_binding_profile *xbp = &icd->base.binding_profiles[i]; 307 307 - struct ipc_shared_binding_profile *isbp = 308 308 - &ism->binding_profiles[isdev->first_binding_profile_index + i]; 309 309 - 310 310 - xbp->name = isbp->name; 311 311 - if (isbp->input_count > 0) { 312 312 - xbp->inputs = &ism->input_pairs[isbp->first_input_index]; 313 313 - xbp->input_count = isbp->input_count; 314 314 - } 315 315 - if (isbp->output_count > 0) { 316 316 - xbp->outputs = &ism->output_pairs[isbp->first_output_index]; 317 317 - xbp->output_count = isbp->output_count; 318 318 - } 319 319 - } 91 91 + // Need to set the destroy function. 92 92 + icd->base.destroy = ipc_client_device_destroy; 320 93 321 94 // Setup variable tracker. 322 95 u_var_add_root(icd, icd->base.str, true); 323 96 u_var_add_ro_u32(icd, &icd->device_id, "device_id"); 324 324 - 325 325 - // Copy information. 326 326 - icd->base.device_type = isdev->device_type; 327 327 - icd->base.supported = isdev->supported; 328 97 329 98 return &icd->base; 330 99 }

+29 -262

src/xrt/ipc/client/ipc_client_hmd.c

··· 1 1 // Copyright 2020-2024, Collabora, Ltd. 2 2 + // Copyright 2025, NVIDIA CORPORATION. 2 3 // SPDX-License-Identifier: BSL-1.0 3 4 /*! 4 5 * @file ··· 22 23 #include "util/u_distortion_mesh.h" 23 24 24 25 #include "client/ipc_client.h" 26 26 + #include "client/ipc_client_xdev.h" 25 27 #include "client/ipc_client_connection.h" 26 28 #include "ipc_client_generated.h" 27 29 ··· 125 127 */ 126 128 127 129 static void 128 128 - ipc_client_hmd_destroy(struct xrt_device *xdev) 129 129 - { 130 130 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 131 131 - 132 132 - // Remove the variable tracking. 133 133 - u_var_remove_root(ich); 134 134 - 135 135 - // We do not own these, so don't free them. 136 136 - ich->base.inputs = NULL; 137 137 - ich->base.outputs = NULL; 138 138 - 139 139 - // Free this device with the helper. 140 140 - u_device_free(&ich->base); 141 141 - } 142 142 - 143 143 - static xrt_result_t 144 144 - ipc_client_hmd_update_inputs(struct xrt_device *xdev) 145 145 - { 146 146 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 147 147 - 148 148 - xrt_result_t xret = ipc_call_device_update_input(ich->ipc_c, ich->device_id); 149 149 - IPC_CHK_ALWAYS_RET(ich->ipc_c, xret, "ipc_call_device_update_input"); 150 150 - } 151 151 - 152 152 - static xrt_result_t 153 153 - ipc_client_hmd_get_tracked_pose(struct xrt_device *xdev, 154 154 - enum xrt_input_name name, 155 155 - int64_t at_timestamp_ns, 156 156 - struct xrt_space_relation *out_relation) 157 157 - { 158 158 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 159 159 - xrt_result_t xret; 160 160 - 161 161 - xret = ipc_call_device_get_tracked_pose( // 162 162 - ich->ipc_c, // 163 163 - ich->device_id, // 164 164 - name, // 165 165 - at_timestamp_ns, // 166 166 - out_relation); // 167 167 - IPC_CHK_ALWAYS_RET(ich->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 168 168 - } 169 169 - 170 170 - static void 171 130 ipc_client_hmd_get_view_poses(struct xrt_device *xdev, 172 131 const struct xrt_vec3 *default_eye_relation, 173 132 int64_t at_timestamp_ns, ··· 216 175 } 217 176 } 218 177 219 219 - static xrt_result_t 220 220 - ipc_client_hmd_get_face_tracking(struct xrt_device *xdev, 221 221 - enum xrt_input_name facial_expression_type, 222 222 - int64_t at_timestamp_ns, 223 223 - struct xrt_facial_expression_set *out_value) 224 224 - { 225 225 - ipc_client_hmd_t *icd = ipc_client_hmd(xdev); 226 226 - 227 227 - xrt_result_t xret = ipc_call_device_get_face_tracking( // 228 228 - icd->ipc_c, // 229 229 - icd->device_id, // 230 230 - facial_expression_type, // 231 231 - at_timestamp_ns, // 232 232 - out_value); // 233 233 - IPC_CHK_ALWAYS_RET(icd->ipc_c, xret, "ipc_call_device_get_face_tracking"); 234 234 - } 235 235 - 236 178 static bool 237 179 ipc_client_hmd_compute_distortion( 238 180 struct xrt_device *xdev, uint32_t view, float u, float v, struct xrt_uv_triplet *out_result) ··· 271 213 return available; 272 214 } 273 215 274 274 - static enum xrt_result 275 275 - ipc_client_hmd_begin_plane_detection_ext(struct xrt_device *xdev, 276 276 - const struct xrt_plane_detector_begin_info_ext *begin_info, 277 277 - uint64_t plane_detection_id, 278 278 - uint64_t *out_plane_detection_id) 279 279 - { 280 280 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 281 281 - 282 282 - ich->ipc_c->ism->plane_begin_info_ext = *begin_info; 283 283 - 284 284 - xrt_result_t r = ipc_call_device_begin_plane_detection_ext(ich->ipc_c, ich->device_id, plane_detection_id, 285 285 - out_plane_detection_id); 286 286 - if (r != XRT_SUCCESS) { 287 287 - IPC_ERROR(ich->ipc_c, "Error sending hmd_begin_plane_detection_ext!"); 288 288 - return r; 289 289 - } 290 290 - 291 291 - return XRT_SUCCESS; 292 292 - } 293 293 - 294 294 - static enum xrt_result 295 295 - ipc_client_hmd_destroy_plane_detection_ext(struct xrt_device *xdev, uint64_t plane_detection_id) 296 296 - { 297 297 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 298 298 - 299 299 - xrt_result_t r = ipc_call_device_destroy_plane_detection_ext(ich->ipc_c, ich->device_id, plane_detection_id); 300 300 - if (r != XRT_SUCCESS) { 301 301 - IPC_ERROR(ich->ipc_c, "Error sending destroy_plane_detection_ext!"); 302 302 - return r; 303 303 - } 304 304 - 305 305 - return XRT_SUCCESS; 306 306 - } 307 307 - 308 308 - /*! 309 309 - * Helper function for @ref xrt_device::get_plane_detection_state. 310 310 - * 311 311 - * @public @memberof xrt_device 312 312 - */ 313 313 - static inline enum xrt_result 314 314 - ipc_client_hmd_get_plane_detection_state_ext(struct xrt_device *xdev, 315 315 - uint64_t plane_detection_id, 316 316 - enum xrt_plane_detector_state_ext *out_state) 317 317 - { 318 318 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 319 319 - 320 320 - xrt_result_t r = 321 321 - ipc_call_device_get_plane_detection_state_ext(ich->ipc_c, ich->device_id, plane_detection_id, out_state); 322 322 - if (r != XRT_SUCCESS) { 323 323 - IPC_ERROR(ich->ipc_c, "Error sending get_plane_detection_state_ext!"); 324 324 - return r; 325 325 - } 326 326 - 327 327 - return XRT_SUCCESS; 328 328 - } 329 329 - 330 330 - /*! 331 331 - * Helper function for @ref xrt_device::get_plane_detections. 332 332 - * 333 333 - * @public @memberof xrt_device 334 334 - */ 335 335 - static inline enum xrt_result 336 336 - ipc_client_hmd_get_plane_detections_ext(struct xrt_device *xdev, 337 337 - uint64_t plane_detection_id, 338 338 - struct xrt_plane_detections_ext *out_detections) 339 339 - { 340 340 - ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 341 341 - struct ipc_connection *ipc_c = ich->ipc_c; 342 342 - 343 343 - ipc_client_connection_lock(ipc_c); 344 344 - 345 345 - xrt_result_t xret = ipc_send_device_get_plane_detections_ext_locked(ipc_c, ich->device_id, plane_detection_id); 346 346 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_send_device_get_plane_detections_ext_locked", out); 347 347 - 348 348 - // in this case, size == count 349 349 - uint32_t location_size = 0; 350 350 - uint32_t polygon_size = 0; 351 351 - uint32_t vertex_size = 0; 352 352 - 353 353 - xret = ipc_receive_device_get_plane_detections_ext_locked(ipc_c, &location_size, &polygon_size, &vertex_size); 354 354 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_receive_device_get_plane_detections_ext_locked", out); 355 355 - 356 356 - 357 357 - // With no locations, the service won't send anything else 358 358 - if (location_size < 1) { 359 359 - out_detections->location_count = 0; 360 360 - goto out; 361 361 - } 362 362 - 363 363 - // realloc arrays in out_detections if necessary, then receive contents 364 364 - 365 365 - out_detections->location_count = location_size; 366 366 - if (out_detections->location_size < location_size) { 367 367 - U_ARRAY_REALLOC_OR_FREE(out_detections->locations, struct xrt_plane_detector_location_ext, 368 368 - location_size); 369 369 - U_ARRAY_REALLOC_OR_FREE(out_detections->polygon_info_start_index, uint32_t, location_size); 370 370 - out_detections->location_size = location_size; 371 371 - } 372 372 - 373 373 - if (out_detections->polygon_info_size < polygon_size) { 374 374 - U_ARRAY_REALLOC_OR_FREE(out_detections->polygon_infos, struct xrt_plane_polygon_info_ext, polygon_size); 375 375 - out_detections->polygon_info_size = polygon_size; 376 376 - } 377 377 - 378 378 - if (out_detections->vertex_size < vertex_size) { 379 379 - U_ARRAY_REALLOC_OR_FREE(out_detections->vertices, struct xrt_vec2, vertex_size); 380 380 - out_detections->vertex_size = vertex_size; 381 381 - } 382 382 - 383 383 - if ((location_size > 0 && 384 384 - (out_detections->locations == NULL || out_detections->polygon_info_start_index == NULL)) || 385 385 - (polygon_size > 0 && out_detections->polygon_infos == NULL) || 386 386 - (vertex_size > 0 && out_detections->vertices == NULL)) { 387 387 - IPC_ERROR(ich->ipc_c, "Error allocating memory for plane detections!"); 388 388 - out_detections->location_size = 0; 389 389 - out_detections->polygon_info_size = 0; 390 390 - out_detections->vertex_size = 0; 391 391 - xret = XRT_ERROR_IPC_FAILURE; 392 392 - goto out; 393 393 - } 394 394 - 395 395 - if (location_size > 0) { 396 396 - // receive location_count * locations 397 397 - xret = ipc_receive(&ipc_c->imc, out_detections->locations, 398 398 - sizeof(struct xrt_plane_detector_location_ext) * location_size); 399 399 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_receive(1)", out); 400 400 - 401 401 - // receive location_count * polygon_info_start_index 402 402 - xret = ipc_receive(&ipc_c->imc, out_detections->polygon_info_start_index, 403 403 - sizeof(uint32_t) * location_size); 404 404 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_receive(2)", out); 405 405 - } 406 406 - 407 407 - 408 408 - if (polygon_size > 0) { 409 409 - // receive polygon_count * polygon_infos 410 410 - xret = ipc_receive(&ipc_c->imc, out_detections->polygon_infos, 411 411 - sizeof(struct xrt_plane_polygon_info_ext) * polygon_size); 412 412 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_receive(3)", out); 413 413 - } 414 414 - 415 415 - if (vertex_size > 0) { 416 416 - // receive vertex_count * vertices 417 417 - xret = ipc_receive(&ipc_c->imc, out_detections->vertices, sizeof(struct xrt_vec2) * vertex_size); 418 418 - IPC_CHK_WITH_GOTO(ich->ipc_c, xret, "ipc_receive(4)", out); 419 419 - } 420 420 - 421 421 - out: 422 422 - ipc_client_connection_unlock(ipc_c); 423 423 - return xret; 424 424 - } 425 425 - 426 216 static xrt_result_t 427 217 ipc_client_hmd_get_visibility_mask(struct xrt_device *xdev, 428 218 enum xrt_visibility_mask_type type, ··· 464 254 return XRT_ERROR_IPC_FAILURE; 465 255 } 466 256 257 257 + static void 258 258 + ipc_client_hmd_destroy(struct xrt_device *xdev) 259 259 + { 260 260 + ipc_client_hmd_t *ich = ipc_client_hmd(xdev); 261 261 + 262 262 + // Remove the variable tracking. 263 263 + u_var_remove_root(ich); 264 264 + 265 265 + // Free and de-init the shared things. 266 266 + ipc_client_xdev_fini(ich); 267 267 + 268 268 + // Free this device with the helper. 269 269 + u_device_free(&ich->base); 270 270 + } 271 271 + 467 272 /*! 468 273 * @public @memberof ipc_client_hmd 469 274 */ 470 275 struct xrt_device * 471 276 ipc_client_hmd_create(struct ipc_connection *ipc_c, struct xrt_tracking_origin *xtrack, uint32_t device_id) 472 277 { 278 278 + // Convenience helper. 473 279 struct ipc_shared_memory *ism = ipc_c->ism; 474 474 - struct ipc_shared_device *isdev = &ism->isdevs[device_id]; 475 280 476 476 - 477 477 - 281 281 + // Allocate a HMD device. 478 282 enum u_device_alloc_flags flags = (enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD); 479 283 ipc_client_hmd_t *ich = U_DEVICE_ALLOCATE(ipc_client_hmd_t, flags, 0, 0); 480 480 - ich->ipc_c = ipc_c; 481 481 - ich->device_id = device_id; 482 482 - ich->base.update_inputs = ipc_client_hmd_update_inputs; 483 483 - ich->base.get_tracked_pose = ipc_client_hmd_get_tracked_pose; 484 484 - ich->base.get_face_tracking = ipc_client_hmd_get_face_tracking; 284 284 + 285 285 + // Fills in almost everything a regular device needs. 286 286 + ipc_client_xdev_init(ich, ipc_c, xtrack, device_id); 287 287 + 288 288 + // Fill in needed HMD functions, and destroy. 485 289 ich->base.get_view_poses = ipc_client_hmd_get_view_poses; 486 290 ich->base.compute_distortion = ipc_client_hmd_compute_distortion; 487 487 - ich->base.begin_plane_detection_ext = ipc_client_hmd_begin_plane_detection_ext; 488 488 - ich->base.destroy_plane_detection_ext = ipc_client_hmd_destroy_plane_detection_ext; 489 489 - ich->base.get_plane_detection_state_ext = ipc_client_hmd_get_plane_detection_state_ext; 490 490 - ich->base.get_plane_detections_ext = ipc_client_hmd_get_plane_detections_ext; 491 491 - ich->base.destroy = ipc_client_hmd_destroy; 492 291 ich->base.is_form_factor_available = ipc_client_hmd_is_form_factor_available; 493 292 ich->base.get_visibility_mask = ipc_client_hmd_get_visibility_mask; 494 494 - 495 495 - // Start copying the information from the isdev. 496 496 - ich->base.tracking_origin = xtrack; 497 497 - ich->base.name = isdev->name; 498 498 - ich->device_id = device_id; 499 499 - 500 500 - // Print name. 501 501 - snprintf(ich->base.str, XRT_DEVICE_NAME_LEN, "%s", isdev->str); 502 502 - snprintf(ich->base.serial, XRT_DEVICE_NAME_LEN, "%s", isdev->serial); 503 503 - 504 504 - // Setup inputs, by pointing directly to the shared memory. 505 505 - assert(isdev->input_count > 0); 506 506 - ich->base.inputs = &ism->inputs[isdev->first_input_index]; 507 507 - ich->base.input_count = isdev->input_count; 508 508 - 509 509 - #if 0 510 510 - // Setup info. 511 511 - struct u_device_simple_info info; 512 512 - info.display.w_pixels = 1920; 513 513 - info.display.h_pixels = 1080; 514 514 - info.display.w_meters = 0.13f; 515 515 - info.display.h_meters = 0.07f; 516 516 - info.lens_horizontal_separation_meters = 0.13f / 2.0f; 517 517 - info.lens_vertical_position_meters = 0.07f / 2.0f; 518 518 - info.views[0].fov = 85.0f * (M_PI / 180.0f); 519 519 - info.views[1].fov = 85.0f * (M_PI / 180.0f); 293 293 + ich->base.destroy = ipc_client_hmd_destroy; 520 294 521 521 - if (!u_device_setup_split_side_by_side(&ich->base, &info)) { 522 522 - IPC_ERROR(ich->ipc_c, "Failed to setup basic device info"); 523 523 - ipc_client_hmd_destroy(&ich->base); 524 524 - return NULL; 525 525 - } 526 526 - #endif 295 295 + // Setup blend-modes. 296 296 + ich->base.hmd->blend_mode_count = ipc_c->ism->hmd.blend_mode_count; 527 297 for (int i = 0; i < XRT_MAX_DEVICE_BLEND_MODES; i++) { 528 298 ich->base.hmd->blend_modes[i] = ipc_c->ism->hmd.blend_modes[i]; 529 299 } 300 300 + 301 301 + // Setup the views. 530 302 ich->base.hmd->view_count = ism->hmd.view_count; 531 531 - ich->base.hmd->blend_mode_count = ipc_c->ism->hmd.blend_mode_count; 532 303 for (uint32_t i = 0; i < ich->base.hmd->view_count; ++i) { 533 304 ich->base.hmd->views[i].display.w_pixels = ipc_c->ism->hmd.views[i].display.w_pixels; 534 305 ich->base.hmd->views[i].display.h_pixels = ipc_c->ism->hmd.views[i].display.h_pixels; ··· 540 311 // Setup variable tracker. 541 312 u_var_add_root(ich, ich->base.str, true); 542 313 u_var_add_ro_u32(ich, &ich->device_id, "device_id"); 543 543 - 544 544 - // Copy information. 545 545 - ich->base.device_type = isdev->device_type; 546 546 - ich->base.supported = isdev->supported; 547 314 548 315 return &ich->base; 549 316 }

+6 -3

src/xrt/ipc/client/ipc_client_space_overseer.c

··· 7 7 * @ingroup ipc_client 8 8 */ 9 9 10 10 + #include "xrt/xrt_defines.h" 11 11 + #include "xrt/xrt_space.h" 12 12 + 13 13 + #include "shared/ipc_message_channel.h" 14 14 + 10 15 #include "client/ipc_client.h" 16 16 + #include "client/ipc_client_xdev.h" 11 17 #include "client/ipc_client_connection.h" 12 12 - #include "shared/ipc_message_channel.h" 13 13 - #include "xrt/xrt_defines.h" 14 14 - #include "xrt/xrt_space.h" 15 18 16 19 #include "ipc_client_generated.h" 17 20

+449

src/xrt/ipc/client/ipc_client_xdev.c

··· 1 1 + // Copyright 2020-2024, Collabora, Ltd. 2 2 + // Copyright 2025, NVIDIA CORPORATION. 3 3 + // SPDX-License-Identifier: BSL-1.0 4 4 + /*! 5 5 + * @file 6 6 + * @brief Shared functions for IPC client @ref xrt_device. 7 7 + * @author Jakob Bornecrantz <jakob@collabora.com> 8 8 + * @author Jakob Bornecrantz <tbornecrantz@nvidia.com> 9 9 + * @author Korcan Hussein <korcan.hussein@collabora.com> 10 10 + * @ingroup ipc_client 11 11 + */ 12 12 + 13 13 + #include "xrt/xrt_device.h" 14 14 + 15 15 + #include "os/os_time.h" 16 16 + 17 17 + #include "math/m_api.h" 18 18 + 19 19 + #include "util/u_var.h" 20 20 + #include "util/u_misc.h" 21 21 + #include "util/u_debug.h" 22 22 + #include "util/u_device.h" 23 23 + 24 24 + #include "client/ipc_client.h" 25 25 + #include "client/ipc_client_connection.h" 26 26 + #include "client/ipc_client_xdev.h" 27 27 + #include "ipc_client_generated.h" 28 28 + 29 29 + 30 30 + /* 31 31 + * 32 32 + * Functions from xrt_device. 33 33 + * 34 34 + */ 35 35 + 36 36 + static xrt_result_t 37 37 + ipc_client_xdev_update_inputs(struct xrt_device *xdev) 38 38 + { 39 39 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 40 40 + 41 41 + xrt_result_t xret = ipc_call_device_update_input(icx->ipc_c, icx->device_id); 42 42 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_update_input"); 43 43 + } 44 44 + 45 45 + static xrt_result_t 46 46 + ipc_client_xdev_get_tracked_pose(struct xrt_device *xdev, 47 47 + enum xrt_input_name name, 48 48 + int64_t at_timestamp_ns, 49 49 + struct xrt_space_relation *out_relation) 50 50 + { 51 51 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 52 52 + 53 53 + xrt_result_t xret = ipc_call_device_get_tracked_pose( // 54 54 + icx->ipc_c, // 55 55 + icx->device_id, // 56 56 + name, // 57 57 + at_timestamp_ns, // 58 58 + out_relation); // 59 59 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_get_tracked_pose"); 60 60 + } 61 61 + 62 62 + static void 63 63 + ipc_client_xdev_get_hand_tracking(struct xrt_device *xdev, 64 64 + enum xrt_input_name name, 65 65 + int64_t at_timestamp_ns, 66 66 + struct xrt_hand_joint_set *out_value, 67 67 + int64_t *out_timestamp_ns) 68 68 + { 69 69 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 70 70 + 71 71 + xrt_result_t xret = ipc_call_device_get_hand_tracking( // 72 72 + icx->ipc_c, // 73 73 + icx->device_id, // 74 74 + name, // 75 75 + at_timestamp_ns, // 76 76 + out_value, // 77 77 + out_timestamp_ns); // 78 78 + IPC_CHK_ONLY_PRINT(icx->ipc_c, xret, "ipc_call_device_get_hand_tracking"); 79 79 + } 80 80 + 81 81 + static xrt_result_t 82 82 + ipc_client_xdev_get_face_tracking(struct xrt_device *xdev, 83 83 + enum xrt_input_name facial_expression_type, 84 84 + int64_t at_timestamp_ns, 85 85 + struct xrt_facial_expression_set *out_value) 86 86 + { 87 87 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 88 88 + 89 89 + xrt_result_t xret = ipc_call_device_get_face_tracking( // 90 90 + icx->ipc_c, // 91 91 + icx->device_id, // 92 92 + facial_expression_type, // 93 93 + at_timestamp_ns, // 94 94 + out_value); // 95 95 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_get_face_tracking"); 96 96 + } 97 97 + 98 98 + static xrt_result_t 99 99 + ipc_client_xdev_get_body_skeleton(struct xrt_device *xdev, 100 100 + enum xrt_input_name body_tracking_type, 101 101 + struct xrt_body_skeleton *out_value) 102 102 + { 103 103 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 104 104 + 105 105 + xrt_result_t xret = ipc_call_device_get_body_skeleton( // 106 106 + icx->ipc_c, // 107 107 + icx->device_id, // 108 108 + body_tracking_type, // 109 109 + out_value); // 110 110 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_get_body_skeleton"); 111 111 + } 112 112 + 113 113 + static xrt_result_t 114 114 + ipc_client_xdev_get_body_joints(struct xrt_device *xdev, 115 115 + enum xrt_input_name body_tracking_type, 116 116 + int64_t desired_timestamp_ns, 117 117 + struct xrt_body_joint_set *out_value) 118 118 + { 119 119 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 120 120 + 121 121 + xrt_result_t xret = ipc_call_device_get_body_joints( // 122 122 + icx->ipc_c, // 123 123 + icx->device_id, // 124 124 + body_tracking_type, // 125 125 + desired_timestamp_ns, // 126 126 + out_value); // 127 127 + IPC_CHK_ALWAYS_RET(icx->ipc_c, xret, "ipc_call_device_get_body_joints"); 128 128 + } 129 129 + 130 130 + static void 131 131 + ipc_client_xdev_set_output(struct xrt_device *xdev, enum xrt_output_name name, const struct xrt_output_value *value) 132 132 + { 133 133 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 134 134 + struct ipc_connection *ipc_c = icx->ipc_c; 135 135 + 136 136 + xrt_result_t xret; 137 137 + if (value->type == XRT_OUTPUT_VALUE_TYPE_PCM_VIBRATION) { 138 138 + uint32_t samples_sent = MIN(value->pcm_vibration.sample_rate, 4000); 139 139 + 140 140 + struct ipc_pcm_haptic_buffer samples = { 141 141 + .append = value->pcm_vibration.append, 142 142 + .num_samples = samples_sent, 143 143 + .sample_rate = value->pcm_vibration.sample_rate, 144 144 + }; 145 145 + 146 146 + ipc_client_connection_lock(ipc_c); 147 147 + 148 148 + xret = ipc_send_device_set_haptic_output_locked(ipc_c, icx->device_id, name, &samples); 149 149 + IPC_CHK_WITH_RET(ipc_c, xret, "ipc_send_device_set_haptic_output_locked", ); 150 150 + 151 151 + xrt_result_t alloc_xret; 152 152 + xret = ipc_receive(&ipc_c->imc, &alloc_xret, sizeof alloc_xret); 153 153 + if (xret != XRT_SUCCESS || alloc_xret != XRT_SUCCESS) { 154 154 + goto send_haptic_output_end; 155 155 + } 156 156 + 157 157 + xret = ipc_send(&ipc_c->imc, value->pcm_vibration.buffer, sizeof(float) * samples_sent); 158 158 + if (xret != XRT_SUCCESS) { 159 159 + goto send_haptic_output_end; 160 160 + } 161 161 + 162 162 + xret = ipc_receive(&ipc_c->imc, value->pcm_vibration.samples_consumed, 163 163 + sizeof(*value->pcm_vibration.samples_consumed)); 164 164 + if (xret != XRT_SUCCESS) { 165 165 + goto send_haptic_output_end; 166 166 + } 167 167 + 168 168 + send_haptic_output_end: 169 169 + ipc_client_connection_unlock(ipc_c); 170 170 + } else { 171 171 + xret = ipc_call_device_set_output(ipc_c, icx->device_id, name, value); 172 172 + IPC_CHK_ONLY_PRINT(ipc_c, xret, "ipc_call_device_set_output"); 173 173 + } 174 174 + } 175 175 + 176 176 + xrt_result_t 177 177 + ipc_client_xdev_get_output_limits(struct xrt_device *xdev, struct xrt_output_limits *limits) 178 178 + { 179 179 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 180 180 + 181 181 + xrt_result_t xret = ipc_call_device_get_output_limits(icx->ipc_c, icx->device_id, limits); 182 182 + IPC_CHK_ONLY_PRINT(icx->ipc_c, xret, "ipc_call_device_get_output_limits"); 183 183 + 184 184 + return xret; 185 185 + } 186 186 + 187 187 + 188 188 + /* 189 189 + * 190 190 + * Plane detection functions. 191 191 + * 192 192 + */ 193 193 + 194 194 + static xrt_result_t 195 195 + ipc_client_xdev_begin_plane_detection_ext(struct xrt_device *xdev, 196 196 + const struct xrt_plane_detector_begin_info_ext *begin_info, 197 197 + uint64_t plane_detection_id, 198 198 + uint64_t *out_plane_detection_id) 199 199 + { 200 200 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 201 201 + 202 202 + icx->ipc_c->ism->plane_begin_info_ext = *begin_info; 203 203 + 204 204 + xrt_result_t r = ipc_call_device_begin_plane_detection_ext(icx->ipc_c, icx->device_id, plane_detection_id, 205 205 + out_plane_detection_id); 206 206 + if (r != XRT_SUCCESS) { 207 207 + IPC_ERROR(icx->ipc_c, "Error sending hmd_begin_plane_detection_ext!"); 208 208 + return r; 209 209 + } 210 210 + 211 211 + return XRT_SUCCESS; 212 212 + } 213 213 + 214 214 + static xrt_result_t 215 215 + ipc_client_xdev_destroy_plane_detection_ext(struct xrt_device *xdev, uint64_t plane_detection_id) 216 216 + { 217 217 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 218 218 + 219 219 + xrt_result_t r = ipc_call_device_destroy_plane_detection_ext(icx->ipc_c, icx->device_id, plane_detection_id); 220 220 + if (r != XRT_SUCCESS) { 221 221 + IPC_ERROR(icx->ipc_c, "Error sending destroy_plane_detection_ext!"); 222 222 + return r; 223 223 + } 224 224 + 225 225 + return XRT_SUCCESS; 226 226 + } 227 227 + 228 228 + /*! 229 229 + * Helper function for @ref xrt_device::get_plane_detection_state. 230 230 + * 231 231 + * @public @memberof xrt_device 232 232 + */ 233 233 + static xrt_result_t 234 234 + ipc_client_xdev_get_plane_detection_state_ext(struct xrt_device *xdev, 235 235 + uint64_t plane_detection_id, 236 236 + enum xrt_plane_detector_state_ext *out_state) 237 237 + { 238 238 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 239 239 + 240 240 + xrt_result_t r = 241 241 + ipc_call_device_get_plane_detection_state_ext(icx->ipc_c, icx->device_id, plane_detection_id, out_state); 242 242 + if (r != XRT_SUCCESS) { 243 243 + IPC_ERROR(icx->ipc_c, "Error sending get_plane_detection_state_ext!"); 244 244 + return r; 245 245 + } 246 246 + 247 247 + return XRT_SUCCESS; 248 248 + } 249 249 + 250 250 + /*! 251 251 + * Helper function for @ref xrt_device::get_plane_detections. 252 252 + * 253 253 + * @public @memberof xrt_device 254 254 + */ 255 255 + static xrt_result_t 256 256 + ipc_client_xdev_get_plane_detections_ext(struct xrt_device *xdev, 257 257 + uint64_t plane_detection_id, 258 258 + struct xrt_plane_detections_ext *out_detections) 259 259 + { 260 260 + struct ipc_client_xdev *icx = ipc_client_xdev(xdev); 261 261 + struct ipc_connection *ipc_c = icx->ipc_c; 262 262 + 263 263 + ipc_client_connection_lock(ipc_c); 264 264 + 265 265 + xrt_result_t xret = ipc_send_device_get_plane_detections_ext_locked(ipc_c, icx->device_id, plane_detection_id); 266 266 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_send_device_get_plane_detections_ext_locked", out); 267 267 + 268 268 + // in this case, size == count 269 269 + uint32_t location_size = 0; 270 270 + uint32_t polygon_size = 0; 271 271 + uint32_t vertex_size = 0; 272 272 + 273 273 + xret = ipc_receive_device_get_plane_detections_ext_locked(ipc_c, &location_size, &polygon_size, &vertex_size); 274 274 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_receive_device_get_plane_detections_ext_locked", out); 275 275 + 276 276 + 277 277 + // With no locations, the service won't send anything else 278 278 + if (location_size < 1) { 279 279 + out_detections->location_count = 0; 280 280 + goto out; 281 281 + } 282 282 + 283 283 + // realloc arrays in out_detections if necessary, then receive contents 284 284 + 285 285 + out_detections->location_count = location_size; 286 286 + if (out_detections->location_size < location_size) { 287 287 + U_ARRAY_REALLOC_OR_FREE(out_detections->locations, struct xrt_plane_detector_location_ext, 288 288 + location_size); 289 289 + U_ARRAY_REALLOC_OR_FREE(out_detections->polygon_info_start_index, uint32_t, location_size); 290 290 + out_detections->location_size = location_size; 291 291 + } 292 292 + 293 293 + if (out_detections->polygon_info_size < polygon_size) { 294 294 + U_ARRAY_REALLOC_OR_FREE(out_detections->polygon_infos, struct xrt_plane_polygon_info_ext, polygon_size); 295 295 + out_detections->polygon_info_size = polygon_size; 296 296 + } 297 297 + 298 298 + if (out_detections->vertex_size < vertex_size) { 299 299 + U_ARRAY_REALLOC_OR_FREE(out_detections->vertices, struct xrt_vec2, vertex_size); 300 300 + out_detections->vertex_size = vertex_size; 301 301 + } 302 302 + 303 303 + if ((location_size > 0 && 304 304 + (out_detections->locations == NULL || out_detections->polygon_info_start_index == NULL)) || 305 305 + (polygon_size > 0 && out_detections->polygon_infos == NULL) || 306 306 + (vertex_size > 0 && out_detections->vertices == NULL)) { 307 307 + IPC_ERROR(icx->ipc_c, "Error allocating memory for plane detections!"); 308 308 + out_detections->location_size = 0; 309 309 + out_detections->polygon_info_size = 0; 310 310 + out_detections->vertex_size = 0; 311 311 + xret = XRT_ERROR_IPC_FAILURE; 312 312 + goto out; 313 313 + } 314 314 + 315 315 + if (location_size > 0) { 316 316 + // receive location_count * locations 317 317 + xret = ipc_receive(&ipc_c->imc, out_detections->locations, 318 318 + sizeof(struct xrt_plane_detector_location_ext) * location_size); 319 319 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_receive(1)", out); 320 320 + 321 321 + // receive location_count * polygon_info_start_index 322 322 + xret = ipc_receive(&ipc_c->imc, out_detections->polygon_info_start_index, 323 323 + sizeof(uint32_t) * location_size); 324 324 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_receive(2)", out); 325 325 + } 326 326 + 327 327 + 328 328 + if (polygon_size > 0) { 329 329 + // receive polygon_count * polygon_infos 330 330 + xret = ipc_receive(&ipc_c->imc, out_detections->polygon_infos, 331 331 + sizeof(struct xrt_plane_polygon_info_ext) * polygon_size); 332 332 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_receive(3)", out); 333 333 + } 334 334 + 335 335 + if (vertex_size > 0) { 336 336 + // receive vertex_count * vertices 337 337 + xret = ipc_receive(&ipc_c->imc, out_detections->vertices, sizeof(struct xrt_vec2) * vertex_size); 338 338 + IPC_CHK_WITH_GOTO(icx->ipc_c, xret, "ipc_receive(4)", out); 339 339 + } 340 340 + 341 341 + out: 342 342 + ipc_client_connection_unlock(ipc_c); 343 343 + return xret; 344 344 + } 345 345 + 346 346 + 347 347 + /* 348 348 + * 349 349 + * 'Exported' functions. 350 350 + * 351 351 + */ 352 352 + 353 353 + void 354 354 + ipc_client_xdev_init(struct ipc_client_xdev *icx, 355 355 + struct ipc_connection *ipc_c, 356 356 + struct xrt_tracking_origin *xtrack, 357 357 + uint32_t device_id) 358 358 + { 359 359 + // Helpers. 360 360 + struct ipc_shared_memory *ism = ipc_c->ism; 361 361 + struct ipc_shared_device *isdev = &ism->isdevs[device_id]; 362 362 + 363 363 + // Important fields. 364 364 + icx->ipc_c = ipc_c; 365 365 + icx->device_id = device_id; 366 366 + 367 367 + // Shared implemented functions. 368 368 + icx->base.update_inputs = ipc_client_xdev_update_inputs; 369 369 + icx->base.get_tracked_pose = ipc_client_xdev_get_tracked_pose; 370 370 + icx->base.get_hand_tracking = ipc_client_xdev_get_hand_tracking; 371 371 + icx->base.get_face_tracking = ipc_client_xdev_get_face_tracking; 372 372 + icx->base.get_body_skeleton = ipc_client_xdev_get_body_skeleton; 373 373 + icx->base.get_body_joints = ipc_client_xdev_get_body_joints; 374 374 + icx->base.set_output = ipc_client_xdev_set_output; 375 375 + icx->base.get_output_limits = ipc_client_xdev_get_output_limits; 376 376 + 377 377 + // Plane detection EXT. 378 378 + icx->base.begin_plane_detection_ext = ipc_client_xdev_begin_plane_detection_ext; 379 379 + icx->base.destroy_plane_detection_ext = ipc_client_xdev_destroy_plane_detection_ext; 380 380 + icx->base.get_plane_detection_state_ext = ipc_client_xdev_get_plane_detection_state_ext; 381 381 + icx->base.get_plane_detections_ext = ipc_client_xdev_get_plane_detections_ext; 382 382 + 383 383 + // Not implemented functions, some get overridden. 384 384 + icx->base.get_view_poses = u_device_ni_get_view_poses; 385 385 + icx->base.compute_distortion = u_device_ni_compute_distortion; 386 386 + icx->base.get_visibility_mask = u_device_ni_get_visibility_mask; 387 387 + icx->base.is_form_factor_available = u_device_ni_is_form_factor_available; 388 388 + icx->base.get_battery_status = u_device_ni_get_battery_status; 389 389 + 390 390 + // Copying the information from the isdev. 391 391 + icx->base.device_type = isdev->device_type; 392 392 + icx->base.supported = isdev->supported; 393 393 + icx->base.tracking_origin = xtrack; 394 394 + icx->base.name = isdev->name; 395 395 + 396 396 + // Print name. 397 397 + snprintf(icx->base.str, XRT_DEVICE_NAME_LEN, "%s", isdev->str); 398 398 + snprintf(icx->base.serial, XRT_DEVICE_NAME_LEN, "%s", isdev->serial); 399 399 + 400 400 + // Setup inputs, by pointing directly to the shared memory. 401 401 + assert(isdev->input_count > 0); 402 402 + icx->base.inputs = &ism->inputs[isdev->first_input_index]; 403 403 + icx->base.input_count = isdev->input_count; 404 404 + 405 405 + // Setup outputs, if any point directly into the shared memory. 406 406 + icx->base.output_count = isdev->output_count; 407 407 + if (isdev->output_count > 0) { 408 408 + icx->base.outputs = &ism->outputs[isdev->first_output_index]; 409 409 + } else { 410 410 + icx->base.outputs = NULL; 411 411 + } 412 412 + 413 413 + // Setup binding profiles. 414 414 + icx->base.binding_profile_count = isdev->binding_profile_count; 415 415 + if (isdev->binding_profile_count > 0) { 416 416 + icx->base.binding_profiles = 417 417 + U_TYPED_ARRAY_CALLOC(struct xrt_binding_profile, isdev->binding_profile_count); 418 418 + } 419 419 + 420 420 + for (size_t i = 0; i < isdev->binding_profile_count; i++) { 421 421 + struct xrt_binding_profile *xbp = &icx->base.binding_profiles[i]; 422 422 + struct ipc_shared_binding_profile *isbp = 423 423 + &ism->binding_profiles[isdev->first_binding_profile_index + i]; 424 424 + 425 425 + xbp->name = isbp->name; 426 426 + if (isbp->input_count > 0) { 427 427 + xbp->inputs = &ism->input_pairs[isbp->first_input_index]; 428 428 + xbp->input_count = isbp->input_count; 429 429 + } 430 430 + if (isbp->output_count > 0) { 431 431 + xbp->outputs = &ism->output_pairs[isbp->first_output_index]; 432 432 + xbp->output_count = isbp->output_count; 433 433 + } 434 434 + } 435 435 + } 436 436 + 437 437 + void 438 438 + ipc_client_xdev_fini(struct ipc_client_xdev *icx) 439 439 + { 440 440 + // We do not own these, so don't free them. 441 441 + icx->base.inputs = NULL; 442 442 + icx->base.outputs = NULL; 443 443 + 444 444 + // We allocated the bindings profiles. 445 445 + if (icx->base.binding_profiles != NULL) { 446 446 + free(icx->base.binding_profiles); 447 447 + icx->base.binding_profiles = NULL; 448 448 + } 449 449 + }

+75

src/xrt/ipc/client/ipc_client_xdev.h

··· 1 1 + // Copyright 2020-2023, Collabora, Ltd. 2 2 + // Copyright 2025, NVIDIA CORPORATION. 3 3 + // SPDX-License-Identifier: BSL-1.0 4 4 + /*! 5 5 + * @file 6 6 + * @brief Shared functions for IPC client @ref xrt_device. 7 7 + * @author Pete Black <pblack@collabora.com> 8 8 + * @author Jakob Bornecrantz <jakob@collabora.com> 9 9 + * @author Jakob Bornecrantz <tbornecrantz@nvidia.com> 10 10 + * @author Rylie Pavlik <rylie.pavlik@collabora.com> 11 11 + * @ingroup ipc_client 12 12 + */ 13 13 + 14 14 + #pragma once 15 15 + 16 16 + #ifdef __cplusplus 17 17 + extern "C" { 18 18 + #endif 19 19 + 20 20 + 21 21 + struct ipc_connection; 22 22 + 23 23 + /*! 24 24 + * An IPC client proxy for an @ref xrt_device. 25 25 + * 26 26 + * @implements xrt_device 27 27 + * @ingroup ipc_client 28 28 + */ 29 29 + struct ipc_client_xdev 30 30 + { 31 31 + struct xrt_device base; 32 32 + 33 33 + struct ipc_connection *ipc_c; 34 34 + 35 35 + uint32_t device_id; 36 36 + }; 37 37 + 38 38 + /*! 39 39 + * Convenience helper to go from a xdev to @ref ipc_client_xdev. 40 40 + * 41 41 + * @ingroup ipc_client 42 42 + */ 43 43 + static inline struct ipc_client_xdev * 44 44 + ipc_client_xdev(struct xrt_device *xdev) 45 45 + { 46 46 + return (struct ipc_client_xdev *)xdev; 47 47 + } 48 48 + 49 49 + /*! 50 50 + * Initializes a ipc_client_xdev so that it's basically fully usable as a 51 51 + * @ref xrt_device object. Does not fill in the destroy function or the any 52 52 + * if the HMD components / functions. 53 53 + * 54 54 + * @ingroup ipc_client 55 55 + * @public @memberof ipc_client_xdev 56 56 + */ 57 57 + void 58 58 + ipc_client_xdev_init(struct ipc_client_xdev *icx, 59 59 + struct ipc_connection *ipc_c, 60 60 + struct xrt_tracking_origin *xtrack, 61 61 + uint32_t device_id); 62 62 + 63 63 + /*! 64 64 + * Frees any memory that was allocated as part of init and resets some pointers. 65 65 + * 66 66 + * @ingroup ipc_client 67 67 + * @public @memberof ipc_client_xdev 68 68 + */ 69 69 + void 70 70 + ipc_client_xdev_fini(struct ipc_client_xdev *icx); 71 71 + 72 72 + 73 73 + #ifdef __cplusplus 74 74 + } 75 75 + #endif