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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* controls.h - Control handling
*/
#ifndef __LIBCAMERA_CONTROLS_H__
#define __LIBCAMERA_CONTROLS_H__
#include <string>
#include <unordered_map>
namespace libcamera {
class Camera;
enum ControlType {
ControlTypeNone,
ControlTypeBool,
ControlTypeInteger32,
ControlTypeInteger64,
};
class ControlValue
{
public:
ControlValue();
ControlValue(bool value);
ControlValue(int32_t value);
ControlValue(int64_t value);
ControlType type() const { return type_; };
bool isNone() const { return type_ == ControlTypeNone; };
template<typename T>
const T &get() const;
template<typename T>
void set(const T &value);
std::string toString() const;
private:
ControlType type_;
union {
bool bool_;
int32_t integer32_;
int64_t integer64_;
};
};
class ControlId
{
public:
unsigned int id() const { return id_; }
const char *name() const { return name_; }
ControlType type() const { return type_; }
protected:
ControlId(unsigned int id, const char *name, ControlType type)
: id_(id), name_(name), type_(type)
{
}
private:
ControlId(const ControlId &) = delete;
ControlId &operator=(const ControlId &) = delete;
unsigned int id_;
const char *name_;
ControlType type_;
};
static inline bool operator==(const ControlId &lhs, const ControlId &rhs)
{
return lhs.id() == rhs.id();
}
static inline bool operator!=(const ControlId &lhs, const ControlId &rhs)
{
return !(lhs == rhs);
}
template<typename T>
class Control : public ControlId
{
public:
using type = T;
Control(unsigned int id, const char *name);
private:
Control(const Control &) = delete;
Control &operator=(const Control &) = delete;
};
class ControlRange
{
public:
explicit ControlRange(const ControlValue &min = 0,
const ControlValue &max = 0);
const ControlValue &min() const { return min_; }
const ControlValue &max() const { return max_; }
std::string toString() const;
private:
ControlValue min_;
ControlValue max_;
};
using ControlInfoMap = std::unordered_map<const ControlId *, ControlRange>;
class ControlList
{
private:
using ControlListMap = std::unordered_map<const ControlId *, ControlValue>;
public:
ControlList(Camera *camera);
using iterator = ControlListMap::iterator;
using const_iterator = ControlListMap::const_iterator;
iterator begin() { return controls_.begin(); }
iterator end() { return controls_.end(); }
const_iterator begin() const { return controls_.begin(); }
const_iterator end() const { return controls_.end(); }
bool contains(const ControlId &id) const;
bool empty() const { return controls_.empty(); }
std::size_t size() const { return controls_.size(); }
void clear() { controls_.clear(); }
template<typename T>
const T &get(const Control<T> &ctrl) const
{
const ControlValue *val = find(ctrl);
if (!val) {
static T t(0);
return t;
}
return val->get<T>();
}
template<typename T>
void set(const Control<T> &ctrl, const T &value)
{
ControlValue *val = find(ctrl);
if (!val)
return;
val->set<T>(value);
}
private:
const ControlValue *find(const ControlId &id) const;
ControlValue *find(const ControlId &id);
Camera *camera_;
ControlListMap controls_;
};
} /* namespace libcamera */
#endif /* __LIBCAMERA_CONTROLS_H__ */
|
