[PATCH v2 4/8] ipa: libipa: Add MeanLuminanceAgc base class
Paul Elder
paul.elder at ideasonboard.com
Fri Apr 19 06:51:06 CEST 2024
It just occurred to me that the commit message still says
MeanLuminanceAgc instead of AgcMeanLuminance.
Paul
On Thu, Apr 18, 2024 at 09:49:34PM +0900, Paul Elder wrote:
> Hi Dan,
>
> On Wed, Apr 17, 2024 at 02:15:32PM +0100, Daniel Scally wrote:
> > The Agc algorithms for the RkIsp1 and IPU3 IPAs do the same thing in
> > very large part; following the Rpi IPA's algorithm in spirit with a
> > few tunable values in that IPA being hardcoded in the libipa ones.
> > Add a new base class for MeanLuminanceAgc which implements the same
> > algorithm and additionally parses yaml tuning files to inform an IPA
> > module's Agc algorithm about valid constraint and exposure modes and
> > their associated bounds.
> >
> > Signed-off-by: Daniel Scally <dan.scally at ideasonboard.com>
> > ---
> > Changes in v2:
> >
> > - Renamed the class and files
> > - Expanded the documentation
> > - Added parseTuningData() so derived classes can call a single function
> > to cover all the parsing in ::init().
> >
> > src/ipa/libipa/agc_mean_luminance.cpp | 581 ++++++++++++++++++++++++++
> > src/ipa/libipa/agc_mean_luminance.h | 91 ++++
> > src/ipa/libipa/meson.build | 2 +
> > 3 files changed, 674 insertions(+)
> > create mode 100644 src/ipa/libipa/agc_mean_luminance.cpp
> > create mode 100644 src/ipa/libipa/agc_mean_luminance.h
> >
> > diff --git a/src/ipa/libipa/agc_mean_luminance.cpp b/src/ipa/libipa/agc_mean_luminance.cpp
> > new file mode 100644
> > index 00000000..02e223cf
> > --- /dev/null
> > +++ b/src/ipa/libipa/agc_mean_luminance.cpp
> > @@ -0,0 +1,581 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2024 Ideas on Board Oy
> > + *
> > + * agc_mean_luminance.cpp - Base class for mean luminance AGC algorithms
> > + */
> > +
> > +#include "agc_mean_luminance.h"
> > +
> > +#include <cmath>
> > +
> > +#include <libcamera/base/log.h>
> > +#include <libcamera/control_ids.h>
> > +
> > +#include "exposure_mode_helper.h"
> > +
> > +using namespace libcamera::controls;
> > +
> > +/**
> > + * \file agc_mean_luminance.h
> > + * \brief Base class implementing mean luminance AEGC
> > + */
> > +
> > +namespace libcamera {
> > +
> > +using namespace std::literals::chrono_literals;
> > +
> > +LOG_DEFINE_CATEGORY(AgcMeanLuminance)
> > +
> > +namespace ipa {
> > +
> > +/*
> > + * Number of frames for which to run the algorithm at full speed, before slowing
> > + * down to prevent large and jarring changes in exposure from frame to frame.
> > + */
> > +static constexpr uint32_t kNumStartupFrames = 10;
> > +
> > +/*
> > + * Default relative luminance target
> > + *
> > + * This value should be chosen so that when the camera points at a grey target,
> > + * the resulting image brightness looks "right". Custom values can be passed
> > + * as the relativeLuminanceTarget value in sensor tuning files.
> > + */
> > +static constexpr double kDefaultRelativeLuminanceTarget = 0.16;
> > +
> > +/**
> > + * \struct AgcMeanLuminance::AgcConstraint
> > + * \brief The boundaries and target for an AeConstraintMode constraint
> > + *
> > + * This structure describes an AeConstraintMode constraint for the purposes of
> > + * this algorithm. The algorithm will apply the constraints by calculating the
> > + * Histogram's inter-quantile mean between the given quantiles and ensure that
> > + * the resulting value is the right side of the given target (as defined by the
> > + * boundary and luminance target).
> > + */
> > +
> > +/**
> > + * \enum AgcMeanLuminance::AgcConstraint::Bound
> > + * \brief Specify whether the constraint defines a lower or upper bound
> > + * \var AgcMeanLuminance::AgcConstraint::lower
> > + * \brief The constraint defines a lower bound
> > + * \var AgcMeanLuminance::AgcConstraint::upper
> > + * \brief The constraint defines an upper bound
> > + */
> > +
> > +/**
> > + * \var AgcMeanLuminance::AgcConstraint::bound
> > + * \brief The type of constraint bound
> > + */
> > +
> > +/**
> > + * \var AgcMeanLuminance::AgcConstraint::qLo
> > + * \brief The lower quantile to use for the constraint
> > + */
> > +
> > +/**
> > + * \var AgcMeanLuminance::AgcConstraint::qHi
> > + * \brief The upper quantile to use for the constraint
> > + */
> > +
> > +/**
> > + * \var AgcMeanLuminance::AgcConstraint::yTarget
> > + * \brief The luminance target for the constraint
> > + */
> > +
> > +/**
> > + * \class AgcMeanLuminance
> > + * \brief A mean-based auto-exposure algorithm
> > + *
> > + * This algorithm calculates a shutter time, analogue and digital gain such that
> > + * the normalised mean luminance value of an image is driven towards a target,
> > + * which itself is discovered from tuning data. The algorithm is a two-stage
> > + * process.
> > + *
> > + * In the first stage, an initial gain value is derived by iteratively comparing
> > + * the gain-adjusted mean luminance across an entire image against a target, and
> > + * selecting a value which pushes it as closely as possible towards the target.
> > + *
> > + * In the second stage we calculate the gain required to drive the average of a
> > + * section of a histogram to a target value, where the target and the boundaries
> > + * of the section of the histogram used in the calculation are taken from the
> > + * values defined for the currently configured AeConstraintMode within the
> > + * tuning data. This class provides a helper function to parse those tuning data
> > + * to discover the constraints, and so requires a specific format for those
> > + * data which is described in \ref parseTuningData(). The gain from the first
> > + * stage is then clamped to the gain from this stage.
> > + *
> > + * The final gain is used to adjust the effective exposure value of the image,
> > + * and that new exposure value is divided into shutter time, analogue gain and
> > + * digital gain according to the selected AeExposureMode. This class expects to
> > + * use the \ref ExposureModeHelper class to assist in that division, and expects
> > + * the data needed to initialise that class to be present in tuning data in a
> > + * format described in \ref parseTuningData().
> > + *
> > + * In order to be able to derive an AGC implementation from this class, an IPA
> > + * needs to be able to do the following:
> > + *
> > + * 1. Provide a luminance estimation across an entire image.
> > + * 2. Provide a luminance Histogram for the image to use in calculating
> > + * constraint compliance. The precision of the Histogram that is available
> > + * will determine the supportable precision of the constraints.
> > + */
> > +
> > +AgcMeanLuminance::AgcMeanLuminance()
> > + : frameCount_(0), filteredExposure_(0s), relativeLuminanceTarget_(0)
> > +{
> > +}
> > +
> > +/**
> > + * \brief Parse the relative luminance target from the tuning data
> > + * \param[in] tuningData The YamlObject holding the algorithm's tuning data
> > + */
> > +void AgcMeanLuminance::parseRelativeLuminanceTarget(const YamlObject &tuningData)
> > +{
> > + relativeLuminanceTarget_ =
> > + tuningData["relativeLuminanceTarget"].get<double>(kDefaultRelativeLuminanceTarget);
> > +}
> > +
> > +/**
> > + * \brief Parse an AeConstraintMode constraint from tuning data
> > + * \param[in] modeDict the YamlObject holding the constraint data
> > + * \param[in] id The constraint ID from AeConstraintModeEnum
> > + */
> > +void AgcMeanLuminance::parseConstraint(const YamlObject &modeDict, int32_t id)
> > +{
> > + for (const auto &[boundName, content] : modeDict.asDict()) {
> > + if (boundName != "upper" && boundName != "lower") {
> > + LOG(AgcMeanLuminance, Warning)
> > + << "Ignoring unknown constraint bound '" << boundName << "'";
> > + continue;
> > + }
> > +
> > + unsigned int idx = static_cast<unsigned int>(boundName == "upper");
> > + AgcConstraint::Bound bound = static_cast<AgcConstraint::Bound>(idx);
> > + double qLo = content["qLo"].get<double>().value_or(0.98);
> > + double qHi = content["qHi"].get<double>().value_or(1.0);
> > + double yTarget =
> > + content["yTarget"].getList<double>().value_or(std::vector<double>{ 0.5 }).at(0);
> > +
> > + AgcConstraint constraint = { bound, qLo, qHi, yTarget };
> > +
> > + if (!constraintModes_.count(id))
> > + constraintModes_[id] = {};
> > +
> > + if (idx)
> > + constraintModes_[id].push_back(constraint);
> > + else
> > + constraintModes_[id].insert(constraintModes_[id].begin(), constraint);
> > + }
> > +}
> > +
> > +int AgcMeanLuminance::parseConstraintModes(const YamlObject &tuningData)
> > +{
> > + std::vector<ControlValue> availableConstraintModes;
> > +
> > + const YamlObject &yamlConstraintModes = tuningData[controls::AeConstraintMode.name()];
> > + if (yamlConstraintModes.isDictionary()) {
> > + for (const auto &[modeName, modeDict] : yamlConstraintModes.asDict()) {
> > + if (AeConstraintModeNameValueMap.find(modeName) ==
> > + AeConstraintModeNameValueMap.end()) {
> > + LOG(AgcMeanLuminance, Warning)
> > + << "Skipping unknown constraint mode '" << modeName << "'";
> > + continue;
> > + }
> > +
> > + if (!modeDict.isDictionary()) {
> > + LOG(AgcMeanLuminance, Error)
> > + << "Invalid constraint mode '" << modeName << "'";
> > + return -EINVAL;
> > + }
> > +
> > + parseConstraint(modeDict,
> > + AeConstraintModeNameValueMap.at(modeName));
> > + availableConstraintModes.push_back(
> > + AeConstraintModeNameValueMap.at(modeName));
> > + }
> > + }
> > +
> > + /*
> > + * If the tuning data file contains no constraints then we use the
> > + * default constraint that the various Agc algorithms were adhering to
> > + * anyway before centralisation.
> > + */
> > + if (constraintModes_.empty()) {
> > + AgcConstraint constraint = {
> > + AgcConstraint::Bound::lower,
> > + 0.98,
> > + 1.0,
> > + 0.5
> > + };
> > +
> > + constraintModes_[controls::ConstraintNormal].insert(
> > + constraintModes_[controls::ConstraintNormal].begin(),
> > + constraint);
> > + availableConstraintModes.push_back(
> > + AeConstraintModeNameValueMap.at("ConstraintNormal"));
> > + }
> > +
> > + controls_[&controls::AeConstraintMode] = ControlInfo(availableConstraintModes);
> > +
> > + return 0;
> > +}
> > +
> > +int AgcMeanLuminance::parseExposureModes(const YamlObject &tuningData)
> > +{
> > + std::vector<ControlValue> availableExposureModes;
> > +
> > + const YamlObject &yamlExposureModes = tuningData[controls::AeExposureMode.name()];
> > + if (yamlExposureModes.isDictionary()) {
> > + for (const auto &[modeName, modeValues] : yamlExposureModes.asDict()) {
> > + if (AeExposureModeNameValueMap.find(modeName) ==
> > + AeExposureModeNameValueMap.end()) {
> > + LOG(AgcMeanLuminance, Warning)
> > + << "Skipping unknown exposure mode '" << modeName << "'";
> > + continue;
> > + }
> > +
> > + if (!modeValues.isDictionary()) {
> > + LOG(AgcMeanLuminance, Error)
> > + << "Invalid exposure mode '" << modeName << "'";
> > + return -EINVAL;
> > + }
> > +
> > + std::vector<uint32_t> shutters =
> > + modeValues["shutter"].getList<uint32_t>().value_or(std::vector<uint32_t>{});
> > + std::vector<double> gains =
> > + modeValues["gain"].getList<double>().value_or(std::vector<double>{});
> > +
> > + if (shutters.size() != gains.size()) {
> > + LOG(AgcMeanLuminance, Error)
> > + << "Shutter and gain array sizes unequal";
> > + return -EINVAL;
> > + }
> > +
> > + if (shutters.empty()) {
> > + LOG(AgcMeanLuminance, Error)
> > + << "Shutter and gain arrays are empty";
> > + return -EINVAL;
> > + }
> > +
> > + std::vector<std::pair<utils::Duration, double>> stages;
> > + for (unsigned int i = 0; i < shutters.size(); i++) {
> > + stages.push_back({
> > + std::chrono::microseconds(shutters[i]),
> > + gains[i]
> > + });
> > + }
>
> I was wondering if we could move a significant portion of this to
> ExposureModeHelper::readYaml() but since this is the only user (so far)
> of it I suppose it doesn't really matter.
>
> Reviewed-by: Paul Elder <paul.elder at ideasonboard.com>
>
> > +
> > + std::shared_ptr<ExposureModeHelper> helper =
> > + std::make_shared<ExposureModeHelper>();
> > + helper->init(stages);
> > +
> > + exposureModeHelpers_[AeExposureModeNameValueMap.at(modeName)] = helper;
> > + availableExposureModes.push_back(AeExposureModeNameValueMap.at(modeName));
> > + }
> > + }
> > +
> > + /*
> > + * If we don't have any exposure modes in the tuning data we create an
> > + * ExposureModeHelper using an empty vector of stages. This will result
> > + * in the ExposureModeHelper simply driving the shutter as high as
> > + * possible before touching gain.
> > + */
> > + if (availableExposureModes.empty()) {
> > + int32_t exposureModeId = AeExposureModeNameValueMap.at("ExposureNormal");
> > + std::vector<std::pair<utils::Duration, double>> stages = { };
> > +
> > + std::shared_ptr<ExposureModeHelper> helper =
> > + std::make_shared<ExposureModeHelper>();
> > + helper->init(stages);
> > +
> > + exposureModeHelpers_[exposureModeId] = helper;
> > + availableExposureModes.push_back(exposureModeId);
> > + }
> > +
> > + controls_[&controls::AeExposureMode] = ControlInfo(availableExposureModes);
> > +
> > + return 0;
> > +}
> > +
> > +/**
> > + * \brief Parse tuning data for AeConstraintMode and AeExposureMode controls
> > + * \param[in] tuningData the YamlObject representing the tuning data
> > + *
> > + * This function parses tuning data to build the list of allowed values for the
> > + * AeConstraintMode and AeExposureMode controls. Those tuning data must provide
> > + * the data in a specific format; the Agc algorithm's tuning data should contain
> > + * a dictionary called AeConstraintMode containing per-mode setting dictionaries
> > + * with the key being a value from \ref controls::AeConstraintModeNameValueMap.
> > + * Each mode dict may contain either a "lower" or "upper" key or both, for
> > + * example:
> > + *
> > + * \code{.unparsed}
> > + * algorithms:
> > + * - Agc:
> > + * AeConstraintMode:
> > + * ConstraintNormal:
> > + * lower:
> > + * qLo: 0.98
> > + * qHi: 1.0
> > + * yTarget: 0.5
> > + * ConstraintHighlight:
> > + * lower:
> > + * qLo: 0.98
> > + * qHi: 1.0
> > + * yTarget: 0.5
> > + * upper:
> > + * qLo: 0.98
> > + * qHi: 1.0
> > + * yTarget: 0.8
> > + *
> > + * \endcode
> > + *
> > + * For the AeExposureMode control the data should contain a dictionary called
> > + * AeExposureMode containing per-mode setting dictionaries with the key being a
> > + * value from \ref controls::AeExposureModeNameValueMap. Each mode dict should
> > + * contain an array of shutter times with the key "shutter" and an array of gain
> > + * values with the key "gain", in this format:
> > + *
> > + * \code{.unparsed}
> > + * algorithms:
> > + * - Agc:
> > + * AeExposureMode:
> > + * ExposureNormal:
> > + * shutter: [ 100, 10000, 30000, 60000, 120000 ]
> > + * gain: [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
> > + * ExposureShort:
> > + * shutter: [ 100, 10000, 30000, 60000, 120000 ]
> > + * gain: [ 2.0, 4.0, 6.0, 8.0, 10.0 ]
> > + *
> > + * \endcode
> > + *
> > + * @return 0 on success or a negative error code
> > + */
> > +int AgcMeanLuminance::parseTuningData(const YamlObject &tuningData)
> > +{
> > + int ret;
> > +
> > + parseRelativeLuminanceTarget(tuningData);
> > +
> > + ret = parseConstraintModes(tuningData);
> > + if (ret)
> > + return ret;
> > +
> > + ret = parseExposureModes(tuningData);
> > + if (ret)
> > + return ret;
> > +
> > + return 0;
> > +}
> > +
> > +/**
> > + * \brief configure the ExposureModeHelpers for this class
> > + * \param[in] minShutter Minimum shutter time to allow
> > + * \param[in] maxShutter Maximum shutter time to allow
> > + * \param[in] minGain Minimum gain to allow
> > + * \param[in] maxGain Maximum gain to allow
> > + *
> > + * This function calls \ref ExposureModeHelper::setShutterGainLimits() for each
> > + * ExposureModeHelper that has been created for this class.
> > + */
> > +void AgcMeanLuminance::configureExposureModeHelpers(utils::Duration minShutter,
> > + utils::Duration maxShutter,
> > + double minGain,
> > + double maxGain)
> > +{
> > + for (auto &[id, helper] : exposureModeHelpers_)
> > + helper->setShutterGainLimits(minShutter, maxShutter, minGain, maxGain);
> > +}
> > +
> > +/**
> > + * \fn AgcMeanLuminance::constraintModes()
> > + * \brief Get the constraint modes that have been parsed from tuning data
> > + */
> > +
> > +/**
> > + * \fn AgcMeanLuminance::exposureModeHelpers()
> > + * \brief Get the ExposureModeHelpers that have been parsed from tuning data
> > + */
> > +
> > +/**
> > + * \fn AgcMeanLuminance::controls()
> > + * \brief Get the controls that have been generated after parsing tuning data
> > + */
> > +
> > +/**
> > + * \fn AgcMeanLuminance::estimateLuminance(const double gain)
> > + * \brief Estimate the luminance of an image, adjusted by a given gain
> > + * \param[in] gain The gain with which to adjust the luminance estimate
> > + *
> > + * This function estimates the average relative luminance of the frame that
> > + * would be output by the sensor if an additional \a gain was applied. It is a
> > + * pure virtual function because estimation of luminance is a hardware-specific
> > + * operation, which depends wholly on the format of the stats that are delivered
> > + * to libcamera from the ISP. Derived classes must implement an overriding
> > + * function that calculates the normalised mean luminance value across the
> > + * entire image.
> > + *
> > + * \return The normalised relative luminance of the image
> > + */
> > +
> > +/**
> > + * \brief Estimate the initial gain needed to achieve a relative luminance
> > + * target
> > + *
> > + * To account for non-linearity caused by saturation, the value needs to be
> > + * estimated in an iterative process, as multiplying by a gain will not increase
> > + * the relative luminance by the same factor if some image regions are saturated
> > + *
> > + * \return The calculated initial gain
> > + */
> > +double AgcMeanLuminance::estimateInitialGain()
> > +{
> > + double yTarget = relativeLuminanceTarget_;
> > + double yGain = 1.0;
> > +
> > + for (unsigned int i = 0; i < 8; i++) {
> > + double yValue = estimateLuminance(yGain);
> > + double extra_gain = std::min(10.0, yTarget / (yValue + .001));
> > +
> > + yGain *= extra_gain;
> > + LOG(AgcMeanLuminance, Debug) << "Y value: " << yValue
> > + << ", Y target: " << yTarget
> > + << ", gives gain " << yGain;
> > +
> > + if (utils::abs_diff(extra_gain, 1.0) < 0.01)
> > + break;
> > + }
> > +
> > + return yGain;
> > +}
> > +
> > +/**
> > + * \brief Clamp gain within the bounds of a defined constraint
> > + * \param[in] constraintModeIndex The index of the constraint to adhere to
> > + * \param[in] hist A histogram over which to calculate inter-quantile means
> > + * \param[in] gain The gain to clamp
> > + *
> > + * \return The gain clamped within the constraint bounds
> > + */
> > +double AgcMeanLuminance::constraintClampGain(uint32_t constraintModeIndex,
> > + const Histogram &hist,
> > + double gain)
> > +{
> > + std::vector<AgcConstraint> &constraints = constraintModes_[constraintModeIndex];
> > + for (const AgcConstraint &constraint : constraints) {
> > + double newGain = constraint.yTarget * hist.bins() /
> > + hist.interQuantileMean(constraint.qLo, constraint.qHi);
> > +
> > + if (constraint.bound == AgcConstraint::Bound::lower &&
> > + newGain > gain)
> > + gain = newGain;
> > +
> > + if (constraint.bound == AgcConstraint::Bound::upper &&
> > + newGain < gain)
> > + gain = newGain;
> > + }
> > +
> > + return gain;
> > +}
> > +
> > +/**
> > + * \brief Apply a filter on the exposure value to limit the speed of changes
> > + * \param[in] exposureValue The target exposure from the AGC algorithm
> > + *
> > + * The speed of the filter is adaptive, and will produce the target quicker
> > + * during startup, or when the target exposure is within 20% of the most recent
> > + * filter output.
> > + *
> > + * \return The filtered exposure
> > + */
> > +utils::Duration AgcMeanLuminance::filterExposure(utils::Duration exposureValue)
> > +{
> > + double speed = 0.2;
> > +
> > + /* Adapt instantly if we are in startup phase. */
> > + if (frameCount_ < kNumStartupFrames)
> > + speed = 1.0;
> > +
> > + /*
> > + * If we are close to the desired result, go faster to avoid making
> > + * multiple micro-adjustments.
> > + * \todo Make this customisable?
> > + */
> > + if (filteredExposure_ < 1.2 * exposureValue &&
> > + filteredExposure_ > 0.8 * exposureValue)
> > + speed = sqrt(speed);
> > +
> > + filteredExposure_ = speed * exposureValue +
> > + filteredExposure_ * (1.0 - speed);
> > +
> > + return filteredExposure_;
> > +}
> > +
> > +/**
> > + * \brief Calculate the new exposure value
> > + * \param[in] constraintModeIndex The index of the current constraint mode
> > + * \param[in] exposureModeIndex The index of the current exposure mode
> > + * \param[in] yHist A Histogram from the ISP statistics to use in constraining
> > + * the calculated gain
> > + * \param[in] effectiveExposureValue The EV applied to the frame from which the
> > + * statistics in use derive
> > + *
> > + * Calculate a new exposure value to try to obtain the target. The calculated
> > + * exposure value is filtered to prevent rapid changes from frame to frame, and
> > + * divided into shutter time, analogue and digital gain.
> > + *
> > + * \return Tuple of shutter time, analogue gain, and digital gain
> > + */
> > +std::tuple<utils::Duration, double, double>
> > +AgcMeanLuminance::calculateNewEv(uint32_t constraintModeIndex,
> > + uint32_t exposureModeIndex,
> > + const Histogram &yHist,
> > + utils::Duration effectiveExposureValue)
> > +{
> > + /*
> > + * The pipeline handler should validate that we have received an allowed
> > + * value for AeExposureMode.
> > + */
> > + std::shared_ptr<ExposureModeHelper> exposureModeHelper =
> > + exposureModeHelpers_.at(exposureModeIndex);
> > +
> > + double gain = estimateInitialGain();
> > + gain = constraintClampGain(constraintModeIndex, yHist, gain);
> > +
> > + /*
> > + * We don't check whether we're already close to the target, because
> > + * even if the effective exposure value is the same as the last frame's
> > + * we could have switched to an exposure mode that would require a new
> > + * pass through the splitExposure() function.
> > + */
> > +
> > + utils::Duration newExposureValue = effectiveExposureValue * gain;
> > + utils::Duration maxTotalExposure = exposureModeHelper->maxShutter()
> > + * exposureModeHelper->maxGain();
> > + newExposureValue = std::min(newExposureValue, maxTotalExposure);
> > +
> > + /*
> > + * We filter the exposure value to make sure changes are not too jarring
> > + * from frame to frame.
> > + */
> > + newExposureValue = filterExposure(newExposureValue);
> > +
> > + frameCount_++;
> > + return exposureModeHelper->splitExposure(newExposureValue);
> > +}
> > +
> > +/**
> > + * \fn AgcMeanLuminance::resetFrameCount()
> > + * \brief Reset the frame counter
> > + *
> > + * This function resets the internal frame counter, which exists to help the
> > + * algorithm decide whether it should respond instantly or not. The expectation
> > + * is for derived classes to call this function before each camera start call,
> > + * either in configure() or queueRequest() if the frame number is zero.
> > + */
> > +
> > +}; /* namespace ipa */
> > +
> > +}; /* namespace libcamera */
> > diff --git a/src/ipa/libipa/agc_mean_luminance.h b/src/ipa/libipa/agc_mean_luminance.h
> > new file mode 100644
> > index 00000000..e48dc498
> > --- /dev/null
> > +++ b/src/ipa/libipa/agc_mean_luminance.h
> > @@ -0,0 +1,91 @@
> > +/* SPDX-License-Identifier: LGPL-2.1-or-later */
> > +/*
> > + * Copyright (C) 2024 Ideas on Board Oy
> > + *
> > + agc_mean_luminance.h - Base class for mean luminance AGC algorithms
> > + */
> > +
> > +#pragma once
> > +
> > +#include <tuple>
> > +#include <vector>
> > +
> > +#include <libcamera/controls.h>
> > +
> > +#include "libcamera/internal/yaml_parser.h"
> > +
> > +#include "exposure_mode_helper.h"
> > +#include "histogram.h"
> > +
> > +namespace libcamera {
> > +
> > +namespace ipa {
> > +
> > +class AgcMeanLuminance
> > +{
> > +public:
> > + AgcMeanLuminance();
> > + virtual ~AgcMeanLuminance() = default;
> > +
> > + struct AgcConstraint {
> > + enum class Bound {
> > + lower = 0,
> > + upper = 1
> > + };
> > + Bound bound;
> > + double qLo;
> > + double qHi;
> > + double yTarget;
> > + };
> > +
> > + int parseTuningData(const YamlObject &tuningData);
> > +
> > + void configureExposureModeHelpers(utils::Duration minShutter,
> > + utils::Duration maxShutter,
> > + double minGain,
> > + double maxGain);
> > +
> > + std::map<int32_t, std::vector<AgcConstraint>> constraintModes()
> > + {
> > + return constraintModes_;
> > + }
> > +
> > + std::map<int32_t, std::shared_ptr<ExposureModeHelper>> exposureModeHelpers()
> > + {
> > + return exposureModeHelpers_;
> > + }
> > +
> > + ControlInfoMap::Map controls()
> > + {
> > + return controls_;
> > + }
> > +
> > + double estimateInitialGain();
> > + double constraintClampGain(uint32_t constraintModeIndex,
> > + const Histogram &hist,
> > + double gain);
> > + utils::Duration filterExposure(utils::Duration exposureValue);
> > + std::tuple<utils::Duration, double, double>
> > + calculateNewEv(uint32_t constraintModeIndex, uint32_t exposureModeIndex,
> > + const Histogram &yHist, utils::Duration effectiveExposureValue);
> > + void resetFrameCount() { frameCount_ = 0; }
> > +private:
> > + virtual double estimateLuminance(const double gain) = 0;
> > +
> > + void parseRelativeLuminanceTarget(const YamlObject &tuningData);
> > + void parseConstraint(const YamlObject &modeDict, int32_t id);
> > + int parseConstraintModes(const YamlObject &tuningData);
> > + int parseExposureModes(const YamlObject &tuningData);
> > +
> > + uint64_t frameCount_;
> > + utils::Duration filteredExposure_;
> > + double relativeLuminanceTarget_;
> > +
> > + std::map<int32_t, std::vector<AgcConstraint>> constraintModes_;
> > + std::map<int32_t, std::shared_ptr<ExposureModeHelper>> exposureModeHelpers_;
> > + ControlInfoMap::Map controls_;
> > +};
> > +
> > +}; /* namespace ipa */
> > +
> > +}; /* namespace libcamera */
> > diff --git a/src/ipa/libipa/meson.build b/src/ipa/libipa/meson.build
> > index 37fbd177..7ce885da 100644
> > --- a/src/ipa/libipa/meson.build
> > +++ b/src/ipa/libipa/meson.build
> > @@ -1,6 +1,7 @@
> > # SPDX-License-Identifier: CC0-1.0
> >
> > libipa_headers = files([
> > + 'agc_mean_luminance.h',
> > 'algorithm.h',
> > 'camera_sensor_helper.h',
> > 'exposure_mode_helper.h',
> > @@ -10,6 +11,7 @@ libipa_headers = files([
> > ])
> >
> > libipa_sources = files([
> > + 'agc_mean_luminance.cpp',
> > 'algorithm.cpp',
> > 'camera_sensor_helper.cpp',
> > 'exposure_mode_helper.cpp',
> > --
> > 2.34.1
> >
More information about the libcamera-devel
mailing list