The open source OpenXR runtime
st/oxr: XR_HTC_facial_tracking state-tracker clean-up
Moves the XR_HTC_facial_tracking state-tracker implementation
out of oxr_api_session.c into dedicated files, following
api/monado conventions.
+226
-165
+4
src/xrt/state_trackers/oxr/CMakeLists.txt
+4
src/xrt/state_trackers/oxr/CMakeLists.txt
···
113
113
target_sources(st_oxr PRIVATE oxr_api_body_tracking.c oxr_body_tracking.c)
114
114
endif()
115
115
116
+
if(XRT_FEATURE_OPENXR_FACIAL_TRACKING_HTC)
117
+
target_sources(st_oxr PRIVATE oxr_api_face_tracking.c oxr_face_tracking.c)
118
+
endif()
119
+
116
120
target_link_libraries(
117
121
st_oxr
118
122
PRIVATE
+92
src/xrt/state_trackers/oxr/oxr_api_face_tracking.c
+92
src/xrt/state_trackers/oxr/oxr_api_face_tracking.c
···
1
+
// Copyright 2024, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
/*!
4
+
* @file
5
+
* @brief face tracking related API entrypoint functions.
6
+
* @author Korcan Hussein <korcan.hussein@collabora.com>
7
+
* @ingroup oxr_api
8
+
*/
9
+
10
+
#include <stdio.h>
11
+
#include <stdlib.h>
12
+
#include <string.h>
13
+
#include <inttypes.h>
14
+
15
+
#include "util/u_trace_marker.h"
16
+
17
+
#include "oxr_objects.h"
18
+
#include "oxr_logger.h"
19
+
20
+
#include "oxr_api_funcs.h"
21
+
#include "oxr_api_verify.h"
22
+
#include "oxr_handle.h"
23
+
24
+
XRAPI_ATTR XrResult XRAPI_CALL
25
+
oxr_xrCreateFacialTrackerHTC(XrSession session,
26
+
const XrFacialTrackerCreateInfoHTC *createInfo,
27
+
XrFacialTrackerHTC *facialTracker)
28
+
{
29
+
OXR_TRACE_MARKER();
30
+
31
+
struct oxr_logger log;
32
+
XrResult ret = XR_SUCCESS;
33
+
struct oxr_session *sess = NULL;
34
+
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
35
+
OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrCreateFacialTrackerHTC");
36
+
OXR_VERIFY_SESSION_NOT_LOST(&log, sess);
37
+
OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, createInfo, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC);
38
+
OXR_VERIFY_EXTENSION(&log, sess->sys->inst, HTC_facial_tracking);
39
+
40
+
ret = oxr_facial_tracker_htc_create(&log, sess, createInfo, &facial_tracker_htc);
41
+
if (ret != XR_SUCCESS) {
42
+
return ret;
43
+
}
44
+
45
+
OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc);
46
+
*facialTracker = oxr_facial_tracker_htc_to_openxr(facial_tracker_htc);
47
+
48
+
return XR_SUCCESS;
49
+
}
50
+
51
+
XRAPI_ATTR XrResult XRAPI_CALL
52
+
oxr_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker)
53
+
{
54
+
OXR_TRACE_MARKER();
55
+
56
+
struct oxr_logger log;
57
+
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
58
+
OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialTracker, facial_tracker_htc, "xrDestroyFacialTrackerHTC");
59
+
60
+
return oxr_handle_destroy(&log, &facial_tracker_htc->handle);
61
+
}
62
+
63
+
XRAPI_ATTR XrResult XRAPI_CALL
64
+
oxr_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions)
65
+
{
66
+
OXR_TRACE_MARKER();
67
+
68
+
struct oxr_logger log;
69
+
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
70
+
OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialExpressions, facial_tracker_htc,
71
+
"xrGetFacialExpressionsHTC");
72
+
OXR_VERIFY_SESSION_NOT_LOST(&log, facial_tracker_htc->sess);
73
+
OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc->xdev);
74
+
OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, facialExpressions, XR_TYPE_FACIAL_EXPRESSIONS_HTC);
75
+
OXR_VERIFY_ARG_NOT_NULL(&log, facialExpressions->expressionWeightings);
76
+
77
+
#define OXR_VERIFY_FACE_EXPRESSION_COUNT(fttype) \
78
+
if (facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_##fttype##_DEFAULT_HTC && \
79
+
facialExpressions->expressionCount < XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC) { \
80
+
return oxr_error( \
81
+
&log, XR_ERROR_SIZE_INSUFFICIENT, \
82
+
"\"expressionCount\" (%d) size is less than the minimum size (%d) required for " #fttype \
83
+
" expressions.\n", \
84
+
facialExpressions->expressionCount, XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC); \
85
+
}
86
+
87
+
OXR_VERIFY_FACE_EXPRESSION_COUNT(EYE)
88
+
OXR_VERIFY_FACE_EXPRESSION_COUNT(LIP)
89
+
#undef OXR_VERIFY_FACE_EXPRESSION_COUNT
90
+
91
+
return oxr_get_facial_expressions_htc(&log, facial_tracker_htc, facialExpressions);
92
+
}
-165
src/xrt/state_trackers/oxr/oxr_api_session.c
-165
src/xrt/state_trackers/oxr/oxr_api_session.c
···
679
679
}
680
680
681
681
#endif
682
-
683
-
#ifdef OXR_HAVE_HTC_facial_tracking
684
-
685
-
static enum xrt_facial_tracking_type_htc
686
-
oxr_to_xrt_facial_tracking_type_htc(enum XrFacialTrackingTypeHTC ft_type)
687
-
{
688
-
return (enum xrt_facial_tracking_type_htc)ft_type;
689
-
}
690
-
691
-
static enum xrt_input_name
692
-
oxr_facial_tracking_type_htc_to_input_name(enum xrt_facial_tracking_type_htc ft_type)
693
-
{
694
-
switch (ft_type) {
695
-
case XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC: return XRT_INPUT_HTC_LIP_FACE_TRACKING;
696
-
case XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC:
697
-
default: return XRT_INPUT_HTC_EYE_FACE_TRACKING;
698
-
}
699
-
}
700
-
701
-
static XrResult
702
-
oxr_facial_tracker_htc_destroy_cb(struct oxr_logger *log, struct oxr_handle_base *hb)
703
-
{
704
-
struct oxr_facial_tracker_htc *face_tracker_htc = (struct oxr_facial_tracker_htc *)hb;
705
-
free(face_tracker_htc);
706
-
return XR_SUCCESS;
707
-
}
708
-
709
-
XrResult
710
-
oxr_facial_tracker_htc_create(struct oxr_logger *log,
711
-
struct oxr_session *sess,
712
-
const XrFacialTrackerCreateInfoHTC *createInfo,
713
-
struct oxr_facial_tracker_htc **out_face_tracker_htc)
714
-
{
715
-
bool supports_eye = false;
716
-
bool supports_lip = false;
717
-
oxr_system_get_face_tracking_htc_support(log, sess->sys->inst, &supports_eye, &supports_lip);
718
-
719
-
const enum xrt_facial_tracking_type_htc facial_tracking_type =
720
-
oxr_to_xrt_facial_tracking_type_htc(createInfo->facialTrackingType);
721
-
722
-
if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC && !supports_eye) {
723
-
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC eye facial tracking");
724
-
}
725
-
if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC && !supports_lip) {
726
-
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC lip facial tracking");
727
-
}
728
-
729
-
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, face);
730
-
if (xdev == NULL) {
731
-
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for face tracking role");
732
-
}
733
-
734
-
if (!xdev->face_tracking_supported) {
735
-
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "Device does not support HTC facial tracking");
736
-
}
737
-
738
-
struct oxr_facial_tracker_htc *face_tracker_htc = NULL;
739
-
OXR_ALLOCATE_HANDLE_OR_RETURN(log, face_tracker_htc, OXR_XR_DEBUG_FTRACKER, oxr_facial_tracker_htc_destroy_cb,
740
-
&sess->handle);
741
-
742
-
face_tracker_htc->sess = sess;
743
-
face_tracker_htc->xdev = xdev;
744
-
face_tracker_htc->facial_tracking_type = facial_tracking_type;
745
-
746
-
*out_face_tracker_htc = face_tracker_htc;
747
-
748
-
return XR_SUCCESS;
749
-
}
750
-
751
-
XRAPI_ATTR XrResult XRAPI_CALL
752
-
oxr_xrCreateFacialTrackerHTC(XrSession session,
753
-
const XrFacialTrackerCreateInfoHTC *createInfo,
754
-
XrFacialTrackerHTC *facialTracker)
755
-
{
756
-
OXR_TRACE_MARKER();
757
-
758
-
struct oxr_logger log;
759
-
XrResult ret = XR_SUCCESS;
760
-
struct oxr_session *sess = NULL;
761
-
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
762
-
OXR_VERIFY_SESSION_AND_INIT_LOG(&log, session, sess, "xrCreateFacialTrackerHTC");
763
-
OXR_VERIFY_SESSION_NOT_LOST(&log, sess);
764
-
OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, createInfo, XR_TYPE_FACIAL_TRACKER_CREATE_INFO_HTC);
765
-
OXR_VERIFY_EXTENSION(&log, sess->sys->inst, HTC_facial_tracking);
766
-
767
-
ret = oxr_facial_tracker_htc_create(&log, sess, createInfo, &facial_tracker_htc);
768
-
if (ret != XR_SUCCESS) {
769
-
return ret;
770
-
}
771
-
772
-
OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc);
773
-
*facialTracker = oxr_facial_tracker_htc_to_openxr(facial_tracker_htc);
774
-
775
-
return XR_SUCCESS;
776
-
}
777
-
778
-
XRAPI_ATTR XrResult XRAPI_CALL
779
-
oxr_xrDestroyFacialTrackerHTC(XrFacialTrackerHTC facialTracker)
780
-
{
781
-
OXR_TRACE_MARKER();
782
-
783
-
struct oxr_logger log;
784
-
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
785
-
OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialTracker, facial_tracker_htc, "xrDestroyFacialTrackerHTC");
786
-
787
-
return oxr_handle_destroy(&log, &facial_tracker_htc->handle);
788
-
}
789
-
790
-
XRAPI_ATTR XrResult XRAPI_CALL
791
-
oxr_xrGetFacialExpressionsHTC(XrFacialTrackerHTC facialTracker, XrFacialExpressionsHTC *facialExpressions)
792
-
{
793
-
OXR_TRACE_MARKER();
794
-
795
-
struct oxr_logger log;
796
-
struct oxr_facial_tracker_htc *facial_tracker_htc = NULL;
797
-
OXR_VERIFY_FACE_TRACKER_HTC_AND_INIT_LOG(&log, facialExpressions, facial_tracker_htc,
798
-
"xrGetFacialExpressionsHTC");
799
-
OXR_VERIFY_SESSION_NOT_LOST(&log, facial_tracker_htc->sess);
800
-
OXR_VERIFY_ARG_NOT_NULL(&log, facial_tracker_htc->xdev);
801
-
OXR_VERIFY_ARG_TYPE_AND_NOT_NULL(&log, facialExpressions, XR_TYPE_FACIAL_EXPRESSIONS_HTC);
802
-
OXR_VERIFY_ARG_NOT_NULL(&log, facialExpressions->expressionWeightings);
803
-
804
-
#define OXR_VERIFY_FACE_EXPRESSION_COUNT(fttype) \
805
-
if (facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_##fttype##_DEFAULT_HTC && \
806
-
facialExpressions->expressionCount < XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC) { \
807
-
return oxr_error( \
808
-
&log, XR_ERROR_SIZE_INSUFFICIENT, \
809
-
"\"expressionCount\" (%d) size is less than the minimum size (%d) required for " #fttype \
810
-
" expressions.\n", \
811
-
facialExpressions->expressionCount, XRT_FACIAL_EXPRESSION_##fttype##_COUNT_HTC); \
812
-
}
813
-
814
-
OXR_VERIFY_FACE_EXPRESSION_COUNT(EYE)
815
-
OXR_VERIFY_FACE_EXPRESSION_COUNT(LIP)
816
-
#undef OXR_VERIFY_FACE_EXPRESSION_COUNT
817
-
818
-
const bool is_eye_tracking =
819
-
facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC;
820
-
const size_t expression_count =
821
-
is_eye_tracking ? XRT_FACIAL_EXPRESSION_EYE_COUNT_HTC : XRT_FACIAL_EXPRESSION_LIP_COUNT_HTC;
822
-
823
-
struct xrt_facial_expression_set facial_expression_set_result = {0};
824
-
float *expression_weights = is_eye_tracking
825
-
? facial_expression_set_result.eye_expression_set_htc.expression_weights
826
-
: facial_expression_set_result.lip_expression_set_htc.expression_weights;
827
-
memset(expression_weights, 0, sizeof(float) * expression_count);
828
-
829
-
const enum xrt_input_name ft_input_name =
830
-
oxr_facial_tracking_type_htc_to_input_name(facial_tracker_htc->facial_tracking_type);
831
-
832
-
xrt_device_get_face_tracking(facial_tracker_htc->xdev, ft_input_name, &facial_expression_set_result);
833
-
834
-
facialExpressions->isActive = facial_expression_set_result.base_expression_set_htc.is_active;
835
-
if (facialExpressions->isActive == XR_FALSE)
836
-
return XR_SUCCESS;
837
-
838
-
const struct oxr_instance *inst = facial_tracker_htc->sess->sys->inst;
839
-
facialExpressions->sampleTime = time_state_monotonic_to_ts_ns(
840
-
inst->timekeeping, facial_expression_set_result.base_expression_set_htc.sample_time_ns);
841
-
842
-
memcpy(facialExpressions->expressionWeightings, expression_weights, sizeof(float) * expression_count);
843
-
844
-
return XR_SUCCESS;
845
-
}
846
-
#endif
+117
src/xrt/state_trackers/oxr/oxr_face_tracking.c
+117
src/xrt/state_trackers/oxr/oxr_face_tracking.c
···
1
+
// Copyright 2024, Collabora, Ltd.
2
+
// SPDX-License-Identifier: BSL-1.0
3
+
/*!
4
+
* @file
5
+
* @brief face tracking related API entrypoint functions.
6
+
* @author Korcan Hussein <korcan.hussein@collabora.com>
7
+
* @ingroup oxr_main
8
+
*/
9
+
10
+
#include <stdio.h>
11
+
#include <stdlib.h>
12
+
#include <string.h>
13
+
#include <inttypes.h>
14
+
15
+
#include "oxr_objects.h"
16
+
#include "oxr_logger.h"
17
+
#include "oxr_handle.h"
18
+
19
+
static enum xrt_facial_tracking_type_htc
20
+
oxr_to_xrt_facial_tracking_type_htc(enum XrFacialTrackingTypeHTC ft_type)
21
+
{
22
+
return (enum xrt_facial_tracking_type_htc)ft_type;
23
+
}
24
+
25
+
static enum xrt_input_name
26
+
oxr_facial_tracking_type_htc_to_input_name(enum xrt_facial_tracking_type_htc ft_type)
27
+
{
28
+
switch (ft_type) {
29
+
case XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC: return XRT_INPUT_HTC_LIP_FACE_TRACKING;
30
+
case XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC:
31
+
default: return XRT_INPUT_HTC_EYE_FACE_TRACKING;
32
+
}
33
+
}
34
+
35
+
static XrResult
36
+
oxr_facial_tracker_htc_destroy_cb(struct oxr_logger *log, struct oxr_handle_base *hb)
37
+
{
38
+
struct oxr_facial_tracker_htc *face_tracker_htc = (struct oxr_facial_tracker_htc *)hb;
39
+
free(face_tracker_htc);
40
+
return XR_SUCCESS;
41
+
}
42
+
43
+
XrResult
44
+
oxr_facial_tracker_htc_create(struct oxr_logger *log,
45
+
struct oxr_session *sess,
46
+
const XrFacialTrackerCreateInfoHTC *createInfo,
47
+
struct oxr_facial_tracker_htc **out_face_tracker_htc)
48
+
{
49
+
bool supports_eye = false;
50
+
bool supports_lip = false;
51
+
oxr_system_get_face_tracking_htc_support(log, sess->sys->inst, &supports_eye, &supports_lip);
52
+
53
+
const enum xrt_facial_tracking_type_htc facial_tracking_type =
54
+
oxr_to_xrt_facial_tracking_type_htc(createInfo->facialTrackingType);
55
+
56
+
if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC && !supports_eye) {
57
+
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC eye facial tracking");
58
+
}
59
+
if (facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_LIP_DEFAULT_HTC && !supports_lip) {
60
+
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "System does not support HTC lip facial tracking");
61
+
}
62
+
63
+
struct xrt_device *xdev = GET_XDEV_BY_ROLE(sess->sys, face);
64
+
if (xdev == NULL) {
65
+
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "No device found for face tracking role");
66
+
}
67
+
68
+
if (!xdev->face_tracking_supported) {
69
+
return oxr_error(log, XR_ERROR_FEATURE_UNSUPPORTED, "Device does not support HTC facial tracking");
70
+
}
71
+
72
+
struct oxr_facial_tracker_htc *face_tracker_htc = NULL;
73
+
OXR_ALLOCATE_HANDLE_OR_RETURN(log, face_tracker_htc, OXR_XR_DEBUG_FTRACKER, oxr_facial_tracker_htc_destroy_cb,
74
+
&sess->handle);
75
+
76
+
face_tracker_htc->sess = sess;
77
+
face_tracker_htc->xdev = xdev;
78
+
face_tracker_htc->facial_tracking_type = facial_tracking_type;
79
+
80
+
*out_face_tracker_htc = face_tracker_htc;
81
+
82
+
return XR_SUCCESS;
83
+
}
84
+
85
+
XrResult
86
+
oxr_get_facial_expressions_htc(struct oxr_logger *log,
87
+
struct oxr_facial_tracker_htc *facial_tracker_htc,
88
+
XrFacialExpressionsHTC *facialExpressions)
89
+
{
90
+
const bool is_eye_tracking =
91
+
facial_tracker_htc->facial_tracking_type == XRT_FACIAL_TRACKING_TYPE_EYE_DEFAULT_HTC;
92
+
const size_t expression_count =
93
+
is_eye_tracking ? XRT_FACIAL_EXPRESSION_EYE_COUNT_HTC : XRT_FACIAL_EXPRESSION_LIP_COUNT_HTC;
94
+
95
+
struct xrt_facial_expression_set facial_expression_set_result = {0};
96
+
float *expression_weights = is_eye_tracking
97
+
? facial_expression_set_result.eye_expression_set_htc.expression_weights
98
+
: facial_expression_set_result.lip_expression_set_htc.expression_weights;
99
+
memset(expression_weights, 0, sizeof(float) * expression_count);
100
+
101
+
const enum xrt_input_name ft_input_name =
102
+
oxr_facial_tracking_type_htc_to_input_name(facial_tracker_htc->facial_tracking_type);
103
+
104
+
xrt_device_get_face_tracking(facial_tracker_htc->xdev, ft_input_name, &facial_expression_set_result);
105
+
106
+
facialExpressions->isActive = facial_expression_set_result.base_expression_set_htc.is_active;
107
+
if (facialExpressions->isActive == XR_FALSE)
108
+
return XR_SUCCESS;
109
+
110
+
const struct oxr_instance *inst = facial_tracker_htc->sess->sys->inst;
111
+
facialExpressions->sampleTime = time_state_monotonic_to_ts_ns(
112
+
inst->timekeeping, facial_expression_set_result.base_expression_set_htc.sample_time_ns);
113
+
114
+
memcpy(facialExpressions->expressionWeightings, expression_weights, sizeof(float) * expression_count);
115
+
116
+
return XR_SUCCESS;
117
+
}
+13
src/xrt/state_trackers/oxr/oxr_objects.h
+13
src/xrt/state_trackers/oxr/oxr_objects.h
···
2667
2667
2668
2668
#endif // OXR_HAVE_FB_passthrough
2669
2669
2670
+
#ifdef OXR_HAVE_HTC_facial_tracking
2670
2671
/*!
2671
2672
* HTC specific Facial tracker.
2672
2673
*
···
2690
2691
//! Type of facial tracking, eyes or lips
2691
2692
enum xrt_facial_tracking_type_htc facial_tracking_type;
2692
2693
};
2694
+
2695
+
XrResult
2696
+
oxr_facial_tracker_htc_create(struct oxr_logger *log,
2697
+
struct oxr_session *sess,
2698
+
const XrFacialTrackerCreateInfoHTC *createInfo,
2699
+
struct oxr_facial_tracker_htc **out_face_tracker_htc);
2700
+
2701
+
XrResult
2702
+
oxr_get_facial_expressions_htc(struct oxr_logger *log,
2703
+
struct oxr_facial_tracker_htc *facial_tracker_htc,
2704
+
XrFacialExpressionsHTC *facialExpressions);
2705
+
#endif
2693
2706
2694
2707
#ifdef OXR_HAVE_FB_body_tracking
2695
2708
/*!