+2

src/xrt/ipc/client/ipc_client_device.c

··· 280 280 icd->base.body_tracking_supported = isdev->body_tracking_supported; 281 281 icd->base.force_feedback_supported = isdev->force_feedback_supported; 282 282 icd->base.stage_supported = isdev->stage_supported; 283 283 + icd->base.planes_supported = isdev->planes_supported; 284 284 + icd->base.plane_capability_flags = isdev->plane_capability_flags; 283 285 284 286 icd->base.device_type = isdev->device_type; 285 287 return &icd->base;

+158

src/xrt/ipc/client/ipc_client_hmd.c

··· 271 271 return available; 272 272 } 273 273 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 + 274 426 static xrt_result_t 275 427 ipc_client_hmd_get_visibility_mask(struct xrt_device *xdev, 276 428 enum xrt_visibility_mask_type type, ··· 332 484 ich->base.get_face_tracking = ipc_client_hmd_get_face_tracking; 333 485 ich->base.get_view_poses = ipc_client_hmd_get_view_poses; 334 486 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; 335 491 ich->base.destroy = ipc_client_hmd_destroy; 336 492 ich->base.is_form_factor_available = ipc_client_hmd_is_form_factor_available; 337 493 ich->base.get_visibility_mask = ipc_client_hmd_get_visibility_mask; ··· 396 552 ich->base.form_factor_check_supported = isdev->form_factor_check_supported; 397 553 ich->base.stage_supported = isdev->stage_supported; 398 554 ich->base.battery_status_supported = isdev->battery_status_supported; 555 555 + ich->base.planes_supported = isdev->planes_supported; 556 556 + ich->base.plane_capability_flags = isdev->plane_capability_flags; 399 557 400 558 return &ich->base; 401 559 }

+10

src/xrt/ipc/server/ipc_server.h

··· 140 140 141 141 struct ipc_app_state client_state; 142 142 143 143 + 144 144 + uint64_t plane_detection_size; 145 145 + uint64_t plane_detection_count; 146 146 + 147 147 + //! Array of plane detection ids with plane_detection_size entries. 148 148 + uint64_t *plane_detection_ids; 149 149 + 150 150 + //! Array of xrt_devices with plane_detection_size entries. 151 151 + struct xrt_device **plane_detection_xdev; 152 152 + 143 153 int server_thread_index; 144 154 }; 145 155

+170

src/xrt/ipc/server/ipc_server_handler.c

