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
|
/* 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 <stdint.h>
#include <string>
#include <unordered_map>
#include <libcamera/control_ids.h>
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_;
};
};
struct ControlIdentifier {
ControlId id;
const char *name;
ControlType type;
};
class ControlInfo
{
public:
explicit ControlInfo(ControlId id, const ControlValue &min = 0,
const ControlValue &max = 0);
ControlId id() const { return ident_->id; }
const char *name() const { return ident_->name; }
ControlType type() const { return ident_->type; }
const ControlValue &min() const { return min_; }
const ControlValue &max() const { return max_; }
std::string toString() const;
private:
const struct ControlIdentifier *ident_;
ControlValue min_;
ControlValue max_;
};
bool operator==(const ControlInfo &lhs, const ControlInfo &rhs);
bool operator==(const ControlId &lhs, const ControlInfo &rhs);
bool operator==(const ControlInfo &lhs, const ControlId &rhs);
static inline bool operator!=(const ControlInfo &lhs, const ControlInfo &rhs)
{
return !(lhs == rhs);
}
static inline bool operator!=(const ControlId &lhs, const ControlInfo &rhs)
{
return !(lhs == rhs);
}
static inline bool operator!=(const ControlInfo &lhs, const ControlId &rhs)
{
return !(lhs == rhs);
}
using ControlInfoMap = std::unordered_map<ControlId, ControlInfo>;
class ControlList
{
private:
using ControlListMap = std::unordered_map<const ControlInfo *, 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(ControlId id) const;
bool contains(const ControlInfo *info) const;
bool empty() const { return controls_.empty(); }
std::size_t size() const { return controls_.size(); }
void clear() { controls_.clear(); }
ControlValue &operator[](ControlId id);
ControlValue &operator[](const ControlInfo *info) { return controls_[info]; }
void update(const ControlList &list);
private:
Camera *camera_;
ControlListMap controls_;
};
} /* namespace libcamera */
#endif /* __LIBCAMERA_CONTROLS_H__ */
|
