orbbec-sdk-sys 0.1.2+2.5.5

Low-level Rust bindings for https://github.com/orbbec/OrbbecSDK_v2
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#pragma once

#include "IProperty.hpp"
#include "IDevice.hpp"

#include <mutex>
#include <functional>

namespace libobsensor {
class DeviceComponentPropertyAccessor : public IBasicPropertyAccessor {
public:
    DeviceComponentPropertyAccessor(IDevice *device, DeviceComponentId compId);
    virtual ~DeviceComponentPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

private:
    IDevice          *device_;
    DeviceComponentId compId_;
};

class FunctionPropertyAccessor : public IBasicPropertyAccessor {
public:
    FunctionPropertyAccessor(std::function<OBPropertyValue(uint32_t)> getter, std::function<void(uint32_t, OBPropertyValue)> setter,
                             std::function<OBPropertyRange(uint32_t)> rangeGetter);

    virtual ~FunctionPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

private:
    std::function<OBPropertyValue(uint32_t)>       getter_;
    std::function<void(uint32_t, OBPropertyValue)> setter_;
    std::function<OBPropertyRange(uint32_t)>       rangeGetter_;
};

class LazyPropertyAccessor : public virtual IBasicPropertyAccessor {
public:
    LazyPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator);

    virtual ~LazyPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

protected:
    std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator_;
    std::shared_ptr<IPropertyAccessor>                  accessor_;
    std::mutex                                          mutex_;
};

class LazySuperPropertyAccessor : public LazyPropertyAccessor, public IStructureDataAccessor, public IStructureDataAccessorV1_1, public IRawDataAccessor {
public:
    LazySuperPropertyAccessor(std::function<std::shared_ptr<IPropertyAccessor>()> accessorCreator);
    virtual ~LazySuperPropertyAccessor() noexcept override = default;

    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;
    void                        getRawData(uint32_t propertyId, GetDataCallback callback) override;

    uint16_t                    getCmdVersionProtoV1_1(uint32_t propertyId) override;
    const std::vector<uint8_t> &getStructureDataProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
    void                        setStructureDataProtoV1_1(uint32_t propertyId, const std::vector<uint8_t> &data, uint16_t cmdVersion) override;
    const std::vector<uint8_t> &getStructureDataListProtoV1_1(uint32_t propertyId, uint16_t cmdVersion) override;
};

class StructureDataOverV1_1Accessor : public IStructureDataAccessor {
public:
    StructureDataOverV1_1Accessor(std::shared_ptr<IStructureDataAccessorV1_1> structureDataV1_1Accessor, uint16_t cmdVersion);

    virtual ~StructureDataOverV1_1Accessor() noexcept override = default;

    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;

private:
    std::shared_ptr<IStructureDataAccessorV1_1> structureDataV1_1Accessor_;
    uint16_t                                    cmdVersion_;
};

class HeartbeatPropertyAccessor : public IBasicPropertyAccessor {
public:
    HeartbeatPropertyAccessor(IDevice *owner);

    virtual ~HeartbeatPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

private:
    IDevice *owner_;
};

class BaselinePropertyAccessor : public IStructureDataAccessor {
public:
    BaselinePropertyAccessor(IDevice *owner);

    virtual ~BaselinePropertyAccessor() noexcept override = default;

    void                        setStructureData(uint32_t propertyId, const std::vector<uint8_t> &data) override;
    const std::vector<uint8_t> &getStructureData(uint32_t propertyId) override;

private:
    IDevice             *owner_;
    std::vector<uint8_t> baselineData_;
};

class StereoFrameTransformPropertyAccessor : public IBasicPropertyAccessor {
public:
    StereoFrameTransformPropertyAccessor(IDevice *owner);
    virtual ~StereoFrameTransformPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

private:
    IDevice *owner_;
};

class MonocularFrameTransformPropertyAccessor : public IBasicPropertyAccessor {
public:
    MonocularFrameTransformPropertyAccessor(IDevice *owner);
    virtual ~MonocularFrameTransformPropertyAccessor() noexcept override = default;

    void setPropertyValue(uint32_t propertyId, const OBPropertyValue &value) override;
    void getPropertyValue(uint32_t propertyId, OBPropertyValue *value) override;
    void getPropertyRange(uint32_t propertyId, OBPropertyRange *range) override;

private:
    IDevice *owner_;
};

}  // namespace libobsensor