··· 2081 2081 } 2082 2082 2083 2083 xrt_result_t 2084 2084 + ipc_handle_device_begin_plane_detection_ext(volatile struct ipc_client_state *ics, 2085 2085 + uint32_t id, 2086 2086 + uint64_t plane_detection_id, 2087 2087 + uint64_t *out_plane_detection_id) 2088 2088 + { 2089 2089 + // To make the code a bit more readable. 2090 2090 + uint32_t device_id = id; 2091 2091 + struct xrt_device *xdev = get_xdev(ics, device_id); 2092 2092 + 2093 2093 + uint64_t new_count = ics->plane_detection_count + 1; 2094 2094 + 2095 2095 + if (new_count > ics->plane_detection_size) { 2096 2096 + IPC_TRACE(ics->server, "Plane detections tracking size: %u -> %u", (uint32_t)ics->plane_detection_count, 2097 2097 + (uint32_t)new_count); 2098 2098 + 2099 2099 + U_ARRAY_REALLOC_OR_FREE(ics->plane_detection_ids, uint64_t, new_count); 2100 2100 + U_ARRAY_REALLOC_OR_FREE(ics->plane_detection_xdev, struct xrt_device *, new_count); 2101 2101 + ics->plane_detection_size = new_count; 2102 2102 + } 2103 2103 + 2104 2104 + struct xrt_plane_detector_begin_info_ext *begin_info = &ics->server->ism->plane_begin_info_ext; 2105 2105 + 2106 2106 + enum xrt_result xret = 2107 2107 + xrt_device_begin_plane_detection_ext(xdev, begin_info, plane_detection_id, out_plane_detection_id); 2108 2108 + if (xret != XRT_SUCCESS) { 2109 2109 + IPC_TRACE(ics->server, "xrt_device_begin_plane_detection_ext error: %d", xret); 2110 2110 + return xret; 2111 2111 + } 2112 2112 + 2113 2113 + if (*out_plane_detection_id != 0) { 2114 2114 + uint64_t index = ics->plane_detection_count; 2115 2115 + ics->plane_detection_ids[index] = *out_plane_detection_id; 2116 2116 + ics->plane_detection_xdev[index] = xdev; 2117 2117 + ics->plane_detection_count = new_count; 2118 2118 + } 2119 2119 + 2120 2120 + return XRT_SUCCESS; 2121 2121 + } 2122 2122 + 2123 2123 + xrt_result_t 2124 2124 + ipc_handle_device_destroy_plane_detection_ext(volatile struct ipc_client_state *ics, 2125 2125 + uint32_t id, 2126 2126 + uint64_t plane_detection_id) 2127 2127 + { 2128 2128 + // To make the code a bit more readable. 2129 2129 + uint32_t device_id = id; 2130 2130 + struct xrt_device *xdev = get_xdev(ics, device_id); 2131 2131 + 2132 2132 + enum xrt_result xret = xrt_device_destroy_plane_detection_ext(xdev, plane_detection_id); 2133 2133 + 2134 2134 + // Iterate through plane detection ids. Once found, move every item one slot to the left. 2135 2135 + bool compact_right = false; 2136 2136 + for (uint32_t i = 0; i < ics->plane_detection_count; i++) { 2137 2137 + if (ics->plane_detection_ids[i] == plane_detection_id) { 2138 2138 + compact_right = true; 2139 2139 + } 2140 2140 + if (compact_right && (i + 1) < ics->plane_detection_count) { 2141 2141 + ics->plane_detection_ids[i] = ics->plane_detection_ids[i + 1]; 2142 2142 + ics->plane_detection_xdev[i] = ics->plane_detection_xdev[i + 1]; 2143 2143 + } 2144 2144 + } 2145 2145 + // if the plane detection was correctly tracked compact_right should always be true 2146 2146 + if (compact_right) { 2147 2147 + ics->plane_detection_count -= 1; 2148 2148 + } else { 2149 2149 + IPC_ERROR(ics->server, "Destroyed plane detection that was not tracked"); 2150 2150 + } 2151 2151 + 2152 2152 + if (xret != XRT_SUCCESS) { 2153 2153 + IPC_ERROR(ics->server, "xrt_device_destroy_plane_detection_ext error: %d", xret); 2154 2154 + return xret; 2155 2155 + } 2156 2156 + 2157 2157 + return XRT_SUCCESS; 2158 2158 + } 2159 2159 + 2160 2160 + xrt_result_t 2161 2161 + ipc_handle_device_get_plane_detection_state_ext(volatile struct ipc_client_state *ics, 2162 2162 + uint32_t id, 2163 2163 + uint64_t plane_detection_id, 2164 2164 + enum xrt_plane_detector_state_ext *out_state) 2165 2165 + { 2166 2166 + // To make the code a bit more readable. 2167 2167 + uint32_t device_id = id; 2168 2168 + struct xrt_device *xdev = get_xdev(ics, device_id); 2169 2169 + 2170 2170 + xrt_result_t xret = xrt_device_get_plane_detection_state_ext(xdev, plane_detection_id, out_state); 2171 2171 + if (xret != XRT_SUCCESS) { 2172 2172 + IPC_ERROR(ics->server, "xrt_device_get_plane_detection_state_ext error: %d", xret); 2173 2173 + return xret; 2174 2174 + } 2175 2175 + 2176 2176 + return XRT_SUCCESS; 2177 2177 + } 2178 2178 + 2179 2179 + xrt_result_t 2180 2180 + ipc_handle_device_get_plane_detections_ext(volatile struct ipc_client_state *ics, 2181 2181 + uint32_t id, 2182 2182 + uint64_t plane_detection_id) 2183 2183 + 2184 2184 + { 2185 2185 + struct ipc_message_channel *imc = (struct ipc_message_channel *)&ics->imc; 2186 2186 + struct ipc_device_get_plane_detections_ext_reply reply = XRT_STRUCT_INIT; 2187 2187 + struct ipc_server *s = ics->server; 2188 2188 + 2189 2189 + // To make the code a bit more readable. 2190 2190 + uint32_t device_id = id; 2191 2191 + struct xrt_device *xdev = get_xdev(ics, device_id); 2192 2192 + 2193 2193 + struct xrt_plane_detections_ext out = {0}; 2194 2194 + 2195 2195 + xrt_result_t xret = xrt_device_get_plane_detections_ext(xdev, plane_detection_id, &out); 2196 2196 + if (xret != XRT_SUCCESS) { 2197 2197 + IPC_ERROR(ics->server, "xrt_device_get_plane_detections_ext error: %d", xret); 2198 2198 + // probably nothing allocated on error, but make sure 2199 2199 + xrt_plane_detections_ext_clear(&out); 2200 2200 + return xret; 2201 2201 + } 2202 2202 + 2203 2203 + reply.result = XRT_SUCCESS; 2204 2204 + reply.location_size = out.location_count; // because we initialized to 0, now size == count 2205 2205 + reply.polygon_size = out.polygon_info_size; 2206 2206 + reply.vertex_size = out.vertex_size; 2207 2207 + 2208 2208 + xret = ipc_send(imc, &reply, sizeof(reply)); 2209 2209 + if (xret != XRT_SUCCESS) { 2210 2210 + IPC_ERROR(s, "Failed to send reply!"); 2211 2211 + goto out; 2212 2212 + } 2213 2213 + 2214 2214 + // send expected contents 2215 2215 + 2216 2216 + if (out.location_count > 0) { 2217 2217 + xret = 2218 2218 + ipc_send(imc, out.locations, sizeof(struct xrt_plane_detector_location_ext) * out.location_count); 2219 2219 + if (xret != XRT_SUCCESS) { 2220 2220 + IPC_ERROR(s, "Failed to send locations!"); 2221 2221 + goto out; 2222 2222 + } 2223 2223 + 2224 2224 + xret = ipc_send(imc, out.polygon_info_start_index, sizeof(uint32_t) * out.location_count); 2225 2225 + if (xret != XRT_SUCCESS) { 2226 2226 + IPC_ERROR(s, "Failed to send locations!"); 2227 2227 + goto out; 2228 2228 + } 2229 2229 + } 2230 2230 + 2231 2231 + if (out.polygon_info_size > 0) { 2232 2232 + xret = 2233 2233 + ipc_send(imc, out.polygon_infos, sizeof(struct xrt_plane_polygon_info_ext) * out.polygon_info_size); 2234 2234 + if (xret != XRT_SUCCESS) { 2235 2235 + IPC_ERROR(s, "Failed to send polygon_infos!"); 2236 2236 + goto out; 2237 2237 + } 2238 2238 + } 2239 2239 + 2240 2240 + if (out.vertex_size > 0) { 2241 2241 + xret = ipc_send(imc, out.vertices, sizeof(struct xrt_vec2) * out.vertex_size); 2242 2242 + if (xret != XRT_SUCCESS) { 2243 2243 + IPC_ERROR(s, "Failed to send vertices!"); 2244 2244 + goto out; 2245 2245 + } 2246 2246 + } 2247 2247 + 2248 2248 + out: 2249 2249 + xrt_plane_detections_ext_clear(&out); 2250 2250 + return xret; 2251 2251 + } 2252 2252 + 2253 2253 + xrt_result_t 2084 2254 ipc_handle_device_set_output(volatile struct ipc_client_state *ics, 2085 2255 uint32_t id, 2086 2256 enum xrt_output_name name,

+11

src/xrt/ipc/server/ipc_server_per_client_thread.c

··· 101 101 ics->device_feature_used[i] = false; 102 102 } 103 103 104 104 + // Make sure undestroyed plane detections are cleaned up 105 105 + for (uint32_t i = 0; i < ics->plane_detection_count; i++) { 106 106 + xrt_device_destroy_plane_detection_ext(ics->plane_detection_xdev[i], ics->plane_detection_ids[i]); 107 107 + } 108 108 + free(ics->plane_detection_ids); 109 109 + free(ics->plane_detection_xdev); 110 110 + ics->plane_detection_ids = NULL; 111 111 + ics->plane_detection_xdev = NULL; 112 112 + ics->plane_detection_size = 0; 113 113 + ics->plane_detection_count = 0; 114 114 + 104 115 // Should we stop the server when a client disconnects? 105 116 if (ics->server->exit_on_disconnect) { 106 117 ics->server->running = false;

