matrixfurry.com
The open source OpenXR runtime
st/oxr: Convert session IPC error to XR_ERROR_SESSION_LOST
Co-authored-by: Jakob Bornecrantz <jakob@collabora.com>
authored by
Jarvis Huang
Jakob Bornecrantz
and committed by
Jakob Bornecrantz
95512594
c006ac13
+60
-58
+1
src/xrt/state_trackers/oxr/oxr_api_verify.h
+1
src/xrt/state_trackers/oxr/oxr_api_verify.h
+16
-10
src/xrt/state_trackers/oxr/oxr_session.c
+16
-10
src/xrt/state_trackers/oxr/oxr_session.c
···
40
40
#include "oxr_chain.h"
41
41
#include "oxr_pretty_print.h"
42
42
#include "oxr_conversions.h"
43
+
#include "oxr_xret.h"
43
44
44
45
#include <stdio.h>
45
46
#include <stdlib.h>
···
50
51
DEBUG_GET_ONCE_NUM_OPTION(ipd, "OXR_DEBUG_IPD_MM", 63)
51
52
DEBUG_GET_ONCE_NUM_OPTION(wait_frame_sleep, "OXR_DEBUG_WAIT_FRAME_EXTRA_SLEEP_MS", 0)
52
53
DEBUG_GET_ONCE_BOOL_OPTION(frame_timing_spew, "OXR_FRAME_TIMING_SPEW", false)
53
-
54
-
#define CALL_CHK(call) \
55
-
if ((call) == XRT_ERROR_IPC_FAILURE) { \
56
-
return oxr_error(log, XR_ERROR_INSTANCE_LOST, "Error in function call over IPC"); \
57
-
}
58
54
59
55
static bool
60
56
should_render(XrSessionState state)
···
144
140
view_type);
145
141
}
146
142
147
-
CALL_CHK(xrt_comp_begin_session(xc, (enum xrt_view_type)beginInfo->primaryViewConfigurationType));
143
+
enum xrt_view_type xvt = (enum xrt_view_type)beginInfo->primaryViewConfigurationType;
144
+
xrt_result_t xret = xrt_comp_begin_session(xc, xvt);
145
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_begin_session");
148
146
}
149
147
150
148
sess->has_begun = true;
···
176
174
}
177
175
sess->frame_started = false;
178
176
179
-
CALL_CHK(xrt_comp_end_session(xc));
177
+
xrt_result_t xret = xrt_comp_end_session(xc);
178
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_end_session");
180
179
}
181
180
182
181
oxr_session_change_state(log, sess, XR_SESSION_STATE_IDLE, 0);
···
494
493
495
494
uint64_t predicted_display_time;
496
495
uint64_t predicted_display_period;
497
-
CALL_CHK(xrt_comp_wait_frame(xc, &sess->frame_id.waited, &predicted_display_time, &predicted_display_period));
496
+
xrt_result_t xret = xrt_comp_wait_frame( //
497
+
xc, // compositor
498
+
&sess->frame_id.waited, // out_frame_id
499
+
&predicted_display_time, // out_predicted_display_time
500
+
&predicted_display_period); // out_predicted_display_period
501
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_wait_frame");
498
502
499
503
if ((int64_t)predicted_display_time <= 0) {
500
504
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Got a negative display time '%" PRIi64 "'",
···
551
555
552
556
ret = XR_FRAME_DISCARDED;
553
557
if (xc != NULL) {
554
-
CALL_CHK(xrt_comp_discard_frame(xc, sess->frame_id.begun));
558
+
xrt_result_t xret = xrt_comp_discard_frame(xc, sess->frame_id.begun);
559
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_discard_frame");
555
560
sess->frame_id.begun = -1;
556
561
557
562
os_mutex_lock(&sess->active_wait_frames_lock);
···
563
568
sess->frame_started = true;
564
569
}
565
570
if (xc != NULL) {
566
-
CALL_CHK(xrt_comp_begin_frame(xc, sess->frame_id.waited));
571
+
xrt_result_t xret = xrt_comp_begin_frame(xc, sess->frame_id.waited);
572
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_begin_frame");
567
573
sess->frame_id.begun = sess->frame_id.waited;
568
574
sess->frame_id.waited = -1;
569
575
}
+35
-24
src/xrt/state_trackers/oxr/oxr_session_frame_end.c
+35
-24
src/xrt/state_trackers/oxr/oxr_session_frame_end.c
···
30
30
#include "oxr_chain.h"
31
31
#include "oxr_api_verify.h"
32
32
#include "oxr_chain.h"
33
+
#include "oxr_xret.h"
33
34
34
35
#include <stdio.h>
35
36
#include <stdlib.h>
···
42
43
* Helper functions and defines.
43
44
*
44
45
*/
45
-
46
-
#define CALL_CHK(call) \
47
-
if ((call) == XRT_ERROR_IPC_FAILURE) { \
48
-
return oxr_error(log, XR_ERROR_INSTANCE_LOST, "Error in function call over IPC"); \
49
-
}
50
46
51
47
static double
52
48
ns_to_ms(int64_t ns)
···
936
932
data.quad.size = *size;
937
933
fill_in_sub_image(sc, &quad->subImage, &data.quad.sub);
938
934
939
-
CALL_CHK(xrt_comp_layer_quad(xc, head, sc->swapchain, &data));
935
+
xrt_result_t xret = xrt_comp_layer_quad(xc, head, sc->swapchain, &data);
936
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_quad");
940
937
941
938
return XR_SUCCESS;
942
939
}
···
1027
1024
if (d_scs[0] != NULL && d_scs[1] != NULL) {
1028
1025
#ifdef XRT_FEATURE_OPENXR_LAYER_DEPTH
1029
1026
data.type = XRT_LAYER_STEREO_PROJECTION_DEPTH;
1030
-
CALL_CHK(xrt_comp_layer_stereo_projection_depth(xc, head,
1031
-
scs[0]->swapchain, // Left
1032
-
scs[1]->swapchain, // Right
1033
-
d_scs[0]->swapchain, // Left
1034
-
d_scs[1]->swapchain, // Right
1035
-
&data));
1027
+
xrt_result_t xret = xrt_comp_layer_stereo_projection_depth( //
1028
+
xc, // compositor
1029
+
head, // xdev
1030
+
scs[0]->swapchain, // left
1031
+
scs[1]->swapchain, // right
1032
+
d_scs[0]->swapchain, // left
1033
+
d_scs[1]->swapchain, // right
1034
+
&data); // data
1035
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_stereo_projection_depth");
1036
1036
#else
1037
1037
assert(false && "Should not get here");
1038
1038
#endif // XRT_FEATURE_OPENXR_LAYER_DEPTH
1039
1039
} else {
1040
-
CALL_CHK(xrt_comp_layer_stereo_projection(xc, head,
1041
-
scs[0]->swapchain, // Left
1042
-
scs[1]->swapchain, // Right
1043
-
&data));
1040
+
xrt_result_t xret = xrt_comp_layer_stereo_projection( //
1041
+
xc, // compositor
1042
+
head, // xdev
1043
+
scs[0]->swapchain, // left
1044
+
scs[1]->swapchain, // right
1045
+
&data); // data
1046
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_stereo_projection");
1044
1047
}
1045
1048
1046
1049
return XR_SUCCESS;
···
1090
1093
return XR_SUCCESS;
1091
1094
}
1092
1095
1093
-
CALL_CHK(xrt_comp_layer_cube(xc, head, sc->swapchain, &data));
1096
+
xrt_result_t xret = xrt_comp_layer_cube(xc, head, sc->swapchain, &data);
1097
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_cube");
1094
1098
1095
1099
return XR_SUCCESS;
1096
1100
}
···
1136
1140
data.cylinder.aspect_ratio = cylinder->aspectRatio;
1137
1141
fill_in_sub_image(sc, &cylinder->subImage, &data.cylinder.sub);
1138
1142
1139
-
CALL_CHK(xrt_comp_layer_cylinder(xc, head, sc->swapchain, &data));
1143
+
xrt_result_t xret = xrt_comp_layer_cylinder(xc, head, sc->swapchain, &data);
1144
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_cylinder");
1140
1145
1141
1146
return XR_SUCCESS;
1142
1147
}
···
1185
1190
data.equirect1.scale = *scale;
1186
1191
data.equirect1.bias = *bias;
1187
1192
1188
-
CALL_CHK(xrt_comp_layer_equirect1(xc, head, sc->swapchain, &data));
1193
+
xrt_result_t xret = xrt_comp_layer_equirect1(xc, head, sc->swapchain, &data);
1194
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_equirect1");
1189
1195
1190
1196
return XR_SUCCESS;
1191
1197
}
···
1239
1245
data.equirect2.lower_vertical_angle = equirect->lowerVerticalAngle;
1240
1246
fill_in_sub_image(sc, &equirect->subImage, &data.equirect2.sub);
1241
1247
1242
-
CALL_CHK(xrt_comp_layer_equirect2(xc, head, sc->swapchain, &data));
1248
+
xrt_result_t xret = xrt_comp_layer_equirect2(xc, head, sc->swapchain, &data);
1249
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_equirect2");
1243
1250
1244
1251
return XR_SUCCESS;
1245
1252
}
···
1320
1327
sess->active_wait_frames--;
1321
1328
os_mutex_unlock(&sess->active_wait_frames_lock);
1322
1329
1323
-
CALL_CHK(xrt_comp_discard_frame(xc, sess->frame_id.begun));
1330
+
xrt_result_t xret = xrt_comp_discard_frame(xc, sess->frame_id.begun);
1331
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_discard_frame");
1324
1332
sess->frame_id.begun = -1;
1325
1333
sess->frame_started = false;
1326
1334
···
1394
1402
struct xrt_pose inv_offset = {0};
1395
1403
math_pose_invert(&xdev->tracking_origin->offset, &inv_offset);
1396
1404
1397
-
CALL_CHK(xrt_comp_layer_begin(xc, sess->frame_id.begun, xrt_display_time_ns, blend_mode));
1405
+
xrt_result_t xret;
1406
+
xret = xrt_comp_layer_begin(xc, sess->frame_id.begun, xrt_display_time_ns, blend_mode);
1407
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_begin");
1398
1408
1399
1409
for (uint32_t i = 0; i < frameEndInfo->layerCount; i++) {
1400
1410
const XrCompositionLayerBaseHeader *layer = frameEndInfo->layers[i];
···
1429
1439
}
1430
1440
}
1431
1441
1432
-
CALL_CHK(xrt_comp_layer_commit(xc, sess->frame_id.begun, XRT_GRAPHICS_SYNC_HANDLE_INVALID));
1442
+
xret = xrt_comp_layer_commit(xc, sess->frame_id.begun, XRT_GRAPHICS_SYNC_HANDLE_INVALID);
1443
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_layer_commit");
1444
+
1433
1445
sess->frame_id.begun = -1;
1434
-
1435
1446
sess->frame_started = false;
1436
1447
1437
1448
os_mutex_lock(&sess->active_wait_frames_lock);
+8
-24
src/xrt/state_trackers/oxr/oxr_swapchain.c
+8
-24
src/xrt/state_trackers/oxr/oxr_swapchain.c
···
12
12
#include "util/u_debug.h"
13
13
#include "util/u_misc.h"
14
14
15
+
#include "oxr_xret.h"
15
16
#include "oxr_objects.h"
16
17
#include "oxr_logger.h"
17
18
#include "oxr_handle.h"
···
34
35
35
36
struct xrt_swapchain *xsc = (struct xrt_swapchain *)sc->swapchain;
36
37
37
-
xrt_result_t res = xrt_swapchain_acquire_image(xsc, &index);
38
-
if (res == XRT_ERROR_IPC_FAILURE) {
39
-
return oxr_error(log, XR_ERROR_INSTANCE_LOST, "Call to xrt_swapchain_acquire_image failed");
40
-
}
41
-
if (res != XRT_SUCCESS) {
42
-
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Call to xrt_swapchain_acquire_image failed");
43
-
}
38
+
xrt_result_t xret = xrt_swapchain_acquire_image(xsc, &index);
39
+
OXR_CHECK_XRET(log, sc->sess, xret, "xrt_swapchain_acquire_image");
44
40
45
41
if (sc->images[index].state != OXR_IMAGE_STATE_READY) {
46
42
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE,
···
79
75
80
76
struct xrt_swapchain *xsc = (struct xrt_swapchain *)sc->swapchain;
81
77
82
-
xrt_result_t res = xrt_swapchain_wait_image(xsc, waitInfo->timeout, index);
83
-
if (res == XRT_ERROR_IPC_FAILURE) {
84
-
return oxr_error(log, XR_ERROR_INSTANCE_LOST, "Call to xrt_swapchain_wait_image failed");
85
-
}
86
-
if (res != XRT_SUCCESS) {
87
-
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Call to xrt_swapchain_wait_image failed");
88
-
}
78
+
xrt_result_t xret = xrt_swapchain_wait_image(xsc, waitInfo->timeout, index);
79
+
OXR_CHECK_XRET(log, sc->sess, xret, "xrt_swapchain_wait_image");
89
80
90
81
// The app can only wait on one image.
91
82
sc->waited.yes = true;
···
108
99
uint32_t index = sc->waited.index;
109
100
110
101
struct xrt_swapchain *xsc = (struct xrt_swapchain *)sc->swapchain;
111
-
xrt_result_t res = xrt_swapchain_release_image(xsc, index);
112
-
if (res == XRT_ERROR_IPC_FAILURE) {
113
-
return oxr_error(log, XR_ERROR_INSTANCE_LOST, "Call to xrt_swapchain_release_image failed");
114
-
}
115
-
if (res != XRT_SUCCESS) {
116
-
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Call to xrt_swapchain_release_image failed");
117
-
}
102
+
xrt_result_t xret = xrt_swapchain_release_image(xsc, index);
103
+
OXR_CHECK_XRET(log, sc->sess, xret, "xrt_swapchain_release_image");
118
104
119
105
// Only decerement here.
120
106
sc->acquired.num--;
···
216
202
return oxr_error(log, XR_ERROR_SWAPCHAIN_FORMAT_UNSUPPORTED,
217
203
"Specified swapchain format is not supported");
218
204
}
219
-
if (xret != XRT_SUCCESS) {
220
-
return oxr_error(log, XR_ERROR_RUNTIME_FAILURE, "Failed to create swapchain");
221
-
}
205
+
OXR_CHECK_XRET(log, sess, xret, "xrt_comp_create_swapchain");
222
206
assert(xsc != NULL);
223
207
224
208
struct oxr_swapchain *sc = NULL;