[v3,1/2] libcamera: controls: Add array information to ControlId
diff mbox series

Message ID 20240915235044.2188179-2-paul.elder@ideasonboard.com
State New
Headers show
Series
  • Add array information to ControlId
Related show

Commit Message

Paul Elder Sept. 15, 2024, 11:50 p.m. UTC 
Add to ControlId information on whether or not it is an array control,
and the size of the control if it is an array control.

Signed-off-by: Paul Elder <paul.elder@ideasonboard.com>
Reviewed-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
Reviewed-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>

---
Changes in v3:
- rebase on v4 of "libcamera: controls: Add enum information to ControlId"
- fix typo and line wrap

Changes in v2:
- fix documentation
---
 include/libcamera/controls.h | 17 ++++++++++++++++-
 src/libcamera/controls.cpp   | 18 ++++++++++++++++--
 2 files changed, 32 insertions(+), 3 deletions(-)

Patch
diff mbox series 

diff --git a/include/libcamera/controls.h b/include/libcamera/controls.h
index 96a774ccd..25f67ed94 100644
--- a/include/libcamera/controls.h
+++ b/include/libcamera/controls.h
@@ -46,50 +46,60 @@  struct control_type {
 template<>
 struct control_type<void> {
 	static constexpr ControlType value = ControlTypeNone;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<bool> {
 	static constexpr ControlType value = ControlTypeBool;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<uint8_t> {
 	static constexpr ControlType value = ControlTypeByte;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<int32_t> {
 	static constexpr ControlType value = ControlTypeInteger32;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<int64_t> {
 	static constexpr ControlType value = ControlTypeInteger64;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<float> {
 	static constexpr ControlType value = ControlTypeFloat;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<std::string> {
 	static constexpr ControlType value = ControlTypeString;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<Rectangle> {
 	static constexpr ControlType value = ControlTypeRectangle;
+	static constexpr std::size_t size = 0;
 };
 
 template<>
 struct control_type<Size> {
 	static constexpr ControlType value = ControlTypeSize;
+	static constexpr std::size_t size = 0;
 };
 
 template<typename T, std::size_t N>
 struct control_type<Span<T, N>> : public control_type<std::remove_cv_t<T>> {
+	static constexpr std::size_t size = N;
 };
 
 } /* namespace details */
@@ -215,11 +225,14 @@  class ControlId
 {
 public:
 	ControlId(unsigned int id, const std::string &name, ControlType type,
+		  std::size_t size = 0,
 		  const std::map<std::string, int32_t> &enumStrMap = {});
 
 	unsigned int id() const { return id_; }
 	const std::string &name() const { return name_; }
 	ControlType type() const { return type_; }
+	bool isArray() const { return size_ > 0; }
+	std::size_t size() const { return size_; }
 	const std::map<int32_t, std::string> &enumerators() const { return reverseMap_; }
 
 private:
@@ -228,6 +241,7 @@  private:
 	unsigned int id_;
 	std::string name_;
 	ControlType type_;
+	std::size_t size_;
 	std::map<std::string, int32_t> enumStrMap_;
 	std::map<int32_t, std::string> reverseMap_;
 };
@@ -259,7 +273,8 @@  public:
 	using type = T;
 
 	Control(unsigned int id, const char *name, const std::map<std::string, int32_t> &enumStrMap = {})
-		: ControlId(id, name, details::control_type<std::remove_cv_t<T>>::value, enumStrMap)
+		: ControlId(id, name, details::control_type<std::remove_cv_t<T>>::value,
+			    details::control_type<std::remove_cv_t<T>>::size, enumStrMap)
 	{
 	}
 
diff --git a/src/libcamera/controls.cpp b/src/libcamera/controls.cpp
index a46c431a1..ea4397302 100644
--- a/src/libcamera/controls.cpp
+++ b/src/libcamera/controls.cpp
@@ -389,11 +389,12 @@  void ControlValue::reserve(ControlType type, bool isArray, std::size_t numElemen
  * \param[in] id The control numerical ID
  * \param[in] name The control name
  * \param[in] type The control data type
+ * \param[in] size The size of the array control, or 0 if scalar control
  * \param[in] enumStrMap The map from enum names to values (optional)
  */
 ControlId::ControlId(unsigned int id, const std::string &name, ControlType type,
-		     const std::map<std::string, int32_t> &enumStrMap)
-	: id_(id), name_(name), type_(type), enumStrMap_(enumStrMap)
+		     std::size_t size, const std::map<std::string, int32_t> &enumStrMap)
+	: id_(id), name_(name), type_(type), size_(size), enumStrMap_(enumStrMap)
 {
 	for (const auto &pair : enumStrMap_)
 		reverseMap_[pair.second] = pair.first;
@@ -417,6 +418,19 @@  ControlId::ControlId(unsigned int id, const std::string &name, ControlType type,
  * \return The control data type
  */
 
+/**
+ * \fn bool ControlId::isArray() const
+ * \brief Determine if the control is an array control
+ * \return True if the control is an array control, false otherwise
+ */
+
+/**
+ * \fn std::size_t ControlId::size() const
+ * \brief Retrieve the size of the control if it is an array control
+ * \return The size of the array control, size_t::max for dynamic extent, or 0
+ * for non-array
+ */
+
 /**
  * \fn const std::map<int32_t, std::string> &ControlId::enumerators() const
  * \brief Retrieve the map of enum values to enum names