+7

src/xrt/ipc/server/ipc_server_process.c

··· 356 356 isdev->body_tracking_supported = xdev->body_tracking_supported; 357 357 isdev->stage_supported = xdev->stage_supported; 358 358 isdev->battery_status_supported = xdev->battery_status_supported; 359 359 + isdev->planes_supported = xdev->planes_supported; 360 360 + isdev->plane_capability_flags = xdev->plane_capability_flags; 359 361 360 362 // Setup the tracking origin. 361 363 isdev->tracking_origin_index = (uint32_t)-1; ··· 964 966 ics->server = vs; 965 967 ics->server_thread_index = cs_index; 966 968 ics->io_active = true; 969 969 + 970 970 + ics->plane_detection_size = 0; 971 971 + ics->plane_detection_count = 0; 972 972 + ics->plane_detection_ids = NULL; 973 973 + ics->plane_detection_xdev = NULL; 967 974 968 975 os_thread_start(&it->thread, ipc_server_client_thread, (void *)ics); 969 976

+5 -2

src/xrt/ipc/shared/ipc_protocol.h

··· 145 145 bool form_factor_check_supported; 146 146 bool stage_supported; 147 147 bool battery_status_supported; 148 148 + bool planes_supported; 149 149 + enum xrt_plane_detection_capability_flags_ext plane_capability_flags; 148 150 }; 149 151 150 150 - static_assert(sizeof(struct ipc_shared_device) == 560, 152 152 + static_assert(sizeof(struct ipc_shared_device) == 564, 151 153 "invalid structure size, maybe different 32/64 bits sizes or padding"); 152 154 153 155 /*! ··· 296 298 struct ipc_layer_slot slots[IPC_MAX_SLOTS]; 297 299 298 300 uint64_t startup_timestamp; 301 301 + struct xrt_plane_detector_begin_info_ext plane_begin_info_ext; 299 302 }; 300 303 301 301 - static_assert(sizeof(struct ipc_shared_memory) == 6497680, 304 304 + static_assert(sizeof(struct ipc_shared_memory) == 6499920, 302 305 "invalid structure size, maybe different 32/64 bits sizes or padding"); 303 306 304 307 /*!

+40

src/xrt/ipc/shared/proto.json

··· 465 465 ] 466 466 }, 467 467 468 468 + "device_begin_plane_detection_ext": { 469 469 + "in": [ 470 470 + {"name": "id", "type": "uint32_t"}, 471 471 + {"name": "plane_detection_id", "type": "uint64_t"} 472 472 + ], 473 473 + "out": [ 474 474 + {"name": "out_plane_detection_id", "type": "uint64_t"} 475 475 + ] 476 476 + }, 477 477 + 478 478 + "device_destroy_plane_detection_ext": { 479 479 + "in": [ 480 480 + {"name": "id", "type": "uint32_t"}, 481 481 + {"name": "plane_detection_id", "type": "uint64_t"} 482 482 + ] 483 483 + }, 484 484 + 485 485 + "device_get_plane_detection_state_ext": { 486 486 + "in": [ 487 487 + {"name": "id", "type": "uint32_t"}, 488 488 + {"name": "plane_detection_id", "type": "uint64_t"} 489 489 + ], 490 490 + "out": [ 491 491 + {"name": "state", "type": "enum xrt_plane_detector_state_ext"} 492 492 + ] 493 493 + }, 494 494 + 495 495 + "device_get_plane_detections_ext": { 496 496 + "varlen": true, 497 497 + "in": [ 498 498 + {"name": "id", "type": "uint32_t"}, 499 499 + {"name": "plane_detection_id", "type": "uint64_t"} 500 500 + ], 501 501 + "out": [ 502 502 + {"name": "location_size", "type": "uint32_t"}, 503 503 + {"name": "polygon_size", "type": "uint32_t"}, 504 504 + {"name": "vertex_size", "type": "uint32_t"} 505 505 + ] 506 506 + }, 507 507 + 468 508 "device_set_output": { 469 509 "in": [ 470 510 {"name": "id", "type": "uint32_t"},