summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--src/ipa/libipa/module.cpp42
-rw-r--r--src/ipa/libipa/module.h71
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 */