From b3a2882b36db009baf473f1a45b4beee929fbb55 Mon Sep 17 00:00:00 2001 From: Jean-Michel Hautbois Date: Thu, 19 Aug 2021 09:03:11 +0200 Subject: ipa: ipu3: Add the functions to the Algorithm class Introduce three functions in the Algorithm class to manage algorithms: - configure which is called when IPA is configured only - prepare called on EventFillParams event at each frame when the request is queued - process called on EventStatReady event at each frame completion when the statistics have been generated. The existing AGC implementation already has a function named process(), though it has different arguments. Adding the new virtual process() interface causes a compiler warning due to the AGC implementation overloading a virtual function, even though the overload can be resolved correctly. Temporarily disable the warning in this commit to maintain bisection until the AGC is converted to the new interface. Signed-off-by: Jean-Michel Hautbois Reviewed-by: Kieran Bingham Reviewed-by: Laurent Pinchart --- meson.build | 4 ++ src/ipa/ipu3/algorithms/algorithm.cpp | 71 +++++++++++++++++++++++++++++++++++ src/ipa/ipu3/algorithms/algorithm.h | 8 ++++ 3 files changed, 83 insertions(+) diff --git a/meson.build b/meson.build index a49c484f..4a10e2b6 100644 --- a/meson.build +++ b/meson.build @@ -108,6 +108,10 @@ if cc.has_argument('-Wno-c99-designator') ] endif +# Do not warn when a function declaration hides virtual functions from +# a base class +cpp_arguments += '-Wno-overloaded-virtual' + c_arguments += common_arguments cpp_arguments += common_arguments diff --git a/src/ipa/ipu3/algorithms/algorithm.cpp b/src/ipa/ipu3/algorithms/algorithm.cpp index dd46846a..3e7e3018 100644 --- a/src/ipa/ipu3/algorithms/algorithm.cpp +++ b/src/ipa/ipu3/algorithms/algorithm.cpp @@ -25,6 +25,77 @@ namespace ipa::ipu3 { * to manage algorithms regardless of their specific type. */ +/** + * \brief Configure the Algorithm given an IPAConfigInfo + * \param[in] context The shared IPA context + * \param[in] configInfo The IPA configuration data, received from the pipeline + * handler + * + * Algorithms may implement a configure operation to pre-calculate + * parameters prior to commencing streaming. + * + * Configuration state may be stored in the IPASessionConfiguration structure of + * the IPAContext. + * + * \return 0 if successful, an error code otherwise + */ +int Algorithm::configure([[maybe_unused]] IPAContext &context, + [[maybe_unused]] const IPAConfigInfo &configInfo) +{ + return 0; +} + +/** + * \brief Fill the \a params buffer with ISP processing parameters for a frame + * \param[in] context The shared IPA context + * \param[out] params The IPU3 specific parameters. + * + * This function is called for every frame when the camera is running before it + * is processed by the ImgU to prepare the ImgU processing parameters for that + * frame. + * + * Algorithms shall fill in the parameter structure fields appropriately to + * configure the ImgU processing blocks that they are responsible for. This + * includes setting fields and flags that enable those processing blocks. + */ +void Algorithm::prepare([[maybe_unused]] IPAContext &context, + [[maybe_unused]] ipu3_uapi_params *params) +{ +} + +/** + * \brief Process ISP statistics, and run algorithm operations + * \param[in] context The shared IPA context + * \param[in] stats The IPU3 statistics and ISP results + * + * This function is called while camera is running for every frame processed by + * the ImgU, to process statistics generated from that frame by the ImgU. + * Algorithms shall use this data to run calculations and update their state + * accordingly. + * + * Processing shall not take an undue amount of time, and any extended or + * computationally expensive calculations or operations must be handled + * asynchronously in a separate thread. + * + * Algorithms can store state in their respective IPAFrameContext structures, + * and reference state from the IPAFrameContext of other algorithms. + * + * \todo Historical data may be required as part of the processing. + * Either the previous frame, or the IPAFrameContext state of the frame + * that generated the statistics for this operation may be required for + * some advanced algorithms to prevent oscillations or support control + * loops correctly. Only a single IPAFrameContext is available currently, + * and so any data stored may represent the results of the previously + * completed operations. + * + * Care shall be taken to ensure the ordering of access to the information + * such that the algorithms use up to date state as required. + */ +void Algorithm::process([[maybe_unused]] IPAContext &context, + [[maybe_unused]] const ipu3_uapi_stats_3a *stats) +{ +} + } /* namespace ipa::ipu3 */ } /* namespace libcamera */ diff --git a/src/ipa/ipu3/algorithms/algorithm.h b/src/ipa/ipu3/algorithms/algorithm.h index 072f01c4..43f5d8b0 100644 --- a/src/ipa/ipu3/algorithms/algorithm.h +++ b/src/ipa/ipu3/algorithms/algorithm.h @@ -7,6 +7,10 @@ #ifndef __LIBCAMERA_IPA_IPU3_ALGORITHM_H__ #define __LIBCAMERA_IPA_IPU3_ALGORITHM_H__ +#include + +#include "ipa_context.h" + namespace libcamera { namespace ipa::ipu3 { @@ -15,6 +19,10 @@ class Algorithm { public: virtual ~Algorithm() {} + + virtual int configure(IPAContext &context, const IPAConfigInfo &configInfo); + virtual void prepare(IPAContext &context, ipu3_uapi_params *params); + virtual void process(IPAContext &context, const ipu3_uapi_stats_3a *stats); }; } /* namespace ipa::ipu3 */ -- cgit v1.2.1