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
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2022, Ideas On Board
*
* module.cpp - IPA Module
*/
#include "module.h"
/**
* \file module.h
* \brief IPA Module common interface
*/
namespace libcamera {
LOG_DEFINE_CATEGORY(IPAModuleAlgo)
/**
* \brief The IPA namespace
*
* The IPA namespace groups all types specific to IPA modules. It serves as the
* top-level namespace for the IPA library libipa, and also contains
* module-specific namespaces for IPA modules.
*/
namespace ipa {
/**
* \class Module
* \brief The base class for all IPA modules
* \tparam Context The type of the shared IPA context
* \tparam FrameContext The type of the frame context
* \tparam Config The type of the IPA configuration data
* \tparam Params The type of the ISP specific parameters
* \tparam Stats The type of the IPA statistics and ISP results
*
* The Module class template defines a standard internal interface between IPA
* modules and libipa.
*
* While IPA modules are platform-specific, many of their internal functions are
* conceptually similar, even if they take different types of platform-specifc
* parameters. For instance, IPA modules could share code that instantiates,
* initializes and run algorithms if it wasn't for the fact that the the format
* of ISP parameters or statistics passed to the related functions is
* device-dependent.
*
* To enable a shared implementation of those common tasks in libipa, the Module
* class template defines a standard internal interface between IPA modules and
* libipa. The template parameters specify the types of module-dependent data.
* IPA modules shall create a specialization of the Module class template in
* their namespace, and use it to specialize other classes of libipa, such as
* the Algorithm class.
*/
/**
* \typedef Module::Context
* \brief The type of the shared IPA context
*/
/**
* \typedef Module::FrameContext
* \brief The type of the frame context
*/
/**
* \typedef Module::Config
* \brief The type of the IPA configuration data
*/
/**
* \typedef Module::Params
* \brief The type of the ISP specific parameters
*/
/**
* \typedef Module::Stats
* \brief The type of the IPA statistics and ISP results
*/
/**
* \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
*
* 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 0 on success, or a negative error code on failure
*/
/**
* \fn Module::registerAlgorithm()
* \brief Add an algorithm factory class to the list of available algorithms
* \param[in] factory Factory to use to construct the algorithm
*
* This function registers an algorithm factory. It is meant to be called by the
* 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 */
|
