ipa: libipa: module: Add support for instantiation from YAML

Add a Module::createAlgorithms() function to instantiate algorithms from
a YamlObject. The instantiated algorithms are stored in a private member
variable list, exposed through the Module::algorithms() function.

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

2 files changed, 98 insertions, 15 deletions

diff --git a/src/ipa/libipa/module.cpp b/src/ipa/libipa/module.cpp
index 451614fd..77352104 100644
--- a/src/ipa/libipa/module.cpp
+++ b/src/ipa/libipa/module.cpp
@@ -14,6 +14,8 @@
 
 namespace libcamera {
 
+LOG_DEFINE_CATEGORY(IPAModuleAlgo)
+
 /**
  * \brief The IPA namespace
  *
@@ -76,18 +78,23 @@ namespace ipa {
  */
 
 /**
- * \fn Module::createAlgorithm()
- * \brief Create an instance of an Algorithm by name
- * \param[in] name The algorithm name
- *
- * This function is the entry point to algorithm instantiation for the IPA
- * module. It creates and returns an instance of an algorithm identified by its
- * \a name. If no such algorithm exists, the function returns nullptr.
+ * \fn Module::algorithms()
+ * \brief Retrieve the list of instantiated algorithms
+ * \return The list of instantiated algorithms
+ */
+
+/**
+ * \fn Module::createAlgorithms()
+ * \brief Create algorithms from YAML configuration data
+ * \param[in] context The IPA context
+ * \param[in] algorithms Algorithms configuration data as a parsed YamlObject
  *
- * To make an algorithm available to the IPA module, it shall be registered with
- * the REGISTER_IPA_ALGORITHM() macro.
+ * This function iterates over the list of \a algorithms parsed from the YAML
+ * configuration file, and instantiates and initializes the corresponding
+ * algorithms. The configuration data is expected to be correct, any error
+ * causes the function to fail and return immediately.
  *
- * \return A new instance of the Algorithm subclass corresponding to the \a name
+ * \return 0 on success, or a negative error code on failure
  */
 
 /**
@@ -99,6 +106,21 @@ namespace ipa {
  * AlgorithmFactory constructor only.
  */
 
+/**
+ * \fn Module::createAlgorithm(const std::string &name)
+ * \brief Create an instance of an Algorithm by name
+ * \param[in] name The algorithm name
+ *
+ * This function is the entry point to algorithm instantiation for the IPA
+ * module. It creates and returns an instance of an algorithm identified by its
+ * \a name. If no such algorithm exists, the function returns nullptr.
+ *
+ * To make an algorithm available to the IPA module, it shall be registered with
+ * the REGISTER_IPA_ALGORITHM() macro.
+ *
+ * \return A new instance of the Algorithm subclass corresponding to the \a name
+ */
+
 } /* namespace ipa */
 
 } /* namespace libcamera */
diff --git a/src/ipa/libipa/module.h b/src/ipa/libipa/module.h
index 05f39801..addae067 100644
--- a/src/ipa/libipa/module.h
+++ b/src/ipa/libipa/module.h
@@ -7,14 +7,22 @@
 
 #pragma once
 
+#include <list>
 #include <memory>
 #include <string>
 #include <vector>
 
+#include <libcamera/base/log.h>
+#include <libcamera/base/utils.h>
+
+#include "libcamera/internal/yaml_parser.h"
+
 #include "algorithm.h"
 
 namespace libcamera {
 
+LOG_DECLARE_CATEGORY(IPAModuleAlgo)
+
 namespace ipa {
 
 template<typename _Context, typename _FrameContext, typename _Config,
@@ -30,14 +38,31 @@ public:
 
 	virtual ~Module() {}
 
-	static std::unique_ptr<Algorithm<Module>> createAlgorithm(const std::string &name)
+	const std::list<std::unique_ptr<Algorithm<Module>>> &algorithms() const
 	{
-		for (const AlgorithmFactoryBase<Module> *factory : factories()) {
-			if (factory->name() == name)
-				return factory->create();
+		return algorithms_;
+	}
+
+	int createAlgorithms(Context &context, const YamlObject &algorithms)
+	{
+		const auto &list = algorithms.asList();
+
+		for (const auto &[i, algo] : utils::enumerate(list)) {
+			if (!algo.isDictionary()) {
+				LOG(IPAModuleAlgo, Error)
+					<< "Invalid YAML syntax for algorithm " << i;
+				algorithms_.clear();
+				return -EINVAL;
+			}
+
+			int ret = createAlgorithm(context, algo);
+			if (ret) {
+				algorithms_.clear();
+				return ret;
+			}
 		}
 
-		return nullptr;
+		return 0;
 	}
 
 	static void registerAlgorithm(AlgorithmFactoryBase<Module> *factory)
@@ -46,6 +71,40 @@ public:
 	}
 
 private:
+	int createAlgorithm(Context &context, const YamlObject &data)
+	{
+		const auto &[name, algoData] = *data.asDict().begin();
+		std::unique_ptr<Algorithm<Module>> algo = createAlgorithm(name);
+		if (!algo) {
+			LOG(IPAModuleAlgo, Error)
+				<< "Algorithm '" << name << "' not found";
+			return -EINVAL;
+		}
+
+		int ret = algo->init(context, algoData);
+		if (ret) {
+			LOG(IPAModuleAlgo, Error)
+				<< "Algorithm '" << name << "' failed to initialize";
+			return ret;
+		}
+
+		LOG(IPAModuleAlgo, Debug)
+			<< "Instantiated algorithm '" << name << "'";
+
+		algorithms_.push_back(std::move(algo));
+		return 0;
+	}
+
+	static std::unique_ptr<Algorithm<Module>> createAlgorithm(const std::string &name)
+	{
+		for (const AlgorithmFactoryBase<Module> *factory : factories()) {
+			if (factory->name() == name)
+				return factory->create();
+		}
+
+		return nullptr;
+	}
+
 	static std::vector<AlgorithmFactoryBase<Module> *> &factories()
 	{
 		/*
@@ -56,6 +115,8 @@ private:
 		static std::vector<AlgorithmFactoryBase<Module> *> factories;
 		return factories;
 	}
+
+	std::list<std::unique_ptr<Algorithm<Module>>> algorithms_;
 };
 
 } /* namespace ipa */