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
|
/* 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::getAlgorithm()
* \brief Find and return the algorithm of requested type
* \tparam AlgoType Algorithm type you want to retrieve
* \return Pointer to the algorithm if found, else nullptr
*/
/**
* \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 */
|
