The open source OpenXR runtime
ipc: Reflect tracking origins correctly
+144
-15
+6
-2
src/xrt/ipc/ipc_client.h
+6
-2
src/xrt/ipc/ipc_client.h
···
120
120
struct xrt_compositor_fd **out_xcfd);
121
121
122
122
struct xrt_device *
123
-
ipc_client_hmd_create(ipc_connection_t *ipc_c, uint32_t device_id);
123
+
ipc_client_hmd_create(ipc_connection_t *ipc_c,
124
+
struct xrt_tracking_origin *xtrack,
125
+
uint32_t device_id);
124
126
125
127
struct xrt_device *
126
-
ipc_client_device_create(ipc_connection_t *ipc_c, uint32_t device_id);
128
+
ipc_client_device_create(ipc_connection_t *ipc_c,
129
+
struct xrt_tracking_origin *xtrack,
130
+
uint32_t device_id);
+6
-3
src/xrt/ipc/ipc_client_device.c
+6
-3
src/xrt/ipc/ipc_client_device.c
···
126
126
}
127
127
128
128
struct xrt_device *
129
-
ipc_client_device_create(ipc_connection_t *ipc_c, uint32_t device_id)
129
+
ipc_client_device_create(ipc_connection_t *ipc_c,
130
+
struct xrt_tracking_origin *xtrack,
131
+
uint32_t device_id)
130
132
{
131
133
// Helpers.
132
134
struct ipc_shared_memory *ism = ipc_c->ism;
133
135
struct ipc_shared_device *idev = &ism->idevs[device_id];
134
136
135
137
// Allocate and setup the basics.
136
-
enum u_device_alloc_flags flags = (enum u_device_alloc_flags)(
137
-
U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE);
138
+
enum u_device_alloc_flags flags =
139
+
(enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD);
138
140
struct ipc_client_device *icd =
139
141
U_DEVICE_ALLOCATE(struct ipc_client_device, flags, 0, 0);
140
142
icd->ipc_c = ipc_c;
···
145
147
icd->base.destroy = ipc_client_device_destroy;
146
148
147
149
// Start copying the information from the idev.
150
+
icd->base.tracking_origin = xtrack;
148
151
icd->base.name = idev->name;
149
152
icd->device_id = device_id;
150
153
+7
-3
src/xrt/ipc/ipc_client_hmd.c
+7
-3
src/xrt/ipc/ipc_client_hmd.c
···
118
118
}
119
119
120
120
struct xrt_device *
121
-
ipc_client_hmd_create(ipc_connection_t *ipc_c, uint32_t device_id)
121
+
ipc_client_hmd_create(ipc_connection_t *ipc_c,
122
+
struct xrt_tracking_origin *xtrack,
123
+
uint32_t device_id)
122
124
{
123
125
struct ipc_shared_memory *ism = ipc_c->ism;
124
126
struct ipc_shared_device *idev = &ism->idevs[device_id];
125
127
126
128
127
129
128
-
enum u_device_alloc_flags flags = (enum u_device_alloc_flags)(
129
-
U_DEVICE_ALLOC_HMD | U_DEVICE_ALLOC_TRACKING_NONE);
130
+
enum u_device_alloc_flags flags =
131
+
(enum u_device_alloc_flags)(U_DEVICE_ALLOC_HMD);
130
132
struct ipc_client_hmd *ich =
131
133
U_DEVICE_ALLOCATE(struct ipc_client_hmd, flags, 0, 0);
132
134
ich->ipc_c = ipc_c;
···
137
139
ich->base.destroy = ipc_client_hmd_destroy;
138
140
139
141
// Start copying the information from the idev.
142
+
ich->base.tracking_origin = xtrack;
140
143
ich->base.name = idev->name;
141
144
ich->device_id = device_id;
145
+
142
146
// Print name.
143
147
snprintf(ich->base.str, XRT_DEVICE_NAME_LEN, "%s", idev->str);
144
148
+35
-5
src/xrt/ipc/ipc_client_instance.c
+35
-5
src/xrt/ipc/ipc_client_instance.c
···
39
39
40
40
ipc_connection_t ipc_c;
41
41
42
+
struct xrt_tracking_origin *xtracks[8];
43
+
size_t num_xtracks;
44
+
42
45
struct xrt_device *xdevs[8];
43
46
size_t num_xdevs;
44
47
};
···
146
149
struct ipc_client_instance *ii = ipc_client_instance(xinst);
147
150
148
151
// service considers us to be connected until fd is closed
149
-
if (ii->ipc_c.socket_fd >= 0)
152
+
if (ii->ipc_c.socket_fd >= 0) {
150
153
close(ii->ipc_c.socket_fd);
154
+
}
155
+
156
+
for (size_t i = 0; i < ii->num_xtracks; i++) {
157
+
free(ii->xtracks[i]);
158
+
ii->xtracks[i] = NULL;
159
+
}
160
+
ii->num_xtracks = 0;
151
161
152
162
os_mutex_destroy(&ii->ipc_c.mutex);
153
163
···
213
223
return -1;
214
224
}
215
225
226
+
uint32_t count = 0;
227
+
struct xrt_tracking_origin *xtrack = NULL;
216
228
struct ipc_shared_memory *ism = ii->ipc_c.ism;
217
229
230
+
// Query the server for how many tracking origins it has.
231
+
count = 0;
232
+
for (uint32_t i = 0; i < ism->num_itracks; i++) {
233
+
fprintf(stderr, "%s\n", ism->itracks[i].name);
234
+
xtrack = U_TYPED_CALLOC(struct xrt_tracking_origin);
218
235
219
-
uint32_t count = 0;
236
+
memcpy(xtrack->name, ism->itracks[i].name,
237
+
sizeof(xtrack->name));
238
+
239
+
xtrack->type = ism->itracks[i].type;
240
+
xtrack->offset = ism->itracks[i].offset;
241
+
ii->xtracks[count++] = xtrack;
242
+
}
243
+
244
+
ii->num_xtracks = count;
245
+
220
246
// Query the server for how many devices it has.
247
+
count = 0;
221
248
for (uint32_t i = 0; i < ism->num_idevs; i++) {
222
-
if (ism->idevs[i].name == XRT_DEVICE_GENERIC_HMD) {
249
+
struct ipc_shared_device *idev = &ism->idevs[i];
250
+
xtrack = ii->xtracks[idev->tracking_origin_index];
251
+
252
+
if (idev->name == XRT_DEVICE_GENERIC_HMD) {
223
253
ii->xdevs[count++] =
224
-
ipc_client_hmd_create(&ii->ipc_c, i);
254
+
ipc_client_hmd_create(&ii->ipc_c, xtrack, i);
225
255
} else {
226
256
ii->xdevs[count++] =
227
-
ipc_client_device_create(&ii->ipc_c, i);
257
+
ipc_client_device_create(&ii->ipc_c, xtrack, i);
228
258
}
229
259
}
230
260
+19
src/xrt/ipc/ipc_protocol.h
+19
src/xrt/ipc/ipc_protocol.h
···
9
9
10
10
#pragma once
11
11
12
+
#include "xrt/xrt_tracking.h"
12
13
#include "xrt/xrt_device.h"
13
14
#include "xrt/xrt_compiler.h"
14
15
···
32
33
*
33
34
*/
34
35
36
+
struct ipc_shared_tracking_origin
37
+
{
38
+
//! For debugging.
39
+
char name[XRT_TRACKING_NAME_LEN];
40
+
41
+
//! What can the state tracker expect from this tracking system.
42
+
enum xrt_tracking_type type;
43
+
44
+
//! Initial offset of the tracking origin.
45
+
struct xrt_pose offset;
46
+
};
47
+
35
48
struct ipc_shared_device
36
49
{
37
50
//! Enum identifier of the device.
38
51
enum xrt_device_name name;
52
+
53
+
//! Which tracking system origin is this device attached to.
54
+
uint32_t tracking_origin_index;
39
55
40
56
//! A string describing the device.
41
57
char str[XRT_DEVICE_NAME_LEN];
···
133
149
*/
134
150
struct ipc_shared_memory
135
151
{
152
+
// This array may be sparse.
153
+
size_t num_itracks;
154
+
struct ipc_shared_tracking_origin itracks[IPC_SHARED_MAX_DEVICES];
136
155
size_t num_idevs;
137
156
struct ipc_shared_device idevs[IPC_SHARED_MAX_DEVICES];
138
157
+1
src/xrt/ipc/ipc_server.h
+1
src/xrt/ipc/ipc_server.h
+70
-2
src/xrt/ipc/ipc_server_process.c
+70
-2
src/xrt/ipc/ipc_server_process.c
···
37
37
#include <errno.h>
38
38
#include <stdio.h>
39
39
#include <string.h>
40
+
#include <assert.h>
40
41
41
42
#ifdef XRT_HAVE_SYSTEMD
42
43
#include <systemd/sd-daemon.h>
43
44
#endif
45
+
44
46
45
47
/*
46
48
*
···
86
88
}
87
89
88
90
static int
91
+
init_tracking_origins(struct ipc_server *s)
92
+
{
93
+
for (size_t i = 0; i < IPC_SERVER_NUM_XDEVS; i++) {
94
+
if (s->xdevs[i] == NULL) {
95
+
continue;
96
+
}
97
+
98
+
struct xrt_device *xdev = s->xdevs[i];
99
+
struct xrt_tracking_origin *xtrack = xdev->tracking_origin;
100
+
size_t index = 0;
101
+
102
+
for (; index < IPC_SERVER_NUM_XDEVS; index++) {
103
+
if (s->xtracks[index] == NULL) {
104
+
s->xtracks[index] = xtrack;
105
+
break;
106
+
} else if (s->xtracks[index] == xtrack) {
107
+
break;
108
+
}
109
+
}
110
+
}
111
+
112
+
return 0;
113
+
}
114
+
115
+
static int
89
116
init_shm(struct ipc_server *s)
90
117
{
91
118
const size_t size = sizeof(struct ipc_shared_memory);
···
121
148
*
122
149
*/
123
150
124
-
uint32_t input_index = 0;
125
-
uint32_t output_index = 0;
126
151
uint32_t count = 0;
127
152
struct ipc_shared_memory *ism = s->ism;
128
153
154
+
count = 0;
155
+
for (size_t i = 0; i < IPC_SERVER_NUM_XDEVS; i++) {
156
+
struct xrt_tracking_origin *xtrack = s->xtracks[i];
157
+
if (xtrack == NULL) {
158
+
continue;
159
+
}
160
+
161
+
// The position of the tracking origin matches that in the
162
+
// servers memory.
163
+
assert(i < IPC_SHARED_MAX_DEVICES);
164
+
165
+
struct ipc_shared_tracking_origin *itrack =
166
+
&ism->itracks[count++];
167
+
memcpy(itrack->name, xtrack->name, sizeof(itrack->name));
168
+
itrack->type = xtrack->type;
169
+
itrack->offset = xtrack->offset;
170
+
}
171
+
172
+
ism->num_itracks = count;
173
+
174
+
count = 0;
175
+
uint32_t input_index = 0;
176
+
uint32_t output_index = 0;
129
177
for (size_t i = 0; i < IPC_SERVER_NUM_XDEVS; i++) {
130
178
struct xrt_device *xdev = s->xdevs[i];
131
179
if (xdev == NULL) {
···
150
198
xdev->hmd->views[1].display.h_pixels;
151
199
ism->hmd.views[1].fov = xdev->hmd->views[1].fov;
152
200
}
201
+
202
+
// Setup the tracking origin.
203
+
idev->tracking_origin_index = (uint32_t)-1;
204
+
for (size_t k = 0; k < IPC_SERVER_NUM_XDEVS; k++) {
205
+
if (xdev->tracking_origin != s->xtracks[i]) {
206
+
continue;
207
+
}
208
+
209
+
idev->tracking_origin_index = i;
210
+
break;
211
+
}
212
+
213
+
assert(idev->tracking_origin_index != (uint32_t)-1);
153
214
154
215
// Initial update.
155
216
xrt_device_update_inputs(xdev);
···
204
265
#endif
205
266
return 0;
206
267
}
268
+
207
269
static int
208
270
create_listen_socket(struct ipc_server *s, int *out_fd)
209
271
{
···
330
392
}
331
393
332
394
if (s->xdevs[0] == NULL) {
395
+
teardown_all(s);
396
+
return -1;
397
+
}
398
+
399
+
ret = init_tracking_origins(s);
400
+
if (ret < 0) {
333
401
teardown_all(s);
334
402
return -1;
335
403
}